BZOJ 2436 Noi嘉年华 （dp）

2436: [Noi2011]Noi嘉年华

Time Limit: 10 Sec Memory Limit: 128 MB
Description

NOI2011 在吉林大学开始啦！为了迎接来自全国各地最优秀的信息学选手，吉林大学决定举办两场盛大的 NOI 嘉年华活动，分在两个不同的地点举办。每个嘉年华可能包含很多个活动，而每个活动只能在一个嘉年华中举办。 现在嘉年华活动的组织者小安一共收到了 n个活动的举办申请，其中第 i 个活动的起始时间为 Si，活动的持续时间为Ti。这些活动都可以安排到任意一个嘉年华的会场，也可以不安排。
小安通过广泛的调查发现，如果某个时刻，两个嘉年华会场同时有活动在进行（不包括活动的开始瞬间和结束瞬间），那么有的选手就会纠结于到底去哪个会场，从而变得不开心。所以，为了避免这样不开心的事情发生，小安要求不能有两个活动在两个会场同时进行（同一会场内的活动可以任意进行）。
另外，可以想象，如果某一个嘉年华会场的活动太少，那么这个嘉年华的吸引力就会不足，容易导致场面冷清。所以小安希望通过合理的安排，使得活动相对较少的嘉年华的活动数量最大。
此外，有一些活动非常有意义，小安希望能举办，他希望知道，如果第i 个活动必须举办（可以安排在两场嘉年华中的任何一个），活动相对较少的嘉年华的活动数量的最大值。

Input

输入的第一行包含一个整数 n，表示申请的活动个数。
接下来 n 行描述所有活动，其中第 i 行包含两个整数 Si、Ti，表示第 i 个活
动从时刻Si开始，持续 Ti的时间。

Output

输出的第一行包含一个整数，表示在没有任何限制的情况下，活动较少的嘉
年华的活动数的最大值。
接下来 n 行每行一个整数，其中第 i 行的整数表示在必须选择第 i 个活动的
前提下，活动较少的嘉年华的活动数的最大值。

Sample Input

5
8 2
1 5
5 3
3 2
5 3

Sample Output

2
2
1
2
2
2

HINT
在没有任何限制的情况下，最优安排可以在一个嘉年华安排活动 1, 4，而在另一个嘉年华安排活动 3, 5，活动2不安排。
1≤n≤200 0≤Si≤10^9
1≤Ti≤ 10^9

思路：
摘自 < FZHvampire >
将时间离散化，令f[i][j]表示到时间i的时候，一个里面有j个，另一个最多有多少，sum[i][j]表示i到j这段区间里有多少个线段。
转移就是f[i][j]=max(f[k][j]+sum[k][i]，f[k][j−sum[k][i]])
如果强制性选一个的话，还需要设一个g[i][j]表示从i开始，一个里面有j个，另一个最多有多少。转移起来跟f数组一样。
令num[i][j]表示必须要选i到j这一段，而且不能有区间跨过这一段的最大值。
num[i][j]=max{min(k+p+sum[i][j],f[i][k]+g[j][p])}
这样暴力转移的话是n4的。
可以观察一下上面的那个式子，可以发现当x在增大的过程中，y只有减小才可能让最大值变大。
我们就可以利用这个性质，对于每一对i,j都单调的维护一下k,p就行了。
在算答案的时候，因为num[i][j]中有一个限制，就是不能有区间跨过i,j，所以答案并不是num[i][j]，而是max{num[p][q]}(p<=i,q>=j)。
复杂度是O(n3)。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 410;

struct activity{
    int l, r;
}act[N];

int n, tot;
int a[N], f[N][N], sum[N][N], g[N][N], num[N][N];

int main(){
    freopen ("show.in", "r", stdin);
    freopen ("show.out", "w", stdout);
    scanf("%d", &n);
    for(register int i=1; i<=n; ++i){
        scanf("%d%d", &act[i].l, &act[i].r);
        act[i].r += act[i].l;
        a[++tot] = act[i].l;
        a[++tot] = act[i].r;
    }
    sort(a+1, a+tot+1);
    int size = unique(a+1, a+tot+1) - a - 1;
    for(register int i=1; i<=n; ++i){
        act[i].l = lower_bound(a+1, a+size+1, act[i].l) - a;
        act[i].r = lower_bound(a+1, a+size+1, act[i].r) - a;
        for(register int j=1; j<=act[i].l; ++j)
            for(register int k=act[i].r; k<=size; ++k)
                ++sum[j][k];//sum[i][j]表示i到j这段区间里有多少个线段
    }
    memset(f, -63, sizeof(f));
    f[1][0] = sum[1][1];
    f[1][sum[1][1]] = 0;//f[i][j]表示到时间i的时候，会场1里面有j个活动，会场2最多有多少活动 
    for(register int i=2; i<=size; ++i)
        for(register int j=0; j<=n; ++j)
            for(register int k=1; k<i; ++k)
                f[i][j] = max(f[i][j], max(f[k][j] + sum[k][i], f[k][j-sum[k][i]]));
                //最后一段时间的活动都给1或2会场 
    int ans = 0;
    for(register int i=0; i<=n; ++i) ans = max(ans, min(i, f[size][i]));
    printf("%d\n", ans); 
    memset(g, -63, sizeof(g));
    g[size][0] = sum[size][size];
    g[size][sum[size][size]] = 0;
    for(register int i=size-1; i; --i)
        for(register int j=0; j<=n; ++j)
            for(register int k=i+1; k<=size; ++k)
                g[i][j] = max(g[i][j], max(g[k][j] + sum[i][k], g[k][j-sum[i][k]]));
                //g[i][j]从时间i到最后时刻，会场1里面有j个活动，会场2最多有多少活动 
    memset(num, -63, sizeof(num));
    for(register int i=1; i<=size; ++i)
        for(register int j=i; j<=size; ++j){
            int k = 0, q = n;
            while( 1 ){//num[i][j]表示必须要选i到j这一段，而且不能跨过这一段的最大值
                int o1 = min(k+1+q+sum[i][j], f[i][k+1]+g[j][q]);
                int o2 = min(k+q-1+sum[i][j], f[i][k]+g[j][q-1]);
                if(max(o1, o2) < num[i][j]) break;
                num[i][j] = max(o1,o2);
                if(o1 > o2) ++k;
                else --q;
            }
        }       
    for(register int i=1; i<=n; ++i){
        ans = 0; 
        for(register int j=1; j<=act[i].l; ++j)
            for(register int k=act[i].r; k<=size; ++k)
                ans = max(ans, num[j][k]);
        printf("%d\n", ans);
    }
    return 0;
}