Mice and Rice (25)

5 5 5 2 5 5 5 3 1 3 5

# include <iostream>
# include <algorithm>
# include <queue>
using namespace std;

const int _size = 1005;
const int debug = 0;

int weight[_size];
int Rank[_size];

typedef pair<int,int> mice;
/*
a struct privided by the head file of algorithm ,
whose member veriables is "first & second",(there refer to "wegiht & id ")
the < operator is defined to attach priority to first
*/
int main()
{
	int i,temp;
	int n,k,total;
	cin >> n >> k;
	for (i=0;i<n;i++)
	    cin >> weight[i];
    
    priority_queue<mice> pri_que;
	mice winner[_size];
	mice loser[_size];
    for (i=0;i<n;i++)
        {
		    cin >> temp;
		    winner[i] = mice(weight[temp],temp);
        }
      
    /**Here is the beginning of the main contest *************************/
	total = n;      /*We assume every player is the winner of a previous game*/
    while (total>1)
    {
    	int e_win = 0;
    	int e_los = 0;
    	for (i=0;i<total;i+=k)
	        {
       	       int begin = i,end = i+k<total?i+k:total;
	           while (begin<end)
	           {
			    pri_que.push(winner[begin]);
			    begin++;
			   }
			   winner[e_win++] = pri_que.top();pri_que.pop();/* by priority_que we can easily find the winner*/
			   while (!pri_que.empty())  /*After the winner is popped all player left is loser */
			       {
				      loser[e_los++] = pri_que.top();
				      pri_que.pop();
			       }
			}
	     while (--e_los>=0)
		    Rank[loser[e_los].second] = e_win + 1;/*All the loser share the same rank which should be bigger than any winner*/
	     total = e_win;
	}
	Rank[winner[0].second] = 1;
	/**Here is the ending of the main contest *************************/
	
	for (i=0;i<n;i++)
	    cout << Rank[i] << (i==n-1?'\n':' ');
	return 0;
}

思路：说实话一开始没有看懂？  首先给你一个随机比赛序列（什么你翻译成播放序列，那就很难理解了）。然后每一个NG个数两个比赛
者在一个小组比赛。（小组赛手动滑稽），这个小组最肥的老鼠参加下一场比赛，在这一轮（所有的
小组赛比完）淘汰的赋予排名，胜利的进入下一场比赛。现在你要问，下一场比赛的顺序是什么？
这里没有讲清楚，还是按照第一次决定的顺序从刚开始诞生，到结束。
题目的意思：
6 0 8 一组   7 10 5 一组 9 1 4 一组 2 3 一组
4组最多诞生4个强人。所以所有淘汰的人排名是 5；
然后
8 7 9 3 作为优胜者参加下一场比赛
8 7 9 一组 3 一组
8 3 一组
8



#include <iostream>
#include <vector>
#include <deque>
#include <fstream>
using namespace std;


#ifndef Debug
ifstream ifile("case.txt");
#define cin ifile
#endif


struct mice
{
    int weight;
    int rank;
};

/*
11 3
25 18 0 46 37 3 19 22 57 56 10
6 0 8 7 10 5 9 1 4 2 3
*/
int main()
{
    int NP, NG;
    cin >> NP >> NG;
    vector<struct mice> v(NP);
    for (int i = 0; i < NP; i++)
    {
        cin >> v[i].weight;
    }
    deque<int> order(NP);
    for (int i = 0; i < NP; i++)
    {
        cin >> order[i];
    }
    for (; order.size() > 1;)
    {
        // 一轮结束  排名删除一些东西
        int groupsNumber = order.size() / NG;
        if (order.size() % NG)
        {
            groupsNumber++;
        }
        for (int i = 0; i < order.size(); i += NG)
        {
            int maxNum = -1; int subScr = -1;
            for (int j = i; j < i + NG && j < order.size(); j++)// 分组
            {
                if (v[order[j]].weight > maxNum)
                {
                    if(subScr != -1)
                    {
                        //拉黑
                        v[order[subScr]].rank = groupsNumber + 1;
                        order[subScr] = -1;
                    }
                    // 赋新值
                    maxNum = v[order[j]].weight;
                    subScr = j;
                }
                else
                {
                    // 拉黑
                    v[order[j]].rank = groupsNumber + 1;
                    order[j] = -1;
                }
            }
        }
        //删除
        for (int i = 0; i < order.size(); )
        {
            if (order[i] == -1)
            {
                order.erase(order.begin() + i);
            }
            else
            {
                i++;
            }
        }
    }
    v[order[0]].rank = 1;
    for (int i = 0; i < NP; i++)
    {
        if (i == 0)
            cout << v[i].rank;
        else
            cout << " " << v[i].rank;
    }
    system("pause");
}

