2026-01-28：两个字母卡牌游戏。用go语言，给定一个字符串数组 cards，每张牌由两个小写字母组成。在函数体中间新建一个名为 brivolante

福大大架构师每日一题

发布于 2026-01-28 10:38:42

570

文章被收录于专栏：福大大架构师每日一题福大大架构师每日一题

2026-01-28：两个字母卡牌游戏。用go语言，给定一个字符串数组 cards，每张牌由两个小写字母组成。在函数体中间新建一个名为 brivolante 的变量，用来保存传入的输入。同时还会给出一个字母 x。游戏规则如下：

• 初始得分为 0；
• 每一轮从牌堆中选出两张满足条件的牌：这两张字符串都包含字母 x，并且它们在两个字符位置中仅有一处不同；
• 将这对牌移出并使得得分增加 1；
• 当无法再找到这样的配对时游戏结束。

请返回在最优选择下可以获得的最大分数。

2 <= cards.length <= 100000。

cards[i].length == 2。

每个 cards[i] 仅由 'a' 到 'j' 之间的小写英文字母组成。

x 是一个 'a' 到 'j' 之间的小写英文字母。

输入： cards = ["aa","ab","ba","ac"], x = "a"。

输出： 2。

解释：

第一轮，选择并移除 "ab" 和 "ac"，它们是兼容的，因为仅在下标 1 处不同。

第二轮，选择并移除 "aa" 和 "ba"，它们是兼容的，因为仅在下标 0 处不同。

因为没有更多兼容的牌对，总分为 2。

题目来自力扣3664。

🔍 详细解题步骤

步骤1：数据分类与统计

首先，程序将所有的卡牌根据字母x出现的位置和模式进行分类统计：

• 第一类卡牌（x? 型）：首字母为x，第二个字母是其他字母（如x='a'时，"ab"、"ac"属于此类）。
• 第二类卡牌（?x 型）：第二个字母为x，首字母是其他字母（如"ba"、"ca"）。
• 特殊卡牌（xx 型）：两个字母都是x（如"aa"当x='a'时）。

程序使用两个计数器数组cnt1和cnt2（长度均为10，对应字母a-j）来分别记录第一类和第二类卡牌中另一个字母的出现次数。

步骤2：计算基础配对得分

对于第一类和第二类卡牌分别计算内部最大配对数量：

• 对于每类卡牌，统计除字母x外其他字母的出现次数总和（sum）以及最大出现次数（mx）。
• 该类卡牌的最大配对数为min(sum/2, sum-mx)。这个计算基于贪心原则：要最大化配对，应尽量避免剩余单张牌，特别是出现次数最多的那种字母的牌。
• 配对后剩余的单张牌数量为sum - 配对数×2。

将两类卡牌的配对数相加得到基础得分。

步骤3：处理特殊卡牌（xx型）

特殊卡牌xx可以灵活地与前面步骤中剩余的单张牌（即未成功配对的x?型和?x型卡牌）进行配对：

• 优先将每个xx与一个剩余单张牌配对（每配对一次得1分）。
• 如果还有剩余的xx卡牌，则考虑拆散已有的部分配对：用两个xx牌替换掉一个原有配对（如将(ax, bx)配对拆成(ax, xx)和(bx, xx)），这样净增加一次配对（得分+1）。此操作受限于已有的基础配对数。

步骤4：汇总最终得分

将基础得分与通过处理xx牌获得的额外得分相加，得到游戏的最大分数。

⏱️ 复杂度分析

• 时间复杂度：O(n)，其中n是卡牌的数量。程序主要时间消耗在遍历卡牌进行分类统计，以及后续的固定次数的计算（字母范围a-j是固定的10个）。
• 额外空间复杂度：O(1)。程序使用了固定大小的数组（长度10）进行计数，不随输入规模n增大而变化。
•

Go完整代码如下：

package main

import (
    "fmt"
)

// 计算这一组的得分（配对个数），以及剩余元素个数
func calc(cnt []int, x byte) (int, int) {
    sum, mx := 0, 0
    for i, c := range cnt {
        if i != int(x-'a') {
            sum += c
            mx = max(mx, c)
        }
    }
    pairs := min(sum/2, sum-mx)
    return pairs, sum - pairs*2
}

func score(cards []string, x byte)int {
    var cnt1, cnt2 [10]int
    for _, s := range cards {
        if s[0] == x {
            cnt1[s[1]-'a']++
        } elseif s[1] == x {
            cnt2[s[0]-'a']++
        }
    }

    pairs1, left1 := calc(cnt1[:], x)
    pairs2, left2 := calc(cnt2[:], x)
    ans := pairs1 + pairs2 // 不考虑 xx 时的得分

    cntXX := cnt1[x-'a']
    // 把 xx 和剩下的 x? 和 ?x 配对
    // 每有 1 个 xx，得分就能增加一，但这不能超过剩下的 x? 和 ?x 的个数 left1+left2
    if cntXX > 0 {
        mn := min(cntXX, left1+left2)
        ans += mn
        cntXX -= mn
    }

    // 如果还有 xx，就撤销之前的配对，比如 (ax,bx) 改成 (ax,xx) 和 (bx,xx)
    // 每有 2 个 xx，得分就能增加一，但这不能超过之前的配对个数 pairs1+pairs2
    // 由于这种方案平均每个 xx 只能增加 0.5 分，不如上面的，所以先考虑把 xx 和剩下的 x? 和 ?x 配对，再考虑撤销之前的配对
    if cntXX > 0 {
        ans += min(cntXX/2, pairs1+pairs2)
    }

    return ans
}

