UVA131德州扑克之枚举子集

本文探讨了如何通过代码实现德州扑克策略,并详细解释了排序、判断顺子、同花等关键步骤。通过枚举五张牌的组合,优化牌组以达到最佳牌型。

这题就是一个德州扑克的题目,主要是代码写的比较繁琐,可能我写的又繁琐了一点,

转化成十张牌之后然后枚举五的子集,然后从剩下五张牌,牌顶拿牌,这样操作一次,

让自己的牌最大,这里我比较牌的大小的时候排了一下序便于判断顺子和同花,

然后对子和炸弹什么的判断我写的稍微有些繁琐,不过我的思路是很简化的。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<stack>
#include<queue>
#include<climits>
using namespace std;
const int N=1e6+10;
string s[10]={"straight-flush","four-of-a-kind","full-house","flush","straight","three-of-a-kind",
"two-pairs","one-pair","highest-card"};
struct node
{
    int va;
    char ch;
    node() {};
};
node re[10];
int cmp(node a,node b)
{
    if(a.va!=b.va)
        return a.va<b.va;
    else
        return a.ch<b.ch;
}
int tnum(char ch)
{
    if(isdigit(ch))
        return ch-'0';
    else
    {
        if(ch=='T')
            return 10;
        else if(ch=='J')
            return 11;
        else if(ch=='Q')
            return 12;
        else if(ch=='A')
            return 1;
        else
            return 13;
    }
}
int work(node *s)
{
    int tem1=0;
    int tem2=0;
    int i;
    for(i=0;i<4;i++)
    {
        if(s[i].va+1!=s[i+1].va)
        {
            break;
        }
    }
    if(i==4)
        tem1=1;
    if(s[0].va==1&&s[1].va==10&&s[2].va==11&&s[3].va==12&&s[4].va==13)
        tem1=1;
    for(i=0;i<4;i++)
        if(s[i].ch!=s[i+1].ch)
        break;
    if(i==4)
        tem2=1;
    if(tem1&&tem2)
        return 0;
    if((s[0].va==s[1].va&&s[1].va==s[2].va&&s[2].va==s[3].va)||
       (s[1].va==s[2].va&&s[2].va==s[3].va&&s[3].va==s[4].va))
       return 1;
    if((s[0].va==s[1].va&&s[1].va==s[2].va&&s[3].va==s[4].va)||(s[0].va==s[1].va&&s[2].va
        ==s[3].va&&s[3].va==s[4].va))
       return 2;
    if(tem2)
        return 3;
    if(tem1)
        return 4;
    if((s[0].va==s[1].va&&s[1].va==s[2].va)||(s[1].va==s[2].va&&s[2].va==s[3].va)||
      (s[2].va==s[3].va&&s[3].va==s[4].va))
        return 5;
    if((s[0].va==s[1].va&&s[2].va==s[3].va)||(s[0].va==s[1].va&&s[3].va==s[4].va)||(s[1].va
        ==s[2].va&&s[3].va==s[4].va))
            return 6;
    if((s[0].va==s[1].va)||(s[1].va==s[2].va)||(s[2].va==s[3].va)||(s[3].va==s[4].va))
        return 7;
    return 8;
}
int pset()
{
    node tem[5];
    int Min=20;
    for(int i=0;i<(1<<5);i++)
    {
        memcpy(tem,re,sizeof(tem));
        int tl=5;
        for(int j=0;j<5;j++)
        {
            if(i&(1<<j))
            {
               tem[j].va=re[tl].va;
               tem[j].ch=re[tl].ch;
               tl++;
            }
        }
        sort(tem,tem+5,cmp);
        int vis=work(tem);
        Min=min(Min,vis);
    }
    return Min;
}
char tch(int num)
{
    if(num>1&&num<10)
        return ('0'+num);
    else
    {
        if(num==10)
            return 'T';
        else if(num==11)
            return 'J';
        else if(num==12)
            return 'Q';
        else if(num==1)
            return 'A';
        else
            return 'K';
    }
}
int main()
{
    string ss;
    while(getline(cin,ss))
    {
        int len=0;
        for(int i=0;i<ss.length();i++)
        {
            if(ss[i]!=' ')
            {
                re[len].va=tnum(ss[i]);
                re[len].ch=ss[i+1];
                len++;
                i++;
            }
        }
        int val=pset();
        printf("Hand: ");
        for(int i=0;i<5;i++)
        {
            printf("%c%c ",tch(re[i].va),re[i].ch);
        }
        printf("Deck: ");
        for(int i=5;i<10;i++)
        {
            printf("%c%c ",tch(re[i].va),re[i].ch);
        }
        printf("Best hand: ");
        cout<<s[val]<<endl;
    }
    return 0;
}


