HDU - 6249 Alice’s Stamps dp+线段树+讲解

最新推荐文章于 2020-01-13 15:45:58 发布

原创最新推荐文章于 2020-01-13 15:45:58 发布 · 338 阅读

1 ·

CC 4.0 BY-SA版权

DP 同时被 3 个专栏收录

26 篇文章

订阅专栏

2018模板整理

24 篇文章

订阅专栏

线段树

9 篇文章

订阅专栏

本文介绍了一种解决区间覆盖问题的动态规划方法，并通过优化将复杂度从n^3降至n^2 * logn。利用线段树维护最大值，实现高效区间合并。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

给定n个区间 [Li， Ri] ，让你选择最多 k 个，问区间的并最大是多少；

思路：

看网上题解都是n^2 对区间进行操作的，我的方才比赛做法是n^3 优化成n^2 * logn的

首先我们去重，按照区间右值排序，用dp[i][j] 表示当前选到第i个区间，已经选了j个区间的最大区间并的长度，这样的话进行下次转移的时候，我们还得考虑前面选了的区间的最右值是多少，这样才能正确的转移

所以不考虑前面所选区间右值的情况下的转移方程就是：

dp[i][j] = max ( dp[i-1][j] , 最大区间并(dp[t][j-1]&第i个区间) t from j to i-1 )；

大概跟划分数那个转移方程似的，，上述的转移方程是 n^3 的，所以得需要优化，优化的话就是优化掉找dp[t][j-1] 跟当前区间i的最大区间并的这一维，

这时我们的dp方程表示：

dp[i][j][0]是前i个区间选完j个区间的最大区间并的值，dp[i][j][1]是前i个区间选完j个区间的能到达的最右边的值

然后我们发现在寻找 dp[t][j-1][0] 的时候，dp[t][j-1][1] 可能在当前区间左值L的左边，也可能大于L，

对于小于L的 dp[t][j-1][1] ，我们只要选一个最大的dp[t][j-1][0] 就好了，因为她们转移都是 dpi][j][0] = dp[t][j-1][0] + 当前区间长度

对于大于L的 dp[t][j-1][1], 我们发现转移方程为 dp[i][j][0] = dp[t][j-1][0] + R(当前区间右值) - dp[t][j-1][1],所以此时我们维护一个最大的 dp[t][j-1][0] - dp[t][j-1][1], 就解决了整个的问题，，

所以我们用 j（当前选了j个）做外层循环，跟滚动数组似的，每次维护两棵线段树，分别维护上述两个最大值，

维护他们的位置就是其最优答案对应的区间的最右边的值

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn = 2010;
const int INF = 0x3f3f3f3f;
int dp[maxn][maxn][2];
int vis[maxn];
struct node {
    int l,r;
} a[maxn],s[maxn];

bool cmp(node a,node b) {
    return a.r < b.r;
}

int max1[maxn<<2];
int max2[maxn<<2];

void push_up1(int id) {
    max1[id] = max(max1[id<<1], max1[id<<1 | 1]);
}
void update1(int id, int l, int r, int ul, int ur, int v) {
    if(r < l || ur < ul)
        return;
    if(l == r) {
        max1[id] = v;
        return;
    }
    int mid = (l+r) >> 1;
    if(ur <= mid) {
        update1(id<<1, l, mid, ul, ur, v);
    } else if(ul > mid) {
        update1(id<<1 | 1, mid+1, r, ul, ur, v);
    } else {
        update1(id<<1, l, mid, ul, mid, v);
        update1(id<<1 | 1, mid+1, r, mid+1, ur, v);
    }
    push_up1(id);
}
int query1(int id, int l, int r, int ql, int qr) {
    if(r < l || qr < ql)
        return 0;
    if(l == ql && r == qr) {
        return max1[id];
    }
    int mid = (l + r) >> 1;
    if(qr <= mid) {
        return query1(id<<1, l, mid, ql, qr);
    } else if(ql > mid) {
        return query1(id<<1 | 1, mid+1, r, ql, qr);
    } else {
        return max( query1(id<<1, l, mid, ql, mid), query1(id<<1 | 1, mid+1, r, mid+1, qr) );
    }
}

