1012. The Best Rank

本文介绍了一个学生成绩排名系统的设计与实现。该系统针对学生的C语言编程、数学和英语三门课程的成绩进行综合评估,并强调最佳排名,即在四类排名(三门课程及平均分)中为每位学生提供最优排名。

1012. The Best Rank (25)

时间限制
400 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue

To evaluate the performance of our first year CS majored students, we consider their grades of three courses only: C - C Programming Language, M - Mathematics (Calculus or Linear Algebra), and E - English. At the mean time, we encourage students by emphasizing on their best ranks -- that is, among the four ranks with respect to the three courses and the average grade, we print the best rank for each student.

For example, The grades of C, M, E and A - Average of 4 students are given as the following:

StudentID  C  M  E  A
310101     98 85 88 90
310102     70 95 88 84
310103     82 87 94 88
310104     91 91 91 91

Then the best ranks for all the students are No.1 since the 1st one has done the best in C Programming Language, while the 2nd one in Mathematics, the 3rd one in English, and the last one in average.

Input

Each input file contains one test case. Each case starts with a line containing 2 numbers N and M (<=2000), which are the total number of students, and the number of students who would check their ranks, respectively. Then N lines follow, each contains a student ID which is a string of 6 digits, followed by the three integer grades (in the range of [0, 100]) of that student in the order of C, M and E. Then there are M lines, each containing a student ID.

Output

For each of the M students, print in one line the best rank for him/her, and the symbol of the corresponding rank, separated by a space.

The priorities of the ranking methods are ordered as A > C > M > E. Hence if there are two or more ways for a student to obtain the same best rank, output the one with the highest priority.

If a student is not on the grading list, simply output "N/A".

Sample Input
5 6
310101 98 85 88
310102 70 95 88
310103 82 87 94
310104 91 91 91
310105 85 90 90
310101
310102
310103
310104
310105
999999
Sample Output
1 C
1 M
1 E
1 A
3 A
N/A

提交代

唉,注意一点,相同分数算作排名相同,所以91,90,88,88,84的排名应该是1,2,3,3,5。不能算作1,2,3,3,4。别的没什么。

#include<bits/stdc++.h>
using namespace std;
struct grade{
    int pos;
    int ranks;
};
struct score{
    bool flag;
    grade g[4];
}st[1000005];
struct Student{
    int no;
    int c;
    int m;
    int e;
    int a;
}s[2005];
bool cmp1(Student a, Student b){
    if(a.c!=b.c) return a.c>b.c;
    return a.no<b.no;
}
bool cmp2(Student a, Student b){
    if(a.m!=b.m) return a.m>b.m;
    return a.no<b.no;
}
bool cmp3(Student a, Student b){
    if(a.e!=b.e) return a.e>b.e;
    return a.no<b.no;
}
bool cmp4(Student a, Student b){
    if(a.a!=b.a) return a.a>b.a;
    return a.no<b.no;
}
bool cmp5(grade a, grade b){
    if(a.ranks != b.ranks) return a.ranks<b.ranks;
    return a.pos<b.pos;
}
int main(){
    int n,m;
    char pp[4]={'A','C','M','E'};
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++){
        scanf("%d%d%d%d",&s[i].no,&s[i].c,&s[i].m,&s[i].e);
        s[i].a=(s[i].c+s[i].m+s[i].e)/3;
        st[s[i].no].flag=1;
    }
    sort(s+1,s+1+n,cmp1);
    int len=0;
    for(int i=1;i<=n;i++){
        if(s[i].c==s[i-1].c)
            st[s[i].no].g[0].ranks=st[s[i-1].no].g[0].ranks;
        else
            st[s[i].no].g[0].ranks=i;
        st[s[i].no].g[0].pos=1;
    }
    sort(s+1,s+1+n,cmp2);
    len=0;
    for(int i=1;i<=n;i++){
        if(s[i].m==s[i-1].m)
            st[s[i].no].g[1].ranks=st[s[i-1].no].g[1].ranks;
        else
            st[s[i].no].g[1].ranks=i;
        st[s[i].no].g[1].pos=2;
    }
    sort(s+1,s+1+n,cmp3);
    len=0;
    for(int i=1;i<=n;i++){
        if(s[i].e==s[i-1].e)
            st[s[i].no].g[2].ranks=st[s[i-1].no].g[2].ranks;
        else
            st[s[i].no].g[2].ranks=i;
        st[s[i].no].g[2].pos=3;
    }
    sort(s+1,s+1+n,cmp4);
    len=0;
    for(int i=1;i<=n;i++){
        if(s[i].a==s[i-1].a)
            st[s[i].no].g[3].ranks=st[s[i-1].no].g[3].ranks;
        else
            st[s[i].no].g[3].ranks=i;
        st[s[i].no].g[3].pos=0;
    }
    int no;
    while(m--){
        scanf("%d", &no);
        if(st[no].flag!=1){printf("N/A\n");}
        else{
            sort(st[no].g,st[no].g+4, cmp5);
            printf("%d %c\n", st[no].g[0].ranks, pp[st[no].g[0].pos]);
        }
    }
    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.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值