HDU4381：Grid（类01背包）

Grid

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 903    Accepted Submission(s): 289

Problem Description

　　There are n boxes in one line numbered 1 to n, at the beginning, all boxes are black. Two kinds of operations are provided to you:

1 a _i x _i ：You can choose any x _i black boxes in interval [1,a _i], and color them white;
2 a _i x _i ：You can choose any x _i black boxes in interval [a _i,n], and color them white;

　　lcq wants to know if she use these operations in optimal strategy, the maximum number of white boxes she can get, and if she get maximum white boxes, the minimum number of operations she should use.
Tips: 
1. It is obvious that sometimes you can choose not to use some operations.
2. If the interval of one operation didn’t have enough black boxes, you can’t use this operation.

 

Input

　　The first line contains one integer T, indicating the number of test case.
　　The first line of each test case contains two integers N (1 <= N <= 1000) and M (1<=M<=1000), indicating that there are N grids and M operations in total. Then M lines followed, each of which contains three integers s _i(1<=s _i<=2) , a _i and x _i (0 <= x _i <= N,1<=a _i<=N), si indicating the type of this operation, a _i and x _i indicating that the interval is [1,a _i] or [a _i,n](depending on s _i), and you can choose x _i black boxes and color them white.

 

Output

　　For each test case, output case number first. Then output two integers, the first one is the maximum boxes she can get, the second one is the minimum operations she should use.

 

Sample Input

1 5 2 2 3 3 1 3 3

 

Sample Output

Case 1: 3 1

 

Author

WHU

 

Source

2012 Multi-University Training Contest 9

题意：略。

思路：背包问题，两边分别处理，dp[i]表示变白前i个格的最小次数，显然有dp[i] = min(dp[i], dp[i-c[k].a]+1)，i∈[c[k].a, c[k].x]，左右都是这个方程，注意需要先排序，从小的开始计算，最后枚举下结果就行。

# include <stdio.h>
# include <string.h>
# define INF 0x3f3f3f3f
# include <algorithm>
using namespace std;
struct node
{
    int x, a;
}l[1001], r[1001];
bool cmp(node a, node b) {return a.x < b.x;}
int dpr[1001], dpl[1001];
int main()
{
    int t, n, m, x, a, s, cas = 1;
    scanf("%d",&t);
    while(t--)
    {
        int cntl = 0, cntr = 0;
        scanf("%d%d",&n,&m);
        for(int i=0; i<m; ++i)
        {
            scanf("%d%d%d",&s,&x,&a);
            if(s==1)
            {
                l[cntl].x = x;
                l[cntl++].a = a;
            }
            else
            {
                r[cntr].x = n+1-x;
                r[cntr++].a = a;
            }
        }
        sort(l, l+cntl, cmp);
        sort(r, r+cntr, cmp);
        for(int i=1; i<=n; ++i)
            dpl[i] = dpr[i] = INF;
        dpl[0] = dpr[0] = 0;
        for(int i=0; i<cntr; ++i)//涂左边
            for(int j=r[i].x; j>=r[i].a; --j)
                dpr[j] = min(dpr[j], dpr[j-r[i].a]+1);
        for(int i=0; i<cntl; ++i)//涂右边
            for(int j=l[i].x; j>=l[i].a; --j)
                dpl[j] = min(dpl[j], dpl[j-l[i].a]+1);
        int imax=-INF, imin=INF;
        for(int i=0; i<=n; ++i)//枚举结果
        {
            for(int j=n-i; j>=0; --j)
            {
                if(dpl[i]!=INF && dpr[j]!=INF)
                {
                    if(i+j > imax)
                    {
                        imax = i+j;
                        imin = dpl[i] + dpr[j];
                    }
                    else if(i+j==imax)
                        imin = min(imin, dpl[i]+dpr[j]);
                    break;
                }
            }
        }
        printf("Case %d: %d %d\n",cas++, imax, imin);
    }
    return 0;
}

转载于:https://www.cnblogs.com/junior19/p/6730040.html