1012. The Best Rank (25)

本文介绍了一个使用C++实现的结构体排序算法,并通过一个具体的应用案例来展示如何进行有效的排序与查询操作。该程序首先输入学生信息及成绩,然后通过比较不同科目的成绩来确定每个学生的最佳排名及对应的科目。

考察结构体排序

#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;
int n;//student
int m;//query
typedef struct Node
{
	string name;
	int grade[4];
	int bestRank;
	int bestGrade;
}Node;
typedef struct SortNode
{
	int g, idx, rank;
	bool operator>(const SortNode& orh)const
	{
		return g>orh.g;
	}
}SortNode;
char CharTable[4]={'A','C','M','E'};
#define INF 0x6FFFFFFF
int main()
{
	//input
	scanf("%d%d",&n,&m);
	vector<Node> stu(n);//student
	map<string, int> stuMap;//for query
	for(int i = 0; i < n; ++i)
	{
		cin>>stu[i].name;
		scanf("%d%d%d", &stu[i].grade[1], &stu[i].grade[2], &stu[i].grade[3]);
		stu[i].grade[0] = stu[i].grade[1]+stu[i].grade[2]+stu[i].grade[3];
		stu[i].bestRank = INF;
		stuMap[stu[i].name] = i;
	}
	//
	for(int i = 0; i < 4; ++i)//for every record
	{
		vector<SortNode> sortNode(n);
		for(int j = 0; j < n; ++j)
		{
			sortNode[j].g = stu[j].grade[i];
			sortNode[j].idx = j;
		}
		sort(sortNode.begin(), sortNode.end(), greater<SortNode>());
		//process the same grade case
		int nowGrade = INF;
		int nowRank = 0;
		for(int j = 0; j < n; ++j)
		{
			if(sortNode[j].g == nowGrade)
				sortNode[j].rank = nowRank;
			else
			{
				sortNode[j].rank = j;
				nowRank = j;
				nowGrade = sortNode[j].g;
			}
		}
		//then compare to select the best rank
		for(int j = 0; j < n; ++j)
		{
			int idx = sortNode[j].idx;
			int rank = sortNode[j].rank;
			if(stu[idx].bestRank > rank)
				stu[idx].bestRank = rank, stu[idx].bestGrade = i;
		}
	}

	//query
	for(int i = 0; i < m; ++i)
	{
		string name;
		cin>>name;
		map<string, int>::iterator it = stuMap.find(name);
		if(it!=stuMap.end())
		{
			int idx = it->second;
			printf("%d %c\n", stu[idx].bestRank+1, CharTable[stu[idx].bestGrade]);
		}
		else printf("N/A\n");
	}
	return 0;
}


 

To determine the number of distinct sets of 13 cards for which Player A can guarantee a win in a poker game where each player selects 5 cards and Player B wins on ties, the problem revolves around combinatorics and game theory. ### Problem Interpretation: - A standard deck has 52 cards. - Player A selects 13 cards as their hand. - From these 13 cards, Player A must be able to choose a 5-card poker hand that beats any 5-card poker hand that Player B could form from the remaining 39 cards. - If both players have the same rank of hand (e.g., both have a flush), Player B wins by default. - The objective is to count how many such 13-card combinations exist where Player A can always select a 5-card hand strictly better than any 5-card hand Player B could choose. ### Key Observations: - There are $\binom{52}{13}$ total possible 13-card hands. - Not all of these hands will allow Player A to guarantee a win. - The solution involves evaluating the strength of all possible 5-card combinations from the 13-card set and ensuring that none of the 5-card combinations from the remaining 39 cards can tie or beat them. ### Strategy to Solve: 1. **Understand Poker Hand Rankings**: The ranking of poker hands from highest to lowest is: Royal Flush, Straight Flush, Four of a Kind, Full House, Flush, Straight, Three of a Kind, Two Pair, One Pair, High Card. 2. **Generate All 13-Card Hands**: The number of ways to choose 13 cards from 52 is $\binom{52}{13}$, which is approximately $6.35 \times 10^{11}$. 3. **Evaluate Each 13-Card Hand**: - For each 13-card hand, generate all $\binom{13}{5} = 1287$ possible 5-card combinations. - Determine the best possible 5-card hand from these combinations. - From the remaining 39 cards, generate all $\binom{39}{5} = 575757$ possible 5-card combinations for Player B. - Check if any of Player B’s hands can tie or beat Player A’s best hand. 4. **Count Winning Hands for Player A**: - If Player A’s best 5-card hand beats all possible 5-card hands from the remaining 39 cards, count that 13-card set as a winning hand. - This requires a poker hand evaluator to compare the strength of hands. 5. **Implement Efficient Comparison**: - Use a precomputed lookup table for poker hand strengths. - Implement a fast comparison algorithm to avoid redundant computations. - Parallelize the computation to handle the large search space. 6. **Optimize with Pruning**: - Discard 13-card hands early if their best 5-card hand cannot beat the minimum possible strength of Player B’s hands. - For example, if Player A’s best hand is a high card, and Player B can form a pair, discard that 13-card set. 7. **Final Count**: - After evaluating all possible 13-card combinations and filtering out those where Player A cannot guarantee a win, the remaining count is the desired answer. ### Computational Complexity: This problem is computationally intensive due to the large number of combinations. It is not feasible to compute manually and would require: - Efficient poker hand evaluation code. - Distributed computing or GPU acceleration. - Optimization techniques such as memoization and pruning. Here is a simplified version of the code in Python: ```python from itertools import combinations import random # Simplified poker hand evaluator (placeholder) def evaluate_hand(hand): # This would be replaced with a full poker hand evaluator return random.randint(1, 1000000) # Generate a deck of 52 cards deck = list(range(52)) # Placeholder for counting winning hands winning_hands_count = 0 # Iterate over all possible 13-card hands (this is computationally infeasible to complete in full) for hand_A in combinations(deck, 13): remaining_cards = list(set(deck) - set(hand_A)) best_hand_A = max(combinations(hand_A, 5), key=evaluate_hand) # Check if best_hand_A beats all possible 5-card hands from the remaining 39 cards player_B_hands = combinations(remaining_cards, 5) if all(evaluate_hand(best_hand_A) > evaluate_hand(hand_B) for hand_B in player_B_hands): winning_hands_count += 1 print(f"Number of winning 13-card hands: {winning_hands_count}") ``` ### Conclusion: The exact number of such 13-card hands is not trivial to compute and would require a dedicated program with optimized algorithms. However, the framework for solving the problem involves evaluating all possible combinations and comparing poker hand strengths.
评论 12
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI记忆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值