### 如何用编程方法生成集合的所有子集 #### 时间复杂度与基本原理 枚举子集的核心在于理解其时间复杂度以及背后的逻辑。对于一个大小为 \( n \) 的集合,其所有可能的子集数量为 \( 2^n \),这是因为每个元素都有两种状态:要么属于某个子集,要么不属于该子集[^1]。 这种指数级的时间复杂度意味着,在实际应用中,通常只适合处理较小规模的数据集(例如 \( n \leq 30 \))。为了高效地生成这些子集,可以通过位运算或者递归来实现。 --- #### 方法一:基于位运算的方法 通过将整数范围内的每一个数字视为一种掩码来表示不同的子集组合。具体来说: - 假设集合中的元素编号从 0 到 \( n-1 \)。 - 对于任意一个介于 \( 0 \) 和 \( 2^n - 1 \) 范围内的整数 \( i \),将其转化为二进制形式,则第 \( j \)-bit 表示是否选取原集合中的第 \( j \) 号元素。 以下是 Python 实现代码: ```python def generate_subsets_bitmask(s): n = len(s) subsets = [] for mask in range(1 << n): # 遍历从 0 到 (2^n - 1) subset = [s[j] for j in range(n) if (mask & (1 << j))] subsets.append(subset) return subsets # 测试例子 example_set = ['a', 'b', 'c'] result = generate_subsets_bitmask(example_set) print(result) ``` 上述程序利用了按位操作符 `&` 来判断某一位是否被设置为 1,从而决定当前元素是否加入到对应的子集中[^3]。 --- #### 方法二:基于递归的方式 另一种常见的做法是采用分治的思想,即每次考虑下一个未决策的元素是否有资格进入当前构建过程中的部分解里去形成新的候选方案之一;最终当遍历完成整个数组之后便能够得到完整的幂集结构。 下面是 C++ 版本的一个简单示范: ```cpp #include <iostream> #include <vector> using namespace std; void findSubsets(int index, vector<int> currentSet, const vector<int>& originalSet, vector<vector<int>>& allSubsets){ if(index == originalSet.size()){ allSubsets.push_back(currentSet); return; } // 不选择当前位置上的元素 findSubsets(index + 1, currentSet, originalSet, allSubsets); // 选择当前位置上的元素 currentSet.push_back(originalSet[index]); findSubsets(index + 1, currentSet, originalSet, allSubsets); } int main(){ vector<int> set = {1, 2, 3}; vector<vector<int>> result; findSubsets(0, {}, set, result); cout << "All Subsets:" << endl; for(auto s : result){ cout << "{ "; for(auto elem : s){ cout << elem << " "; } cout << "}" << endl; } return 0; } ``` 此版本展示了如何通过函数调用来模拟树形搜索路径,并逐步累积每条分支的结果直到叶节点处收集完毕为止[^2]。 --- #### 复杂度分析 无论采取哪种方式实现,由于都需要访问全部潜在可能性因此总体计算量必然达到 \( O(2^n * k) \),其中 \( k \) 是平均单个输出所需的操作次数(比如拷贝列表等额外开销),而空间消耗则取决于所使用的数据存储策略及其最大深度限制条件下的栈帧需求情况。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值