codeforces 967 D Resource Distribution

题目

One department of some software company has n servers of different specifications. Servers are indexed with consecutive integers from $1$ to $n$. Suppose that the specifications of the $j$-th server may be expressed with a single integer number $c_j$ of artificial resource units.

In order for production to work, it is needed to deploy two services $S_1$ and $S_2$ to process incoming requests using the servers of the department. Processing of incoming requests of service $S_i$ takes $x_i$ resource units.

The described situation happens in an advanced company, that is why each service may be deployed using not only one server, but several servers simultaneously. If service $S_i$ is deployed using $k_i$ servers, then the load is divided equally between these servers and each server requires only $x_i$/$k_i$ (that may be a fractional number) resource units.

Each server may be left unused at all, or be used for deploying exactly one of the services (but not for two of them simultaneously). The service should not use more resources than the server provides.

Determine if it is possible to deploy both services using the given servers, and if yes, determine which servers should be used for deploying each of the services.

Input
The first line contains three integers $n$, $x_1$, $x_2$ ($2 \le n \le300000$, $1 \le x_1,x_2 \le 10^9$) — the number of servers that the department may use, and resource units requirements for each of the services.

The second line contains $n$ space-separated integers $c_1$,$c_2$,$...$,$c_n$ ($1 \le c_i \le 10^9$) — the number of resource units provided by each of the servers.

Output
If it is impossible to deploy both services using the given servers, print the only word “No” (without the quotes).

Otherwise print the word “Yes” (without the quotes).

In the second line print two integers $k_1$ and $k_2$ ($1\le k_1,k_2\le n$) — the number of servers used for each of the services.

In the third line print $k_1$ integers, the indices of the servers that will be used for the first service.

In the fourth line print $k_2$ integers, the indices of the servers that will be used for the second service.

No index may appear twice among the indices you print in the last two lines. If there are several possible answers, it is allowed to print any of them.

Examples

Input
6 8 16 3 5 2 9 8 7
Output
Yes 3 2 1 2 6 5 4

Input
4 20 32 21 11 11 12
Output
Yes 1 3 1 2 3 4

Input
4 11 32 5 5 16 16
Output
No

Input
5 12 20 7 8 4 11 9
Output
No

Note
In the first sample test each of the servers $1$, $2$ and $6$ will will provide $8/3=2.(6)$ resource units and each of the servers $5$, $4$ will provide $16/2=8$ resource units.

In the second sample test the first server will provide $20$ resource units and each of the remaining servers will provide $32/3=10.(6)$ resource units.

---

分析

【题意】
给出$n$个服务器的资源数$c_1, c_2, ..., c_n$和运行$2$个程序需要的资源$x_1, x_2$，求一个解决方案

• 选取$k_1$个资源数不小于$\frac{x_1}{k_1}$的服务器使资源总和不小于$x_1$
• 选取$k_2$个资源数不小于$\frac{x_2}{k_2}$的服务器使资源总和不小于$x_2$
• 两次选取的服务器不能有交叉

【分析】

1. 服务器贪心：连续选择$\lceil \frac{x_1}{c_{min}}\rceil$个服务器
   假设对于x1已经选择了n个服务器，要求每个服务器的资源数都不小于$\frac{x_1}{n}$，只要最小的资源数不小于这个值就行了，也就是 $c_{min}\ge\frac{x_1}{n} \Rightarrow c_{min}·n\ge x_1$。可以理解为，一个服务器的集合实际上最多提供$c_{min}·n$个资源。那么从贪心的角度，其他服务器在大于$c_{min}$的同时应该尽可能的小，如果把服务器按从大到小排序，就应该从$c_{min}$向左连续选n-1个。事实上，在从大到小排序的基础上，从一个点开始往左连续选择，那么这个点就是$c_{min}$，而我们只需要一共选择$\lceil \frac{x_1}{c_{min}}\rceil$个就足够让$x_1$运行了。

2. 如何寻找解：后分配的在左边继续寻找
   假设现在为x1分配服务器，想象所有的服务器按从大到小排成一列，如果从中间的某个地方开始往左选若干个出来，那么势必会将这个序列分割为两端，是不是应该到两边都试一下给x2分配服务器呢？
   

