【CF1077D】 Cutting Out

题目

题意翻译
题目描述
给你一个序列ss，长度为nn.

你需要找到一个长度为kk的序列tt使得它能被最多次数地从ss中切割。

一次切割的意思是你需要对于tt序列中所有t_it
i
​ ，在ss中找到一个跟它相同的数，并将其移除。

举例，如果s=[1,2,3,2,4,3,1]s=[1,2,3,2,4,3,1]，k=3k=3，那么一种可行的方案是t=[1,2,3]t=[1,2,3]，这个子序列可以被切割两次。

第一次切割，你可以选择[1, \underline{\textbf{2}}, 3, 2, 4, \underline{\textbf{3}}, \underline{\textbf{1}}][1,
2
​ ,3,2,4,
3
​ ,
1
​ ]，移除完后s=[1,3,2,4]s=[1,3,2,4]
第二次切割，你可以选择s=[\underline{\textbf{1}},\underline{\textbf{3}},\underline{\textbf{2}},4]s=[
1
​ ,
3
​ ,
2
​ ,4]，移除完后s=[4]s=[4]
你的任务是找到一个序列tt，能最多次数地从ss中切割它。如果有多个可行的方案，只需输出任意一种。

输入格式
第一行两个整数n,k(1\le k\le n\le 2\times 10^5)n,k(1≤k≤n≤2×10
5
)，表示ss序列的长度和tt序列的长度。

接下来一行nn个整数s_1,s_2,…,s_n(1\le s_i\le 2\times 10^5)s
1
​ ,s
2
​ ,…,s
n
​ (1≤s
i
​ ≤2×10
5
)
输出格式
输出kk个整数，表示你找到的序列tt使得能被切割的次数最大。如果有多个方案，只需输出任意一种。

样例解释
第一个样例在样例描述中已经说过。

第二个样例中可行的方案只有[7,3,1,3][7,3,1,3]和它的全排列。可以证明你不能找到其它长度为kk的序列tt使得能被切割两次

第三个样例中t=[1,1]t=[1,1]可以被切割五次。

题目描述
You are given an array s s consisting of n n integers.

You have to find any array t t of length k k such that you can cut out maximum number of copies of array t t from array s s .

Cutting out the copy of t t means that for each element t_i t
i
​ of array t t you have to find t_i t
i
​ in s s and remove it from s s . If for some t_i t
i
​ you cannot find such element in s s , then you cannot cut out one more copy of t t . The both arrays can contain duplicate elements.

For example, if s = [1, 2, 3, 2, 4, 3, 1] s=[1,2,3,2,4,3,1] and k = 3 k=3 then one of the possible answers is t = [1, 2, 3] t=[1,2,3] . This array t t can be cut out 2 2 times.

To cut out the first copy of t t you can use the elements [1, \underline{\textbf{2}}, 3, 2, 4, \underline{\textbf{3}}, \underline{\textbf{1}}] [1,
2
​ ,3,2,4,
3
​ ,
1
​ ] (use the highlighted elements). After cutting out the first copy of t t the array s s can look like [1, 3, 2, 4] [1,3,2,4] .
To cut out the second copy of t t you can use the elements [\underline{\textbf{1}}, \underline{\textbf{3}}, \underline{\textbf{2}}, 4] [
1
​ ,
3
​ ,
2
​ ,4] . After cutting out the second copy of t t the array s s will be [4] [4] .
Your task is to find such array t t that you can cut out the copy of t t from s s maximum number of times. If there are multiple answers, you may choose any of them.

输入输出格式
输入格式：
The first line of the input contains two integers n n and k k ( 1 \le k \le n \le 2 \cdot 10^5 1≤k≤n≤2⋅10
5
) — the number of elements in s s and the desired number of elements in t t , respectively.

The second line of the input contains exactly n n integers s_1, s_2, \dots, s_n s
1
​ ,s
2
​ ,…,s
n
​ ( 1 \le s_i \le 2 \cdot 10^5 1≤s
i
​ ≤2⋅10
5
).

输出格式：
Print k k integers — the elements of array t t such that you can cut out maximum possible number of copies of this array from s s . If there are multiple answers, print any of them. The required array t t can contain duplicate elements. All the elements of t t ( t_1, t_2, \dots, t_k t
1
​ ,t
2
​ ,…,t
k
​ ) should satisfy the following condition: 1 \le t_i \le 2 \cdot 10^5 1≤t
i
​ ≤2⋅10
5
.

输入输出样例
输入样例#1：
7 3
1 2 3 2 4 3 1
输出样例#1：
1 2 3
输入样例#2：
10 4
1 3 1 3 10 3 7 7 12 3
输出样例#2：
7 3 1 3
输入样例#3：
15 2
1 2 1 1 1 2 1 1 2 1 2 1 1 1 1
输出样例#3：
1 1
说明
The first example is described in the problem statement.

In the second example the only answer is [7, 3, 1, 3] [7,3,1,3] and any its permutations. It can be shown that you cannot choose any other array such that the maximum number of copies you can cut out would be equal to 2 2 .

In the third example the array t t can be cut out 5 5 times.

思路

本题可以采用二分的思想。

对进行删除操作的次数进行二分。

显然存在单调性…

确定玩对什么进行二分后，难点就在于二分的 check 函数了.

check 函数部分:

尽然已经知道可以删除多少次了，那么就可以计算出来每个数在 t 数组中出现的次数。

然后将所有出现的次数和与 t 数组的大小 k 进行比较即可。

代码

#include <bits/stdc++.h>

int n, k;
int a[200010], ans[200010];
int s[200010];
std::queue<int> st;

int check(int x)
{
    while(!st.empty())
        st.pop();
    for(int i = 1; i <= 200000; i++)
        for(int j = s[i] / x; j; j--)
            st.push(i);
    if(st.size() >= k)
    {
        for(int i = 1; i <= k; i++)
            ans[i] = st.front(), st.pop();
        return true;
    }
    return false;
}

int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]), s[a[i]]++;
    int l = 0, r = 200001;
    while (l < r)
    {
        int mid = (l + r + 1) >> 1;
        if (check(mid))
            l = mid;
        else
            r = mid - 1;
    }
    for (int i = 1; i <= k; i++)
        printf("%d ", ans[i]);
    return 0;
}