NWERC 2015

2015-2016 Northwestern European Regional Contest (NWERC 2015)

F H没做

似乎只有 B 题有点意思

D：数论分块枚举所有上取整区间，只需要对于所有下取整的区间，取在右端点处的上取整的值即可。这些值是所有上取整区间的左端点。

B

题意：有 n 个区间，分成 p 组，每组的权值是所有区间交的长度，交不能是 0 。求权值和最大。保证有解。 \(n,p \le 200\)

key：思路，dp

对于每一组，限制区间交的长度的区间至多是 2 个（认为 {[1,3],[2,4],[2,3]} 只有 [2,3] 限制）。考虑一个分组方案，定义这种区间是好的，其他区间（即不限制它所在组的权值）是坏的。

显然为了使权值最大，每个区间都趋向于成为坏的。

1. 限制该组权值的区间只有 1 个。此时其他区间一定都包含它。
2. 限制该组权值的区间有 2 个。取其中一个为 a，那么 a 一定不包含任何其它区间，因为如果它包含其它区间，那么它可以分配到它包含的某个区间所对应的组，成为一个坏的，此时会使答案更大。

所以对于一个包含其它区间的区间，它要么被分配到它包含的某个区间的组内（此时不影响答案），要么单独成为一组（成为第一类），所以可以按这个性质进行分类。

具体地说，先把给定的 n 个区间划分为两类：如果该区间不包含任何其它区间，分到 A 类。否则分到 B 类。

A 类中的区间没有包含关系，所以排序后的分组一定是一段段区间，这个可以 DP （甚至因为决策单调性可以做到 \(O(n^2)\)）

B 类中的区间要么单独成组，要么不影响答案，所以只需要排序取长度前若干大即可。

#include
using namespace std;

typedef long long LL;
typedef long double LD;
typedef pair pii;
typedef pair pli;
const int SZ = 1e6 + 10;
const int INF = 1e9 + 10;
const int mod = 1e9 + 7;
const LD eps = 1e-8;

LL read() {
    LL n = 0;
    char a = getchar();
    bool flag = 0;
    while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
    while(a <= '9' && a >= '0') { n = n * 10 + a - '0',a = getchar(); }
    if(flag) n = -n;
    return n;
}

struct haha {
    int l,r;
}a[SZ];

bool cmplen(haha a,haha b) { return a.r-a.l < b.r-b.l; }
bool cmplen2(haha a,haha b) { return a.r-a.l > b.r-b.l; }
bool cmpl(haha a,haha b) { return a.l < b.l; }

vector A,B;
/// A: 没包含任何

int f[210][210];

int main() {
    int n = read(),p = read();
    for(int i = 1;i <= n;i ++) {
        a[i].l = read();
        a[i].r = read();
    }
    sort(a+1,a+1+n,cmplen);
    for(int i = 1;i <= n;i ++) {
        bool flag = 0;
        for(haha p : A) {
            if(a[i].l <= p.l && p.r <= a[i].r) {
                flag = 1; break;
            }
        }
        if(!flag) A.push_back(a[i]);
        else B.push_back(a[i]);
    }
    sort(A.begin(),A.end(),cmpl);
    for(int i = 0;i <= A.size();i ++)
        for(int j = 0;j <= p;j ++)
            f[i][j] = -INF;
    f[0][0] = 0;
    for(int k = 1;k <= p;k ++) {
        for(int i = 1;i <= A.size();i ++) {
            int l = A[i-1].l;
            int r = A[i-1].r;
            for(int j = i-1;j >= 0;j --) {
                if(l>=r) break;
                f[i][k] = max(f[i][k],f[j][k-1] + r-l);
                if(j) l = max(l,A[j-1].l),r = min(r,A[j-1].r);
            }
        }
    }
    sort(B.begin(),B.end(),cmplen2);
    LL ans = f[A.size()][p],sum = 0;
    for(int i = 0;i < min((int)B.size(),p);i ++) {
        sum += B[i].r-B[i].l;
        ans = max(ans,sum+f[A.size()][p-i-1]);
    }
    cout << ans << endl;
}

转载于:https://www.cnblogs.com/dqsssss/p/11349572.html