从$c_{min}$开始向左选择是，大小是递增的，每个服务器都一定会提供$c_{min}$个资源，所以总的个数是明确的，只需要判断一下左边有没有这个多服务器就能直到有没有解；但是向右选择，服务器越来越小，没有直接的依据应该截取到哪个位置，需要把右边都遍历完才能知道是否有解，复杂度很高，这样做显然不好。

既然向右寻找行不通，那么如果先给$x_1$分配服务器了，再给$x_2$分配就只能从$x_1$的左边继续寻找。为了考虑$x_2$在右边的情况，就让$x_2$先分配，再让$x_1$在x2的左边寻找（向左=低复杂度）。

【算法】
先尝试先分配$x_1$，再分配$x_2$，遍历所有位置$i$作为$x_1$分配的起点，分配的终点就是$i - \lceil \frac{x_1}{c_{min}}\rceil$，再在分配终点继续向左为$x_2$分配；
再尝试先分配$x_2$，再分配$x_1$，原理和上述一样。

我自己感觉，连续的分配是最贪心解，也是最优的解，如果有不是连续的分配，也一定可以通过交换变成连续的分配，因为分配的所有服务器，只有最右边的那一个在决定整体的大小，所以其实在它的左边选哪些服务器并不影响最后的大小，只要数量是$\lceil \frac{x_1}{c_{min}}\rceil$就行了。至于具体怎么证明就不会了。。。

代码

#include<stdio.h>
#include<algorithm>
using std::sort;

/*
 * 给c1, c2, ..., cn和x1, x2
 * 选取k1个不小于x1/k1的组成x1，再用剩下的选k2个不小于x2/k2的组成x2
 * 只需给出一个解
 * 
 */

#define maxn 300010
#define max(a,b) ((a)>(b)?(a):(b))
#define updiv(a,b) ((a)/(b)+(((a)%(b))!=0))
struct thing {
    int v;
    int id;
}c[maxn];   

bool cmp(thing t1,thing t2) {
        return t1.v>t2.v;
}
int n, a, b;
int k1, k2;
int main() {
    scanf("%d%d%d", &n, &a, &b);
    for(int i=1;i<= n;++i)
        scanf("%d", &c[i].v), c[i].id = i;
    sort(c + 1, c + n + 1,cmp);
    //尝试先分配a，再分配b
    for (int i = 1; i <= n; i++) {//只前i个能否构成解
        //以服务器i为下限组成a需要前k1个
        k1 = updiv(a, c[i].v);
        if (k1 >= i)continue;
        //把[i-k1+1,i]分配给a
        //以服务器i-k1为下限组成b需要前k2个
        k2 = updiv(b, c[i - k1].v);
        if (k2 > i - k1)continue;
        //把[i-k1-k2+1,i-k1]分配给b

        //分配成功
        printf("Yes\n%d %d\n", k1, k2);
        for (int t = i - k1 + 1; t <= i; ++t)printf("%d%c", c[t].id, t == i ? '\n' : ' ');
        for (int t = i-k1-k2+1; t <=i-k1; ++t)printf("%d%c", c[t].id, t == i-k1 ? '\n' : ' ');
        return 0;
    }

    //尝试先分配b，再分配a
    for (int i = 1; i <= n; i++) {//只前i个能否构成解
        //以服务器i为下限组成b需要前k2个
        k2 = updiv(b, c[i].v);
        if (k2 >= i)continue;
        //把[i-k2+1,i]分配给b

        //以服务器i-k2为下限组成a需要前k1个
        k1 = updiv(a, c[i - k2].v);
        if (k1 > i - k2)continue;
        //把[i-k2-k1+1,i-k2]分配给a

        //分配成功
        printf("Yes\n%d %d\n", k1, k2);
        for (int t = i-k2 - k1 + 1; t <= i-k2; ++t)printf("%d%c", c[t].id, t == i-k2 ? '\n' : ' ');
        for (int t = i-k2+1; t <= i; ++t)printf("%d%c", c[t].id, t == i ? '\n' : ' ');
        return 0;
    }
    printf("No");
    return 0;
}

【总结】
遇到直接做不好分析的问题，不妨先着眼于解空间的构成，如果是贪心问题，就更应该去思考最优解是怎样的存在，如何高效的构造出来才是问题的关键，如果做不到高效的构造，又怎么贪心呢。