uva 131(枚举子集)

本文介绍了一种通过枚举所有可能的手牌组合来找出最优5张牌的算法。该算法适用于德州扑克游戏,考虑了前5张牌的任意舍弃与保留,并依据后续补牌形成最佳牌型。

题意:给出10张牌,前五张牌可以随意舍弃或里留下,后五张牌根据丢弃的个数从前往后依次补齐5张牌,使得最后的5张牌的值最大,牌的值可参照德州扑克大小规则。

题解:枚举出所有5张牌的情况,一共 2^5 - 1 种情况,即从保留5张牌到全部舍弃,可以将这些情况全部拿去判断他的最大值,判断的规则就是德州扑克大小规则。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <string>
#include <iostream>
using namespace std;
const int N = 10;

string s[N], s1[5];
const string an[9] = {"straight-flush", "four-of-a-kind", "full-house", "flush", "straight", "three-of-a-kind", "two-pairs", "one-pair", "highest-card"};
const string h = "23456789 9JKQT 89JQT 789JT 6789T 2345A AJKQT";
int n, flag, sub[32][5];

void init() {
	for (int i = 0; i < N; i++)
		s[i] = "";
	for (int i = 0; i < 5; i++)
		s1[i] = "";
	n = 0;
}
int cmp(string a, string b) {
	return a < b;
}

int judge() {
	sort(s1, s1 + 5, cmp);
	int temp = 0;
	string tempp = "";
	for (int i = 0; i < 5; i++)
		tempp += s1[i][0];
	if (h.find(tempp) != string::npos)
		temp = 1;
	if (temp == 1) {
		int ttemp = 1;
		char c = s1[0][1];
		for (int i = 1; i < 5; i++)	
			if (s1[i][1] == c)
				ttemp++;
		if (ttemp == 5)
			return 0; //同花顺
	}
	char c1 = s1[0][0];
	char c2 = s1[3][0];
	char c3 = s1[1][0];
	char c4 = s1[4][0];
	if (c1 == c2 || c3 == c4)
		return 1; //四条
	char c5 = s1[2][0];
	if ((c1 == c3 && c5 == c4) || (c1 == c5 && c2 == c4))
		return 2; //葫芦
	int temp1, temp2, temp3, temp4;
	temp1 = temp2 = temp3 = temp4 = 0;
	for (int i = 0; i < 5; i++) {
		if (s1[i][1] == 'H')
			temp1++;
		else if (s1[i][1] == 'C')
			temp2++;
		else if (s1[i][1] == 'S')
			temp3++;
		else 
			temp4++;
	}
	if (temp1 == 5 || temp2 == 5 || temp3 == 5 || temp4 == 5)
		return 3; //同花
	if (temp == 1)
		return 4; //顺子
	if (c1 == c5 || c3 == c2 || c5 == c4)
		return 5; //三条
	if ((c1 == c3 && c5 == c2) || (c1 == c3 && c2 == c4) || c3 == c5 && c2 == c4)
		return 6; //两对
	if (c1 == c3 || c3 == c5 || c5 == c2 || c2 == c4)
		return 7; //一对 
	return 8; //散牌
}

void solve() {
	flag = 8;
	for (int i = 0; i < (1 << 5); i++) {
		for (int j = 0, k = 4; j < 5; j++, k--)
			if (i & (1 << j))
				sub[i][k] = 1;
			else
				sub[i][k] = 0;
		int temp = 0;
		for (int k = 0; k < 5; k++)
			s1[k] = "";
		for (int k = 0; k < 5; k++) {
			if (sub[i][k] == 1) {
				s1[temp] += s[k][0];
				s1[temp++] += s[k][1];
			}
		}
		for (int k = temp, q = 5; k < 5; k++, q++) {
			s1[k] += s[q][0];
			s1[k] += s[q][1];
		}
		int ans = judge();
		if (ans < flag)
			flag = ans;
	}
}

int main() {
	char a, b, c;
	init();
	while (scanf("%c%c%c", &a, &b, &c) != EOF) {
		s[n] += a;
		s[n++] += b;
		if (c == '\n') {
			solve();
			printf("Hand: ");
			for (int j = 0; j < 5; j++)
				cout << s[j] << " ";
			printf("Deck: ");
			for (int j = 5; j < N; j++)
				cout << s[j] << " ";
			printf("Best hand: ");
			cout << an[flag] << endl;
			init();
		}
	}
	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、付费专栏及课程。

余额充值