Easy

题目描述

给你一个整数数组 ranks 和一个字符数组 suits。你有 5 张牌，其中第 i 张牌大小为 ranks[i]，花色为 suits[i]。

下述是从好到坏你能用这些牌组成的手牌类型：

  • “Flush”：同花，五张相同花色的牌。
  • “Three of a Kind”：三条，三张大小相同的牌。
  • “Pair”：对子，两张大小相同的牌。
  • “High Card”：高牌，任意一张单牌。

请你返回一个字符串，表示你能用给定的牌组成的最好手牌类型。

注意：返回的字符串是区分大小写的。

示例 1：

输入：ranks = [13,2,3,1,9], suits = ["a","a","a","a","a"]
输出："Flush"
解释：五张牌都是相同花色，所以返回 "Flush"。

示例 2：

输入：ranks = [4,4,2,4,4], suits = ["d","a","a","b","c"]
输出："Three of a Kind"
解释：第一张、第二张、第四张牌有相同的大小，所以是 "Three of a Kind"。
注意我们也可以组成 "Pair" ，但是 "Three of a Kind" 是更好的手牌类型。

示例 3：

输入：ranks = [10,10,2,12,9], suits = ["a","b","c","a","d"]
输出："Pair"
解释：第一张和第二张牌有相同的大小，所以是 "Pair"。
注意不能组成 "Flush" 或 "Three of a Kind"。

提示：

  • ranks.length == suits.length == 5
  • 1 <= ranks[i] <= 13
  • 'a' <= suits[i] <= 'd'
  • 没有两张牌有相同的大小和花色。

提示： 按照条件 1 到 4 的顺序检查，并返回第一个满足条件的结果。

解题思路

这道题要求我们判断 5 张扑克牌能组成的最佳手牌类型。根据题目要求，我们需要按照优先级从高到低依次检查：

解题思路

  1. 同花（Flush）检查：检查所有 5 张牌是否都是相同花色
  2. 三条（Three of a Kind）检查：统计每种牌面值的出现次数，看是否有牌面值出现 3 次或更多
  3. 对子（Pair）检查：检查是否有牌面值出现 2 次
  4. 高牌（High Card）：如果以上都不满足，则返回高牌

实现方法

我们可以使用哈希表来统计牌面值的出现次数，同时检查花色是否相同。具体步骤：

  1. 遍历所有牌，检查是否所有花色都相同
  2. 使用哈希表统计每种牌面值的出现次数
  3. 根据统计结果，按优先级返回对应的手牌类型

时间复杂度是 O(1)（因为只有 5 张牌），空间复杂度也是 O(1)（哈希表最多存储 5 个不同的牌面值）。

这种方法简洁高效，一次遍历即可得到结果。

代码实现

class Solution {
public:
    string bestHand(vector<int>& ranks, vector<char>& suits) {
        // 检查同花
        bool isFlush = true;
        for (int i = 1; i < 5; i++) {
            if (suits[i] != suits[0]) {
                isFlush = false;
                break;
            }
        }
        if (isFlush) return "Flush";
        
        // 统计每种牌面值的出现次数
        unordered_map<int, int> count;
        for (int rank : ranks) {
            count[rank]++;
        }
        
        // 检查三条
        for (auto& p : count) {
            if (p.second >= 3) {
                return "Three of a Kind";
            }
        }
        
        // 检查对子
        for (auto& p : count) {
            if (p.second == 2) {
                return "Pair";
            }
        }
        
        return "High Card";
    }
};

class Solution:
    def bestHand(self, ranks: List[int], suits: List[str]) -> str:
        # 检查同花
        if len(set(suits)) == 1:
            return "Flush"
        
        # 统计每种牌面值的出现次数
        from collections import Counter
        count = Counter(ranks)
        
        # 检查三条
        if any(cnt >= 3 for cnt in count.values()):
            return "Three of a Kind"
        
        # 检查对子
        if any(cnt == 2 for cnt in count.values()):
            return "Pair"
        
        return "High Card"

public class Solution {
    public string BestHand(int[] ranks, char[] suits) {
        // 检查同花
        bool isFlush = true;
        for (int i = 1; i < 5; i++) {
            if (suits[i] != suits[0]) {
                isFlush = false;
                break;
            }
        }
        if (isFlush) return "Flush";
        
        // 统计每种牌面值的出现次数
        var count = new Dictionary<int, int>();
        foreach (int rank in ranks) {
            count[rank] = count.GetValueOrDefault(rank, 0) + 1;
        }
        
        // 检查三条
        foreach (var kvp in count) {
            if (kvp.Value >= 3) {
                return "Three of a Kind";
            }
        }
        
        // 检查对子
        foreach (var kvp in count) {
            if (kvp.Value == 2) {
                return "Pair";
            }
        }
        
        return "High Card";
    }
}

/**
 * @param {number[]} ranks
 * @param {character[]} suits
 * @return {string}
 */
var bestHand = function(ranks, suits) {
    // Check for flush
    if (new Set(suits).size === 1) {
        return "Flush";
    }
    
    // Count rank frequencies
    const rankCount = {};
    for (let rank of ranks) {
        rankCount[rank] = (rankCount[rank] || 0) + 1;
    }
    
    const maxCount = Math.max(...Object.values(rankCount));
    
    if (maxCount >= 3) {
        return "Three of a Kind";
    } else if (maxCount === 2) {
        return "Pair";
    } else {
        return "High Card";
    }
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型复杂度说明
时间复杂度O(1)固定处理 5 张牌，常数时间
空间复杂度O(1)哈希表最多存储 5 个不同的牌面值

相关题目