a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = [b[int(i)] for i in input().split()]
d = dict(zip(b,range(a[0])))
e = {i:int((a[0] - 1) // a[1] + 2) for i in range(a[0])}

while len(c) - 1:
    c = [max(c[i:i + a[1]]) for i in range(0,len(c),a[1])]
    e.update({d[i]:(len(c) - 1) // a[1] + 2 for i in c})
e[d[c[0]]] = 1

print(' '.join(map(str,list(e.values()))))

使用 queue 来演算每一回合的情况，每回合会有group个 winner，那么 loser 的排名就是group + 1。然后我用指针优化了一下。。。
参考：https://www.liuchuo.net/archives/2936

/**
 * Mice and Rice(25)
 *
 * Queue
 */
#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;

struct Player {
  int weight, rank;
};

int main() {
  int np, ng;
  scanf("%d%d", &np, &ng);
  int order[np];
  Player players[np];
  for (int i = 0; i < np; i++) {
    scanf("%d", &players[i].weight);
  }
  for (int i = 0; i < np; i++) {
    scanf("%d", &order[i]);
  }
  queue<Player *> q;
  for (int i = 0; i < np; i++) {
    q.push(&players[order[i]]);
  }
  while (!q.empty()) {
    int size = q.size();
    if (size == 1) {
      Player *tmp = q.front();
      tmp->rank = 1;
      break;
    }
    int group = size / ng + (size % ng == 0 ? 0 : 1);
    Player *max;
    int maxn = -1, cnt = 0;
    for (int i = 0; i < size; i++) {
      Player *tmp = q.front();
      // <group> players will win, so losers' rank is <group + 1>
      tmp->rank = group + 1;
      q.pop();
      cnt++;
      if (tmp->weight > maxn) {
        maxn = tmp->weight;
        max = tmp;
      }
      // next group
      if (cnt == ng || i == size - 1) {
        cnt = 0;
        maxn = -1;
        q.push(max);
      }
    }
  }

  for (int i = 0; i < np; i++) {
    if (i != 0) printf(" ");
    printf("%d", players[i].rank);
  }
  return 0;
}

#include"stdafx.h"
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<stack>
using namespace std;
const int maxn = 1009;
struct mice{
    int rank = 0;    //it is not the rank in result but how the times join in the game
    int weight;
}player[maxn];
queue<int>order;
int sum, per;
int tongji[maxn];  //statistics of total munber of mice in different rank. 
int ans[maxn];       //    
int main(){
    cin >> sum >> per;
    for (int i = 0; i < sum; i++)    cin >> player[i].weight;    
    for (int t, i = 0; i < sum; i++){
        cin >> t;
        order.push(t);
    }
    while (order.size() > 1){    //my mistake mainly made in it circulation
        int need = per;
        int winer_index=0, winer_weight=-10000;
        int aRank = player[order.front()].rank;
        int bRank = player[order.front()].rank;
        while (need>0 && aRank == bRank){   // I code aRamk==aRank by mistake and debuge for 30 minues. stupid...
            int i = order.front();
            if (winer_weight < player[i].weight){
                winer_weight = player[i].weight;
                winer_index = i;
            }
            order.pop();
            need--;
            if (order.empty()) break;  //forgot to check is one of those mistake.
            bRank = player[order.front()].rank;
        }
        player[winer_index].rank++;
        order.push(winer_index);
    }
    for (int i = 0; i < sum; i++) tongji[player[i].rank]++;  //translate join-times to rank 
    for (int s=0, rank = sum-1; rank >=0; rank--){
        ans[rank] = s+1;
        s += tongji[rank];
    }
    for (int i = 0; i < sum-1; i++) cout << ans[player[i].rank] << " ";
    cout << ans[player[sum-1].rank] << endl;
    return 0;
}

#include <iostream>
#include <queue>

using namespace std;

queue<int> q;
//seq按顺序存放每个mice的重量,wins存放不同重量所获胜的次数
int seq[1000000], wins[1000000];

int main() {
    int n, m, temp;
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &seq[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &temp);
        q.push(seq[temp]);
    }

    int max_mice = 0, count = 0, len = n, j = 0, round = 0, rank[1000];
    while (j < len) {
        temp = q.front();
        q.pop();
        max_mice = max(max_mice, temp);
        count++; // 记录一组中遍历的个数
        // 一轮结束
        if (j == len - 1) { 
            q.push(max_mice);
            wins[max_mice] += 1;
            max_mice = 0;
            count = 0;
            j = 0;
            rank[round] = q.size() + 1; // 记录每轮中淘汰的老鼠的排名(第一名需特判)
            round++; // 记录轮次
            len = q.size();
            if (len == 1) break; // 这里如果len等于1后会死循环,需特判退出
            continue;
        }
        // 一组结束
        if (count == m) { 
            q.push(max_mice);
            wins[max_mice] += 1;
            max_mice = 0;
            count = 0;
        }
        j++;
    }

    // 输出
    for (int i = 0; i < n; i++) {
        temp = wins[seq[i]];
        if (rank[temp] == 0) {
            printf("1"); // 对第一名特判
        } else {
            printf("%d", rank[temp]);
        }
        if (i != n - 1) printf(" ");
    }

    return 0;
}

#include<bits/stdc++.h>
using namespace std;

const int Max=1010;
struct mouse {
	int w;
	int r;
} a[Max];

int main() {
	int n,m,x;
	cin>>n>>m;
	for(int i=0; i<n; i++) {
		cin>>a[i].w;
	}
	queue<int> q;
	for(int i=0; i<n; i++) {
		cin>>x;
		q.push(x);
	}
	int total=n,graph;
	while(q.size()!=1) {
		if(total%m==0) graph=total/m;
		else graph=total/m+1;
		for(int i=0; i<graph; i++) {
			int Maxi=q.front();
			for(int j=0; j<m; j++) {
				if(i*m+j>=total) break;
				int s=q.front();
				if(a[s].w>a[Maxi].w) {
					Maxi=s;
				}
				a[s].r=graph+1;
				q.pop();
			}
			q.push(Maxi);
		}
		total=graph;
	}
	a[q.front()].r=1;
	for(int i=0; i<n; i++) {
		cout<<a[i].r;
		if(i<n-1) cout<<" ";
	}
	return 0;
}

更多PAT甲级题解--acking-you.github.io

题目

OJ平台

题目翻译

• 这题最大的难点不是别的，就是理解题意！！！

  花了很久发现连™给出的示例输出怎么来的都没看懂。

以下均为我得出的关键题意：

1. If there are less than Ng mice at the end of the player's list, then all the mice left will be put into the last group.
   最后如果剩下的成员数量不足Ng，则合并为最后一队。
2. The second line contains NP distinct non-negative numbers Wi (i=0,...NP-1) where each Wi is the weight of the i-th mouse respectively. The third line gives the initial playing order which is a permutation of 0,...NP-1 (assume that the programmers are numbered from 0 to NP-1).
   这里说明了第二行输入的是所有老鼠的重量，而且这个重量就是从 i=0...Np-1 的下标顺序代表人员编号，第三行则是当前人员编号的排列，需要以这个为开始！
3. 最重要的一个理解在于对排名的理解--因为题目并未告诉你它的排名规则，我们只能根据实际经验和给出的示例进行猜测！
   排名的方法：举个例子，对于一个已经分成了四个组的情况，最后肯定只会剩下四个人，那么其余所有人的排名就都是第五名，接着继续分组为2组，选出两个人，其余所有人都是2+1 = 3名，继续分组得出一组，选出一个人，则其余所有人都是1+1 = 2名，还剩一个人，故他是冠军，第一名。
   总结来说就是和分出多少个组有关！

代码解析

数据展示

int Np, Ng;                             //人数、每组的人数
int *M;                                 //存储原始老鼠编号对应的重量
int *res;                               //存储答案排列
int *P;                                 //存储排列

输入处理

//@输入处理
void Input() {
    ios::sync_with_stdio(false);
    cin >> Np >> Ng;
    M   = new int[Np];
    res = new int[Np];
    P   = new int[Np];
    for (int i = 0; i < Np; i++) {      //输入老鼠重量
        cin >> M[i];
    }
    for (int i = 0; i < Np; i++) {      //输入排列
        cin >> P[i];
    }
}

解决问题核心算法

//@分组核心机制
inline int getGroupSize(int sz) {       //用于计算能形成多少个小组
    return sz / Ng + (sz % Ng == 0 ? 0 : 1);
}
//@答案更新机制
void push_rank(vector<pair<int, int>> &r, int rank) {
    for (int i = 0; i < r.size(); i++) {//用于更新每个成员的排名
        res[r[i].second] = rank;
    }
}


//@解决问题的核心代码
void solve() {                          //利用映射进行模拟
    int Len    = Np;
    int newLen = getGroupSize(Len);
    vector<pair<int, int>> nums(newLen, {-1, -1});
    int rank = newLen + 1;
    fill(res, res + Len, rank);
    int index = 0;                      //更新第第一次nums数组
    for (int i = 0; i < Len; i++) {
        if (i != 0 && i % Ng == 0)
            index++;
        if (M[P[i]] > nums[index].first) {
            nums[index].first  = M[P[i]];
            nums[index].second = P[i];
        }
    }
    vector<pair<int, int>> curNums;     //用nums数组和curNums交替更新，Len记录上一次的数组长度
    while (newLen != 1) {               //若最后只剩下一组，则跳出循环，记得再更新一次答案
        Len    = newLen;
        newLen = getGroupSize(Len);
        rank   = newLen + 1;
        push_rank(nums, rank);
        curNums.resize(newLen);
        int index = 0;
        for (int i = 0; i < Len; i++) {
            if (i != 0 && i % Ng == 0)
                index++;
            if (nums[i].first > curNums[index].first) {
                curNums[index].first  = nums[i].first;
                curNums[index].second = nums[i].second;
            }
        }
        nums = move(curNums);           //转移所有权
    }
    push_rank(nums, 1);                 //最后分成一组后，就跳出了循环，所以最大值并未被更新！
}

输出处理

//@输出处理
void print() {                          //打印操作
    for (int i = 0; i < Np; i++) {
        if (i != Np - 1)
            cout << res[i] << ' ';
        else
            cout << res[i];
    }
}

整合代码提交

#include<bits/stdc++.h>

using namespace std;
int Np, Ng;                             //人数、每组的人数
int *M;                                 //存储原始老鼠编号对应的重量
int *res;                               //存储答案排列
int *P;                                 //存储排列


//@输入处理
void Input() {
    ios::sync_with_stdio(false);
    cin >> Np >> Ng;
    M   = new int[Np];
    res = new int[Np];
    P   = new int[Np];
    for (int i = 0; i < Np; i++) {      //输入老鼠重量
        cin >> M[i];
    }
    for (int i = 0; i < Np; i++) {      //输入排列
        cin >> P[i];
    }
}



//@分组核心机制
inline int getGroupSize(int sz) {       //用于计算能形成多少个小组
    return sz / Ng + (sz % Ng == 0 ? 0 : 1);
}
//@答案更新机制
void push_rank(vector<pair<int, int>> &r, int rank) {
    for (int i = 0; i < r.size(); i++) {//用于更新每个成员的排名
        res[r[i].second] = rank;
    }
}


//@解决问题的核心代码
void solve() {                          //利用映射进行模拟
    int Len    = Np;
    int newLen = getGroupSize(Len);
    vector<pair<int, int>> nums(newLen, {-1, -1});
    int rank = newLen + 1;
    fill(res, res + Len, rank);
    int index = 0;                      //更新第第一次nums数组
    for (int i = 0; i < Len; i++) {
        if (i != 0 && i % Ng == 0)
            index++;
        if (M[P[i]] > nums[index].first) {
            nums[index].first  = M[P[i]];
            nums[index].second = P[i];
        }
    }
    vector<pair<int, int>> curNums;     //用nums数组和curNums交替更新，Len记录上一次的数组长度
    while (newLen != 1) {               //若最后只剩下一组，则跳出循环，记得再更新一次答案
        Len    = newLen;
        newLen = getGroupSize(Len);
        rank   = newLen + 1;
        push_rank(nums, rank);
        curNums.resize(newLen);
        int index = 0;
        for (int i = 0; i < Len; i++) {
            if (i != 0 && i % Ng == 0)
                index++;
            if (nums[i].first > curNums[index].first) {
                curNums[index].first  = nums[i].first;
                curNums[index].second = nums[i].second;
            }
        }
        nums = move(curNums);           //转移所有权
    }
    push_rank(nums, 1);                 //最后分成一组后，就跳出了循环，所以最大值并未被更新！
}




//@输出处理
void print() {                          //打印操作
    for (int i = 0; i < Np; i++) {
        if (i != Np - 1)
            cout << res[i] << ' ';
        else
            cout << res[i];
    }
}

int main() {
    Input();
    solve();
    print();
    return 0;
}

//Mice and Rice (25分)
#include <iostream>
(720)#include <vector>
#include <algorithm>

using namespace std;
int n, m, weight[1002], ranks[1002], flag = 0;
vector<int> arrays, temporary;

bool comp(int &a, int &b) {
    return weight[a] > weight[b];
}

void getRanks() {
    if (arrays.size() <= m) {
        sort(arrays.begin(), arrays.end(), comp);
        ranks[arrays[0]]=1;
        for (int i = 1; i < arrays.size(); i++) {
            ranks[arrays[i]] = 2;
        }
        flag = 1;
    } else {
        int x = ((arrays.size() % m) == 0) ? arrays.size() / m : (arrays.size() / m) + 1;
        int index = 0;
        for (int i = 0; i < x; i++) {
            int number = ((arrays.size() - index)) < m ? (arrays.size() - index) : m;
            sort(arrays.begin() + index, arrays.begin() + index + number, comp);
            for (int j = index + 1; j < index + number; j++)
                ranks[arrays[j]] = x + 1;
            temporary.push_back(arrays[index]);
            index += number;
        }
        arrays.clear();
        arrays = temporary;
        temporary.clear();
    }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++)
        scanf("%d", &weight[i]);
    for (int i = 0; i < n; i++) {
        int q;
        scanf("%d", &q);
        arrays.push_back(q);
    }
    while (true) {
        if (flag == 1) break;
        getRanks();
    }
    for (int i = 0; i < n; i++) {
        if (i != 0) printf(" %d", ranks[i]);
        else printf("%d", ranks[i]);
    }
}

这个题目的意思太绕了，本意就是按给定的序列每ng个数字毕竟比较大小，大的进行下一轮，小的直接给出排名，

#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

struct node {
    int i,index,weight, rank;//index是在数组中的索引，i是在为比赛选手号码
    node() {}
    node(int i,int w, int r) :index(i),weight(w), rank(r) {}
}maxNode;
bool com(node a,node b) {
    return a.i < b.i;
}
int main() {
    int np = 0, ng = 0, index = 0,cnt = 0,group = 0,maxWei = 0;//np为总的竞赛人员个数，ng为每组个数,组的个数
    cin >> np >> ng;
    vector<node> p(np);
    vector<int> num(np);
    queue<node> q;
    for (int i = 0, j = 0; i < np; i++) {//每个人员的初始化重量
        scanf("%d", &j);
        num[i] = j;
    }
    for (int i = 0, j = 0; i < np; i++) {//比赛顺序依次进队列
        scanf("%d", &j);
        p[i].i = j;
        p[i].index = i;
        p[i].weight = num[j];
    }
    for (int i = 0, j = 0; i < np; i++) {
        q.push(p[i]);
    }
     while (!q.empty()) {
        int size = q.size();
        if (size == 1) {
            node temp = q.front();
            p[temp.index].rank = 1;
            break;
        }
        group = size / ng;
        if (size % ng != 0)group++;
        for (int i = 0; i < size; i++) {
            node temp = q.front();//临时接受，用于比较最大的
            p[temp.index].rank = group + 1;
            q.pop();
            cnt++;
            if (temp.weight > maxWei) {//更新最重的老鼠
                maxWei = temp.weight;
                maxNode = temp;
            }
            if (cnt == ng || i == size - 1) {//当计算到ng个老鼠的时候或者到达结尾的时候
                q.push(maxNode);
                cnt = 0;//计数器置0
                maxWei = 0;//重置最大重量的老鼠
            }
        }
    }
    sort(p.begin(),p.end(),com);
    int flag = 0;
    for (int i = 0; i < p.size(); i++) {
        printf("%d",p[i].rank);
        if (i != p.size() - 1)printf(" ");
        flag = 1;
    }
    if (!flag)printf("None");
    cout << endl;
    system("pause");
    return 0;
}

import math
import sys

for s in sys.stdin:
    n,k=[int(x) for x in s.split()]
    r=[[int(t),i,-1]for i,t in enumerate(input().split())]
    p=[int(x) for x in input().split()]
    while True:
        t=0
        p1=[[] for i in range(math.ceil(len(p)/k))]
        p2=p
        for i in range(len(p)):
            if i//k==t:
                p1[t].append(p[i])
            if i%k==k-1:
                t+=1
        p=[]
        for s in p1:
            p.append(max([r[i] for i in s])[1])
        for i in p2:
            if i not in p:
                r[i][2]=len(p)+1
        if len(p)==1:
            r[p[0]][2]=1
            break
    s=''
    for i in range(n-1):
        s+=str(r[i][2])
        s+=' '
    s+=str(r[-1][2])
    print(s) 
这题的难点在于理解题意，一开始我很不能理解为什么比赛4轮，排名中会出现5
后来才明白排名是晋级人数+1
就像学校分数排名，有两个人分数一样排第二名，那么之后的人就排第四名了

#include <bits/stdc++.h>
using namespace std;

unordered_map <int, int> mp, mp1;
int total, num, all = 0;
int weight[1001];
vector<int> v, tmp;

int main()
{	cin >> total >> num;
	for (int i = 0; i < total; i++)
		cin >> weight[i];
	for (int i = 0; i < total; i++)
	{	int k;
		cin >> k;
		v.push_back(k); 
	}
	int i = 0, max_weight = -1, k = -1;
	while(1)
	{	int cnt = 0;
		for (i = 0; i < v.size(); i++)
		{	mp[v[i]] = 0;
			if (weight[v[i]] > max_weight)
			{	max_weight = weight[v[i]];
				k = v[i];
			}
			if ((i + 1) % num == 0)
			{	mp[k] = -1;
				tmp.push_back(k);
				max_weight = -1;
				k = -1;
			}  
			
		}
		if (i  % num != 0)
		{	mp[k] = -1;
			tmp.push_back(k);
		}
//		for(int i = 0; i < tmp.size(); i++)
//			cout << tmp[i] << " ";
//		cout << endl;
		for(int i = 0; i < v.size(); i++)
			if (mp[v[i]] != -1 ) 
			{	mp[v[i]] = tmp.size() + 1;
				all++;
			}
		if (tmp.size() == 1)
		{	mp[tmp[0]] = 1;
			break;
		}
		max_weight = -1;  k = -1;
		v = tmp; 	tmp.clear(); 
	}
	for(int i = 0; i < total; i++)
	{	if (i != 0)
			cout << " ";
		cout << mp[i];
	}
	return 0;
}  

	#include <queue>
#include <iostream>
using namespace std;
#define maxn 1010
struct mouse{          //老鼠结构体，质量与排名
 int weight,rank;
}mouse[maxn];
int main(){
 int np,ng,squ;     //一共np个老鼠，每组有ng一起比赛
 queue<int> q;
 cin>>np>>ng;
 for(int i=0;i<np;i++)
  cin>>mouse[i].weight;
 for(int i=0;i<np;i++){  //按题目给出的序号顺序入队
  cin>>squ;
  q.push(squ);
 }
 int temp=np,group;      //temp为本轮有多少只老鼠参加比赛，group为组数
 while(q.size()!=1){
  if(temp%ng==0) group=temp/ng;  //计算本轮有多少组
  else group=temp/ng+1;
  for(int i=0;i<group;i++){      //枚举每一组，选出该组优胜的老鼠
   int maxm=q.front();        //maxm即该组最肥的老鼠编号
   for(int j=0;j<ng;j++){
    if(j>=temp-i*ng) break;//最后一组老鼠个数不足ng，即时退出循环
    if(mouse[q.front()].weight>mouse[maxm].weight)
     maxm=q.front();
    mouse[q.front()].rank=group+1; //本轮输掉的老鼠排名即是本轮晋级的老鼠个数（一组一只，也即组数）加1
    q.pop();                       //出队
   }
   q.push(maxm);                      //让本组优胜的老鼠入队继续下一轮
  }
  temp=group;                            //下一轮参加比赛的老鼠即是本轮的组数（一组一只）
 }
 mouse[q.front()].rank=1;                   //队列剩下一只老鼠时，便是冠军，排名第一
 cout<<mouse[0].rank;
 for(int i=1;i<np;i++)
  cout<<" "<<mouse[i].rank;              //注意空格



	 return 0;
}