51nod 1821 最优集合(思维+单调队列)

题意:一个集合S的优美值定义为：最大的x，满足对于任意i∈[1,x]，都存在一个S的子集S‘，使得S‘中元素之和为i。

给定n个集合，对于每一次询问，指定一个集合S1和一个集合S2，以及一个数k，要求选择一个S2的子集S3(|S3|<=k)，使得S1∪S3的优美值最大。

（集合元素可以重复）

我们首先考虑对于集合S1，能否求出它的最大优美值。

　　首先排序一遍，对于前i个元素，如果它的最大优美值为v，那么当S1[i+1]>v+1时，前i+1个元素的最大优美值依然为v，否则为v+S1[i+1].此处易证。

　　也就是说集合S1的最大优美值等于排序后集合S1的使得S1[i+1]>Sum[i]+1成立的最大前缀和.

再考虑S2到底加入哪些元素可以使得S1的优美值最大呢。

　　首先可以肯定的是，由于加入的元素数量有限制，因此S2应该尽量加对S1的优美值增加最大的元素，由上面可以得知，应该为使得S2[i]<=v+1的最大的S2[i].

　　这样之后v就变成了v+S2[i],此时集合S1又有可能有元素可以利用了，这样一直进行K次。

要确保算法复杂度即可能低的情况下，可以使用单调队列来维护上面的操作。

因此，总时间复杂度为O(log(nm)+T*m).

# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <bitset>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define eps 1e-8
# define MOD 1000000007
# define INF 1000000000
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
# define lch p<<1,l,mid
# define rch p<<1|1,mid+1,r
# define mp make_pair
# define pb push_back
typedef pair<int,int> PII;
typedef vector<int> VI;
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
inline int Scan() {
    int x=0,f=1;char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
    while(ch>=‘0‘&&ch<=‘9‘){x=x*10+ch-‘0‘;ch=getchar();}
    return x*f;
}
inline void Out(int a) {
    if(a<0) {putchar(‘-‘); a=-a;}
    if(a>=10) Out(a/10);
    putchar(a%10+‘0‘);
}
const int N=1005;
//Code begin...

VI v[N];
LL val[N], que[N];
int p[N], head, tail;

void sol(int x, int &q, LL &w){
    FO(i,q,v[x].size()) {
        if (v[x][i]>w+1) break;
        w+=v[x][i]; ++q;
    }
}
int main ()
{
    int n, m, x, A, B, K, T;
    n=Scan();
    FOR(i,1,n) {
        m=Scan();
        while (m--) x=Scan(), v[i].pb(x);
        sort(v[i].begin(),v[i].end());
        p[i]=m;
        FO(j,0,v[i].size()) {
            if (v[i][j]>val[i]+1) {p[i]=j; break;}
            val[i]+=v[i][j];
        }
    }
    T=Scan();
    while (T--) {
        A=Scan(); B=Scan(); K=Scan();
        int q=p[A];
        LL w=val[A];
        head=-1; tail=0;
        FO(i,0,v[B].size()) {
            while (v[B][i]>w+1) {
                if (head<tail || !K) break;
                if (head>=tail&&K) w+=que[head], sol(A,q,w), --head, --K;
            }
            if (v[B][i]<=w+1) {
                que[++head]=v[B][i];
                while (head-tail+1>K) ++tail;
            }
            if (head<tail || !K) break;
        }
        if (K) while (head>=tail) w+=que[tail], sol(A,q,w), ++tail;
        printf("%lld\n",w);
    }
    return 0;
}