void push_up2(int id) {
    max2[id] = max(max2[id<<1], max2[id<<1 | 1]);
}
void update2(int id, int l, int r, int ul, int ur, int v) {
    if(r < l || ur < ul)
        return;
    if(l == r) {
        max2[id] = v;
        return;
    }
    int mid = (l+r) >> 1;
    if(ur <= mid) {
        update2(id<<1, l, mid, ul, ur, v);
    } else if(ul > mid) {
        update2(id<<1 | 1, mid+1, r, ul, ur, v);
    } else {
        update2(id<<1, l, mid, ul, mid, v);
        update2(id<<1 | 1, mid+1, r, mid+1, ur, v);
    }
    push_up2(id);
}
int query2(int id, int l, int r, int ql, int qr) {
    if(r < l || qr < ql)
        return -INF;
    if(l == ql && r == qr) {
        return max2[id];
    }
    int mid = (l + r) >> 1;
    if(qr <= mid) {
        return query2(id<<1, l, mid, ql, qr);
    } else if(ql > mid) {
        return query2(id<<1 | 1, mid+1, r, ql, qr);
    } else {
        return max( query2(id<<1, l, mid, ql, mid), query2(id<<1 | 1, mid+1, r, mid+1, qr) );
    }
}

int main() {
    int T;
    int kase = 0;
    scanf("%d",&T);
    while(T--) {
        memset(dp,0,sizeof(dp));
        memset(vis,0,sizeof(vis));
        memset(max1, 0, sizeof max1);
        memset(max2, -INF, sizeof max2);
        int n,m,k;
        scanf("%d%d%d",&n,&m,&k);
        for(int i = 1; i <= m; i++) {
            scanf("%d%d",&a[i].l,&a[i].r);
        }
        int cnt = 1;

        for(int i = 1; i <= m; i++) {
            if(vis[i])
                continue;
            for(int j = 1; j <= m; j++) {
                if(i==j)
                    continue;
                if(a[i].l<=a[j].l&&a[i].r>=a[j].r) {
                    vis[j] = 1;
                }
            }
        }
        for(int i = 1; i <= m; i++) {
            if(vis[i]==0)
                s[cnt++] = a[i];
        }
        sort(s+1,s+cnt,cmp);


        if(cnt-1<=k) {
            int ans = 0;
            for(int i = 1; i < cnt; i++) {
                if(i==1)
                    ans += s[i].r-s[i].l+1;
                else {
                    if(s[i].l>s[i-1].r)
                        ans += s[i].r-s[i].l+1;
                    else
                        ans += s[i].r-s[i-1].r;
                }
            }
            printf("Case #%d: %d\n",++kase,ans);
        } else {
            for(int j = 1; j <= k; j++) {
                for(int i = 1; i < cnt; i++) {
                    int res = 0;
                    int t1  =  query1(1,1,2000, 1, s[i].l-1) + (s[i].r - s[i].l + 1); 
                    int t2 = query2(1, 1, 2000, s[i].l, s[i].r-1) + s[i].r;
                    int t3 = dp[i-1][j][0];

                    dp[i][j][0] = max(t1, t2);
                    dp[i][j][1] = s[i].r;

                    if(t3 >= dp[i][j][0]) {
                        dp[i][j][0] = t3;
                        dp[i][j][1] = min(dp[i][j][1], dp[i-1][j][1]);
                    }
                }
                memset(max1, 0, sizeof max1);
                memset(max2, -INF, sizeof max2);
                for(int i = j; i < cnt; ++i) {
                    update1(1,1,2000, dp[i][j][1], dp[i][j][1], dp[i][j][0]);
                    update2(1,1,2000, dp[i][j][1], dp[i][j][1], dp[i][j][0]-dp[i][j][1]);
                }
            }
            int ans = dp[cnt-1][k][0];
            printf("Case #%d: %d\n",++kase,ans);
        }
    }
    return 0;
}