1056 Mice and Rice 25

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(\le 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,\cdots ,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,\cdots ,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

问题思路

本题大意：给定编号0, 1, 2, ..., Np的老鼠，通过比赛得出它们的体重排名。比赛规则如下：随机排列每只老鼠的比赛顺序，按顺序每Ng只分为一组进行比赛，少于Ng的为一组，决出每组冠军进入下一轮，同一轮败者排名一致；下一轮以同样规则进行比赛直到决出最终冠军。

思路：

每一轮的比赛规则是相同的，都是每Ng只老鼠逐次进行比赛，所以我们可以使用一个队列来记录即将进行比赛的老鼠，每场比赛Ng只老鼠出队进行比赛，小组冠军继续入队等待，而败者可以使用一个优先队列（最大堆）进行储存，最后一起输出排名。

1. 用队列进行比赛模拟模拟时需要注意两个地方：

   • 每一轮最后一组老鼠数量可能少于Ng，导致下一轮的老鼠出队，所以我们需要让“假老鼠”入队凑出Ng的整数倍
   • 如何分辨队列中一只老鼠是这一轮的还是下一轮的？使用一个变量turn标记轮数，使用pair<int, int>表示一只老鼠的序号和轮数(struct也可以)

2. 用优先队列进行排名模拟时需要注意：

   • 优先队列应是以轮数为键值的最大堆，这样最后输出时才能保证按照排名先后输出

源码

#include <cstdio>
#include <queue>
#include <map>
using namespace std;

struct cmp {
	bool operator()(pair<int, int> m1, pair<int, int> m2)
	{
		return m1.second < m2.second;
	}
};

int main()
{
    priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> rank;
    queue<pair<int, int>> waiting;

    int Np, Ng;
    scanf("%d %d", &Np, &Ng);
    int *mice = new int[Np];
    for (int i = 0; i < Np; i++)
    {
        scanf("%d", &mice[i]);
    }
    for (int i = 0; i < Np; i++)
    {
        pair<int, int> tmp;
        scanf("%d", &tmp.first);
        tmp.second = 0;
        waiting.push(tmp);
    }
    for (int i = 0; Np % Ng != 0 && i < Ng - Np % Ng; i++)
    {
        // 加入假老鼠，凑Ng的倍数
        pair<int, int> tmp{-1, 0};
        waiting.push(tmp);
    }

    int turn = 1;
    pair<int, int> winner, comp;
    while (!waiting.empty())
    {
        winner = waiting.front();
        waiting.pop();
        // 出队Ng只老鼠进行比赛
        for (int i = 0; i < Ng - 1; i++)
        {
            comp = waiting.front();
            waiting.pop();
            if (comp.first != -1 && mice[comp.first] > mice[winner.first])
            {
                rank.push(winner);
                winner = comp;
            }
            else if(comp.first != -1)
            {
                rank.push(comp);
            }
        }
        winner.second++;
        waiting.push(winner);
        if (waiting.front().second == turn && waiting.size() > 1)
        {
            int N = waiting.size();
            for (int i = 0; N % Ng != 0 && i < Ng - N % Ng; i++)
            {
                // 凑Ng的倍数
                pair<int, int> tmp{-1, turn};
                waiting.push(tmp);
            }
            turn++;
        }
        // 若队列中只有一只老鼠，说明已经决出冠军
        if (waiting.size() == 1)
        {
            winner = waiting.front();
            waiting.pop();
            rank.push(winner);
        }
    }

    // 优先队列输出，得到最终排名
    int same_rank = 1, num_same_rank = 0;
    int *final_rank = new int[Np];
    turn = rank.top().second;
    while (!rank.empty())
    {
        comp = rank.top();
        rank.pop();
        if (comp.second == turn)
        {
            num_same_rank++;
        }
        else
        {
            same_rank += num_same_rank;
            num_same_rank = 1;
            turn--;
        }
        final_rank[comp.first] = same_rank;
    }
    for (int i = 0; i < Np; i++)
    {
        printf(i == 0 ? "%d" : " %d", final_rank[i]);
    }

    delete[] mice, final_rank;
    return 0;
}