1012. The Best Rank

本文介绍了一个学生排名系统的设计与实现,该系统通过C++编程语言完成。系统能够根据学生的不同成绩进行排序,并找出每个学生在各项成绩中的最佳排名。文章详细展示了如何定义学生结构体、实现比较函数以及查找最佳排名的过程。
// 1012. The Best Rank.cpp: 主项目文件。

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <algorithm>
using std::sort;

const int N=10003;
typedef struct Stu{
	char id[8];
	int A,C,M,E;
	int rank[4];
}Stu;
Stu stu[N];
int n,version;

bool cmp(Stu m1,Stu m2){
	if(version==0)
		return m1.A>m2.A;
	else if(version==1)
		return m1.C>m2.C;
	else if(version==2)
		return m1.M>m2.M;
	else 
		return m1.E>m2.E;
}

bool cmp1(Stu m1,Stu m2){
	return strcmp(m1.id,m2.id)<0;
}

void getRank(){
	sort(stu,stu+n,cmp);
	stu[0].rank[version]=1;
	for(int i=1;i<n;i++){
		if(version==0){
			if(stu[i].A==stu[i-1].A)
				stu[i].rank[version]=stu[i-1].rank[version];
			else
				stu[i].rank[version]=i+1;
		}
		else if(version==1){
			if(stu[i].C==stu[i-1].C)
				stu[i].rank[version]=stu[i-1].rank[version];
			else
				stu[i].rank[version]=i+1;
		}
		else if(version==2){
			if(stu[i].M==stu[i-1].M)
				stu[i].rank[version]=stu[i-1].rank[version];
			else
				stu[i].rank[version]=i+1;
		}
		else{
			if(stu[i].E==stu[i-1].E)
				stu[i].rank[version]=stu[i-1].rank[version];
			else
				stu[i].rank[version]=i+1;
		}
	}
}

int binarySearch(char *query,int low,int high){
	if(low<=high){
		int mid=(low+high)/2;
		if(strcmp(query,stu[mid].id)==0)
			return mid;
		else if(strcmp(query,stu[mid].id)>0)
			return binarySearch(query,mid+1,high);
		else
			return binarySearch(query,low,mid-1);
	}
	return -1;
}

void getBestRank(int pos){
	int min=stu[pos].rank[0],minf=0;
	for(int i=1;i<4;i++){
		if(stu[pos].rank[i]<min)
			min=stu[pos].rank[i],minf=i;
	}
	printf("%d ",min);
	if(minf==0)
		printf("A\n");
	else if(minf==1)
		printf("C\n");
	else if(minf==2)
		printf("M\n");
	else
		printf("E\n");
}

int main()
{
	int m;
    scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++){
		double a,c,m,e;
		scanf("%s%lf%lf%lf",stu[i].id,&c,&m,&e);
		stu[i].C=(int)c,stu[i].M=(int)m,stu[i].E=(int)e;
		stu[i].A=(int)((c+m+e)/3+0.5);//四舍五入
	}
	for(int i=0;i<4;i++){
		version=i;
		getRank();
	}
	sort(stu,stu+n,cmp1);
	while(m--){
		char query[8];
		scanf("%s",query);
		int index=binarySearch(query,0,n-1);
		if(index==-1)
			puts("N/A");
		else
			getBestRank(index);
	}
    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.
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值