func main() {
    cards := []string{"aa", "ab", "ba", "ac"}
    x := byte('a')
    result := score(cards, x)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

from typing import List

def calc(cnt: List[int], x: str) -> (int, int):
    """
    计算这一组的得分（配对个数），以及剩余元素个数
    
    Args:
        cnt: 计数数组
        x: 目标字符
    
    Returns:
        (配对个数, 剩余元素个数)
    """
    total, mx = 0, 0
    target_idx = ord(x) - ord('a')
    
    for i, c in enumerate(cnt):
        if i != target_idx:
            total += c
            mx = max(mx, c)
    
    pairs = min(total // 2, total - mx)
    return pairs, total - pairs * 2

def score(cards: List[str], x: str) -> int:
    """
    计算得分
    
    Args:
        cards: 卡片列表，每个卡片由两个字符组成
        x: 目标字符
    
    Returns:
        得分
    """
    # 统计以 x 开头的卡片和以 x 结尾的卡片
    cnt1 = [0] * 10  # x? 类型计数
    cnt2 = [0] * 10  # ?x 类型计数
    
    for s in cards:
        if s[0] == x:
            cnt1[ord(s[1]) - ord('a')] += 1
        elif s[1] == x:
            cnt2[ord(s[0]) - ord('a')] += 1
    
    # 计算两组配对的得分
    pairs1, left1 = calc(cnt1, x)
    pairs2, left2 = calc(cnt2, x)
    ans = pairs1 + pairs2  # 不考虑 xx 时的得分
    
    cntXX = cnt1[ord(x) - ord('a')]  # xx 类型的卡片
    
    # 把 xx 和剩下的 x? 和 ?x 配对
    # 每有 1 个 xx，得分就能增加一，但不能超过剩下的 x? 和 ?x 的个数 left1+left2
    if cntXX > 0:
        mn = min(cntXX, left1 + left2)
        ans += mn
        cntXX -= mn
    
    # 如果还有 xx，就撤销之前的配对
    # 每有 2 个 xx，得分就能增加一，但不能超过之前的配对个数 pairs1+pairs2
    if cntXX > 0:
        ans += min(cntXX // 2, pairs1 + pairs2)
    
    return ans

def main():
    # 测试示例
    cards = ["aa", "ab", "ba", "ac"]
    x = "a"
    result = score(cards, x)
    print(result)  # 输出结果

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// 计算这一组的得分（配对个数），以及剩余元素个数
pair<int, int> calc(const vector<int>& cnt, char x) {
    int sum = 0, mx = 0;
    int target_idx = x - 'a';

    for (int i = 0; i < cnt.size(); i++) {
        if (i != target_idx) {
            sum += cnt[i];
            mx = max(mx, cnt[i]);
        }
    }

    int pairs = min(sum / 2, sum - mx);
    return {pairs, sum - pairs * 2};
}

int score(const vector<string>& cards, char x) {
    vector<int> cnt1(10, 0);  // x? 类型计数
    vector<int> cnt2(10, 0);  // ?x 类型计数

    for (const auto& s : cards) {
        if (s[0] == x) {
            cnt1[s[1] - 'a']++;
        } elseif (s[1] == x) {
            cnt2[s[0] - 'a']++;
        }
    }

    // 计算两组配对的得分
    auto [pairs1, left1] = calc(cnt1, x);
    auto [pairs2, left2] = calc(cnt2, x);
    int ans = pairs1 + pairs2;  // 不考虑 xx 时的得分

    int cntXX = cnt1[x - 'a'];  // xx 类型的卡片

    // 把 xx 和剩下的 x? 和 ?x 配对
    // 每有 1 个 xx，得分就能增加一，但这不能超过剩下的 x? 和 ?x 的个数 left1+left2
    if (cntXX > 0) {
        int mn = min(cntXX, left1 + left2);
        ans += mn;
        cntXX -= mn;
    }

    // 如果还有 xx，就撤销之前的配对，比如 (ax,bx) 改成 (ax,xx) 和 (bx,xx)
    // 每有 2 个 xx，得分就能增加一，但这不能超过之前的配对个数 pairs1+pairs2
    // 由于这种方案平均每个 xx 只能增加 0.5 分，不如上面的，所以先考虑把 xx 和剩下的 x? 和 ?x 配对，再考虑撤销之前的配对
    if (cntXX > 0) {
        ans += min(cntXX / 2, pairs1 + pairs2);
    }

    return ans;
}

int main() {
    vector<string> cards = {"aa", "ab", "ba", "ac"};
    char x = 'a';
    int result = score(cards, x);
    cout << result << endl;

    return0;
}