Newcoder 142 B.Interval Revisited（dp）

Description

给出$n$个小区间$[l_i,r_i]$，每个小区间有权值$w_i$，要求用这$n$个区间覆盖区间$[1,m]$，使得$[1,m]$中每个整数$x$都会被至少一个小区间覆盖，$x$的权值$s_x$为覆盖$x$的小区间的权值之和，要最小化$s_x$的最大值

Input

第一行输入一整数$T$表示用例组数，每组用例首先输入两个整数$n,m$表示小区间个数和需要被覆盖的区间长度，之后$n$行每行输入三个整数$l_i,r_i,w_i$表示一个小区间和这个小区间的权值

$(1\le n,m\le 2000,1\le l_r\le r_i\le m,.1\le w_i\le 1000,\sum n\le 20000)$

Output

对于每组用例，输出最小化的$s_x$的最大值，如果$n$个小区间无法覆盖$[1,m]$则输出$-1$

Sample Input

2
2 4
1 2 2
3 4 5
1 4
1 3 1

Sample Output

5
-1

Solution

显然一个位置不会被超过两个区间覆盖，把所有区间按左端点和右端点为两个关键字排序，编号为$0,1,...,n-1$，以$dp[i][j]$表示一定选第$i$个区间、下一次准备选第$j$个区间时每个位置最大值最小化的结果，那么根据第$j$个区间选或不选有转移
$dp[i][j+1]=min(dp[i][j+1],dp[i][j])$

$dp[j][next[i]]=min(dp[j][next[i]],max(dp[i][j],w[i]+w[j])),l[j]\le r[i]$

$dp[j][max(next[i],j+1)]=min(dp[j][max(next[i],j+1)],max(dp[i][j],w[j])),l[j]=r[i]+1$

其中$next[i]$表示第$i$个区间之后第一个与第$i$个区间不交的区间编号

那么第一种转移就是不选第$j$个区间，而第二种转移表示选了$j$区间之后，下一次只能选一个与第$i$个区间不交的区间，否则会出现三个区间覆盖一点的情况，此时被第$i$个区间和第$j$个区间覆盖的位置权值为$w[i]+w[j]$，第三种转移表示如果没有区间与第$i$个区间重叠，那么至少要与第$i$个区间相连，此时下一个可选区间要么是$next[i]$，要么如果$next[i]=j$就是第$j+1$个区间，答案即为$min(dp[i][n],0\le i<n,r[i]=m)$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f,maxn=2005;
struct node
{
    int l,r,w;
    bool operator<(const node&b)const
    {
        if(l!=b.l)return l<b.l;
        if(r!=b.r)return r<b.r;
        return w<b.w;
    }
}a[maxn];
int T,n,m,nex[maxn],dp[maxn][maxn];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)scanf("%d%d%d",&a[i].l,&a[i].r,&a[i].w);
        sort(a,a+n);
        memset(dp,INF,sizeof(dp));
        for(int i=0;i<n;i++)
        {
            nex[i]=n;
            for(int j=i+1;j<n;j++)
                if(a[j].l>a[i].r)
                {
                    nex[i]=j;
                    break;
                }
        }   
        int ans=INF;
        for(int i=0;i<n;i++)
        {
            if(a[i].l==1)dp[i][i+1]=a[i].w;
            for(int j=i+1;j<n;j++)
            {
                dp[i][j+1]=min(dp[i][j+1],dp[i][j]);
                if(a[j].l<=a[i].r)dp[j][nex[i]]=min(dp[j][nex[i]],max(dp[i][j],a[i].w+a[j].w));
                if(a[j].l==a[i].r+1)dp[j][max(nex[i],j+1)]=min(dp[j][max(nex[i],j+1)],max(dp[i][j],a[j].w));
            }
            if(a[i].r==m)ans=min(ans,dp[i][n]);
        }
        if(ans==INF)ans=-1;
        printf("%d\n",ans);
    }
    return 0;
}