CodeForces 723C-Polycarp at the Radio（模拟 贪心 vector乱搞）

C. Polycarp at the Radio
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
Polycarp is a music editor at the radio station. He received a playlist for tomorrow, that can be represented as a sequence a1, a2, …, an, where ai is a band, which performs the i-th song. Polycarp likes bands with the numbers from 1 to m, but he doesn’t really like others.

We define as bj the number of songs the group j is going to perform tomorrow. Polycarp wants to change the playlist in such a way that the minimum among the numbers b1, b2, …, bm will be as large as possible.

Find this maximum possible value of the minimum among the bj (1 ≤ j ≤ m), and the minimum number of changes in the playlist Polycarp needs to make to achieve it. One change in the playlist is a replacement of the performer of the i-th song with any other group.

Input
The first line of the input contains two integers n and m (1 ≤ m ≤ n ≤ 2000).

The second line contains n integers a1, a2, …, an (1 ≤ ai ≤ 109), where ai is the performer of the i-th song.

Output
In the first line print two integers: the maximum possible value of the minimum among the bj (1 ≤ j ≤ m), where bj is the number of songs in the changed playlist performed by the j-th band, and the minimum number of changes in the playlist Polycarp needs to make.

In the second line print the changed playlist.

If there are multiple answers, print any of them.

Examples
input
4 2
1 2 3 2
output
2 1
1 2 1 2

input
7 3
1 3 2 2 2 2 1
output
2 1
1 3 3 2 2 2 1

input
4 4
1000000000 100 7 1000000000
output
1 4
1 2 3 4

Note
In the first sample, after Polycarp’s changes the first band performs two songs (b1 = 2), and the second band also performs two songs (b2 = 2). Thus, the minimum of these values equals to 2. It is impossible to achieve a higher minimum value by any changes in the playlist.

In the second sample, after Polycarp’s changes the first band performs two songs (b1 = 2), the second band performs three songs (b2 = 3), and the third band also performs two songs (b3 = 2). Thus, the best minimum value is 2.

题意：有N首编号为1~N的歌，有M个编号为1~M的合法演奏者，第二行N个ai，代表第i首歌由第ai位演奏者演奏，ai不一定就是1~M中的某一位。
我们需要使所有的歌曲演奏者均合法，并使得每一位演奏者演奏歌曲数量的最小值最大。
输出这个值和更改后的演奏者序列。

思路：很明显合法演奏者演奏歌曲数量最小值的最大值是N/M，创建一个合法演奏者演奏歌曲编号的动态数组和一个存储非法演奏者演奏歌曲序号的动态数组以及一个存储非法演奏者编号的动态数组。
遍历每一个合法演奏者，如果他演奏的歌曲数量不足，则优先从非法演奏者动态数组中抽调，如果抽调后数量仍然不足，则扫描非自己的合法演奏者，数量多的调到自己集合。（当然这一步可以另建数组存储数据，然后二分查找优化时间复杂度，但是鉴于数据那么小，就偷懒没写。）

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<vector>
using namespace std;
const int maxn=2005;
int A[maxn];//第i首歌曲由第A[i]个人演奏
vector<int>Less[maxn];//第i个人演奏的歌曲集合Less[i]
vector<int>more_point;//演奏序号超过M的歌曲编号集合
vector<int>more_num;//演奏序号超过M的序号
int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    for(int i=1; i<=N; i++)
    {
        int flag;
        scanf("%d",&flag);
        if(flag<=M)
            Less[flag].push_back(i);
        else
        {
            more_point.push_back(i);
            more_num.push_back(flag);
        }

    }
    int average=N/M;
    int num=0;
    for(int i=1; i<=M; i++)
    {
        if((int)Less[i].size()<average)
        {
            if((int)more_point.size()>0)
            {
                while((int)Less[i].size()!=average&&(int)more_point.size()!=0)
                {
                    Less[i].push_back(more_point.back());
                    more_point.pop_back();
                    more_num.pop_back();
                    num++;
                }
            }
            for(int j=1; j<=M&&(int)Less[i].size()<average; j++)
            {
                if(i!=j&&(int)Less[j].size()>average)
                {
                    while((int)Less[i].size()<average&&(int)Less[j].size()>average)
                    {
                        Less[i].push_back(Less[j].back());
                        Less[j].pop_back();
                        num++;
                    }
                }
            }
        }
    }
    for(int i=1; i<=M; i++)
    {
        for(int j=0; j<(int)Less[i].size(); j++)
        {
            A[Less[i][j]]=i;
        }
    }
    for(int i=0;i<(int)more_point.size();i++)//这一点不能漏掉
        A[more_point[i]]=more_num[i];
    printf("%d %d\n",average,num);
    for(int i=1; i<=N; i++)
        printf("%d ",A[i]);
    printf("\n");
    return 0;
}