HDU-6249 Alice’s Stamps（DP）

Alice’s Stamps
Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1430 Accepted Submission(s): 494

Problem Description
Alice likes to collect stamps. She is now at the post office buying some new stamps.
There are N different kinds of stamps that exist in the world; they are numbered 1 through N. However, stamps are not sold individually; they must be purchased in sets. There are M different stamp sets available; the ith set contains the stamps numbered Li through Ri. The same stamp might appear in more than one set, and it is possible that one or more stamps are not available in any of the sets.
All of the sets cost the same amount; because Alice has a limited budget, she can buy at most K different sets. What is the maximum number of different kinds of stamps that Alice can get?

Input
The input starts with one line containing one integer T, the number of test cases.T test cases follow.
Each test case begins with a line containing three integers: N, M, and K: the number of different kinds of stamps available, the number of stamp sets available, and the maximum number of stamp sets that Alice can buy.
M lines follow; the ithoftheselinesrepresentsthei^{th} stamp set and contains two integers, Li and Ri, which represent the inclusive range of the numbers of the stamps available in that set.
1≤T≤100
1≤K≤M
1≤N,M≤2000
1≤Li≤Ri≤N

Output
For each test case, output one line containing “Case #x: y”, where x is the test case number (starting from 1) and y is the maximum number of different kinds of stamp that Alice could get.

Sample Input
2
5 3 2
3 4
1 1
1 3
100 2 1
1 50
90 100

Sample Output
Case #1: 4
Case #2: 50
Hint

In sample case #1, Alice could buy the first and the third stamp sets, which contain the first four kinds
of stamp. Note that she gets two copies of stamp 3, but only the number of different kinds of stamps
matters, not the number of stamps of each kind.
In sample case #2, Alice could buy the first stamp set, which contains 50 different kinds of stamps.

首先说一句，动态规划是真的难。。。。
dp[i][j]表示从1 - i 位置选择 j 个集合的覆盖种数

接下来考虑状态转移方程式：
首先是在当前位置不选集合的情况：
dp[i][j] = max(dp[i][j],dp[i - 1][j]);
其次考虑它能转移到的点

用up[i] 记录覆盖i点的线段最右的点，如果要在 i 后面加一条线段，那么肯定优先取这个（因为它最右，同样加一条线段得到的覆盖长度更长)

所以dp[i][j]转移到dp[up[i]][j] = max(dp[i - 1][j - 1] + up[i] - i + 1,dp[up[i]][j]);

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int inf = 0x3f3f3f3f;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
const int N = 2005;

int dp[N][N];
int up[N];

int main()
{
    int t;
    scanf("%d",&t);
    int cnt = 0;
    while(t--)
    {
        cnt++;
        int n,m,k;
        scanf("%d %d %d",&n,&m,&k);

        memset(up,0,sizeof(up));

        for(int i = 0;i < m;++i){
            int l,r;
            scanf("%d %d",&l,&r);
            for(int j = l;j <= r;++j){
                up[j] = max(up[j],r);
            }
        }

        memset(dp,0,sizeof(dp));
        for(int i = 1;i <= n;++i){
            for(int j = 1;j <= k;++j){
                if(up[i]){
                    dp[up[i]][j] = max(dp[i - 1][j - 1] + up[i] - i + 1,dp[up[i]][j]);
                }
                dp[i][j] = max(dp[i][j],dp[i - 1][j]);
            }
        }

        int ans = 0;
        for(int i = 1;i <= n;++i){
            for(int j = 1;j <= k;++j){
                ans = max(ans,dp[i][j]);
            }
        }

        printf("Case #%d: %d\n",cnt,ans);
    }
    return 0;
}