1056 Mice and Rice (25分)

Mice and Rice is the name of a programming contest in which each programmer must write a piece of code to control the movements of a mouse in a given map. The goal of each mouse is to eat as much rice as possible in order to become a FatMouse.

First the playing order is randomly decided for N​P​​ programmers. Then every N​G​​programmers are grouped in a match. The fattest mouse in a group wins and enters the next turn. All the losers in this turn are ranked the same. Every N​G​​ winners are then grouped in the next match until a final winner is determined.

For the sake of simplicity, assume that the weight of each mouse is fixed once the programmer submits his/her code. Given the weights of all the mice and the initial playing order, you are supposed to output the ranks for the programmers.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers: N​P​​ and N​G​​ (≤1000), the number of programmers and the maximum number of mice in a group, respectively. If there are less than N​G​​ mice at the end of the player's list, then all the mice left will be put into the last group. The second line contains N​P​​ distinct non-negative numbers W​i​​ (i=0,⋯,N​P​​−1) where each W​i​​ is the weight of the i-th mouse respectively. The third line gives the initial playing order which is a permutation of 0,⋯,N​P​​−1 (assume that the programmers are numbered from 0 to N​P​​−1). All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the final ranks in a line. The i-th number is the rank of the i-th programmer, and all the numbers must be separated by a space, with no extra space at the end of the line.

Sample Input:

11 3
25 18 0 46 37 3 19 22 57 56 10
6 0 8 7 10 5 9 1 4 2 3

Sample Output:

5 5 5 2 5 5 5 3 1 3 5

题意：几个人分组比赛，只要输一次，就淘汰，最后输出排名。

#include<iostream>

#include<vector>
#include<algorithm>
using namespace std;
struct node{
    int weight;
    int rank;
    int init_order;
    int win_cnt; // 第几个胜出的（神坑） 

};
bool cmp_weight(node a, node b){
    return a.weight > b.weight;
}
bool cmp_init(node a, node b){
    return a.init_order < b.init_order;
}

bool cmp_rank(node a, node b){
    return a.rank != b.rank ? a.rank < b.rank : a.win_cnt < b.win_cnt;
}
int main(){

    int np, ng;
    cin >> np >> ng;
    
    vector<node> vec(np);
    vector<node> temp_vec(np);
    for(int i = 0; i < np; i++){
        scanf("%d", &temp_vec[i].weight);
        temp_vec[i].init_order = i;
    }
    for(int i = 0; i < np; i++){
        int temp;
        scanf("%d", &temp);
        vec[i] = temp_vec[temp];
        
    }

    
    int failure_cnt = 0;
    int len = np;

    while(failure_cnt < np - 1){   //不论什么比赛，第一只有一个，就是永远没有输的那个人   
        int temp_cnt = 0;
        int rank = len / ng + 1;
        if(len % ng != 0){
            rank++;
        }
        for(int i = 0; i < len; i++){
            vec[i].rank = rank;
            failure_cnt++;
            
        }
        int flag = 0;
        while (flag < len)
        {
            int index = flag;
            int max = -1;
            int max_index;
            while (index < flag + ng && index < len)
            {
                if(vec[index].weight > max){
                    max = vec[index].weight;
                    max_index = index;
                }

                index++;
            }
                
            vec[max_index].rank = - 1;//win
            vec[max_index].win_cnt = index;
            temp_cnt++;
            failure_cnt--;
                
            
            flag += ng;
        }
        
        sort(vec.begin(), vec.end(), cmp_rank);
        len = temp_cnt;

    }
    // vec[0].weight = 1;
    // for(int i = 1; i < np; i++){
    //     if(vec[i].rank == vec[i - 1].rank){
    //         vec[i].weight = vec[i - 1].weight;
    //     }else
    //     {
    //         vec[i].weight = i + 1;
    //     }
        
        
    
    // }
    // sort(vec.begin(), vec.end(), cmp_init);
    // for(int i = 0; i < np - 1; i++){
        
    //     printf("%d ", vec[i].weight);
    
    // }
    // printf("%d\n", vec[np - 1].weight);
    vec[0].rank = 1;
    sort(vec.begin(), vec.end(), cmp_init);
    for(int i = 0; i < np - 1; i++){
        
        printf("%d ", vec[i].rank);
    
    }
    printf("%d\n", vec[np - 1].rank);
    return 0;
}