P4447 [AHOI2018初中组] 分组（C语言）

小可可的学校信息组总共有 n 个队员，每个人都有一个实力值 ai​。现在，一年一度的编程大赛就要到了，小可可的学校获得了若干个参赛名额，教练决定把学校信息组的 n 个队员分成若干个小组去参加这场比赛。

但是每个队员都不会愿意与实力跟自己过于悬殊的队员组队，于是要求分成的每个小组的队员实力值连续，同时，一个队不需要两个实力相同的选手。举个例子：[1,2,3,4,5][1,2,3,4,5] 是合法的分组方案，因为实力值连续；[1,2,3,5][1,2,3,5] 不是合法的分组方案，因为实力值不连续；[0,1,1,2][0,1,1,2] 同样不是合法的分组方案，因为出现了两个实力值为 11 的选手。

如果有小组内人数太少，就会因为时间不够而无法获得高分，于是小可可想让你给出一个合法的分组方案，满足所有人都恰好分到一个小组，使得人数最少的组人数最多，输出人数最少的组人数的最大值。

注意：实力值可能是负数，分组的数量没有限制。

输入格式

输入有两行：

第一行一个正整数 n，表示队员数量。
第二行有 n 个整数，第 i 个整数 ai​ 表示第 i 个队员的实力。

输出格式

输出一行，包括一个正整数，表示人数最少的组的人数最大值。

输入输出样例

输入 #1复制

7
4 5 2 3 -4 -3 -5

输出 #1复制

3

说明/提示

【样例解释】 分为 22 组，一组的队员实力值是 {4,5,2,3}{4,5,2,3}，一组是 {−4,−3,−5}{−4,−3,−5}，其中最小的组人数为 33，可以发现没有比 33 更优的分法了。

【数据范围】

对于 %100的数据满足：1≤n≤100000，∣ai​∣≤10^9。

本题共 1010 个测试点，编号为 1∼101∼10，每个测试点额外保证如下：

测试点编号	数据限制
1∼2	�≤6,1≤��≤100n≤6,1≤ai​≤100
3∼43∼4	�≤1000,1≤��≤105n≤1000,1≤ai​≤105 且 ��ai​ 互不相同
5∼65∼6	�≤100000,��n≤100000,ai​ 互不相同
7∼87∼8	�≤100000,1≤��≤105n≤100000,1≤ai​≤105
9∼109∼10	�≤100000,−109≤��≤109n≤100000,−109≤ai​≤109

说明：次题对时间限制的很紧凑，找到贪心思路，用二分查找，对数组排序用快排

AC代码：

#include <stdio.h>
#include <stdlib.h>
int a[100005] = {0};
int mark = 0;

struct team {
    int len, last;
} tm[100005];

// 归并排序函数
void merge(int arr[], int left, int mid, int right) {
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];

    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    i = 0;
    j = 0;
    k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
    int n, i;
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
	//快速排序 （普通的排序会超时） 
    mergeSort(a, 0, n - 1);
    //二分查找（依次遍历也会超时） 
    tm[0].last = a[0];
    tm[0].len = 1;
    mark = 1;
for(i=1;i<n;i++){
	int left=0,right=mark-1,mid,k=a[i];
	while(left<right){
		 mid=(left+right+1)/2;
		 if(tm[mid].last+1<=k){
		 	left=mid;
		 }else{
		 	right=mid-1;
		 }
	}
	//满足要求更换数组的末尾值和数组长度 
	if(tm[right].last ==k-1){
		tm[right].last =k;
		tm[right].len++;
	}
	//不满足从新开一个数组 
	else{
		tm[mark].last =k;
		tm[mark].len =1;
		mark++;
	}
	
}
	//找到最小的数组长度 
    int minlen = tm[0].len;
    for (i = 1; i < mark; i++) {
        if (tm[i].len < minlen) {
            minlen = tm[i].len;
        }
    }
    printf("%d\n", minlen);
    return 0;
}