计蒜客 16953 Hack Portals（贪心+区间DP）

Description

区间$[0,l]$上有$n$台电脑，第$i$台电脑在$x_i$处，要在$t_i$秒后才能被黑，学校位置在$k$处，初始黑客在$0$位置，单位长度移动耗时一秒，问最少花多少时间该黑客可以把每台电脑都黑掉且回到学校

Input

第一行一整数$T$表示用例组数，每组用例首先输入三个整数$n,l,k$，之后$n$行每行两个整数$x_i,t_i$表示第$i$台电脑的位置和黑这台电脑的时间限制$(n\le 1000,l\le 1000,0\le k,x_i\le l,0\le t_i<32768)$

Output

输出最少用时

Sample Input

1

4 10 3
8 9
4 21
3 16
8 12

Sample Output

Case #1: 22

Solution

把电脑按坐标排序，如果第$i$个电脑到第$j$个电脑都还没有被黑，那么先黑$i$电脑或者先黑$j$电脑要比先黑中间的某个$k$电脑更优，因为如果先黑中间某个电脑，之后必然还要走到$i$电脑和$j$电脑，那么不如先黑掉$i$电脑或者$j$电脑，之后去黑另一端的电脑时必然会经过中间的电脑将其黑掉，故设$dp[i][j][0/1]$表示只剩下第$i$个电脑和第$j$个电脑没被黑时，先黑$i$电脑/$j$电脑所需的最少用时，那么$dp[i][j][0/1]$只会由$dp[i-1][j][0]$和$dp[i][j+1][1]$转移过来，转移方程为

$dp[i][j][0]=max(t_i,min(dp[i-1][j][0]+x_i-x_{i-1},dp[i][j+1][1]+x_{j+1}-x_i))$

$dp[i][j][1]=max(t_j,min(dp[i-1][j][0]+x_{j}-x_{i-1},dp[i][j+1][1]+x_{j+1}-x_j))$

以此转移求得$dp$，则最少用时即为$min(min(dp[i][i][0],dp[i][i][1])+abs(x_i-k))$

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=1005;
int T,Case=1,n,l,k,dp[maxn][maxn][2];
struct node
{
    int x,t;
    bool operator<(const node&b)const
    {
        if(x!=b.x)return x<b.x;
        return t<b.t;
    }
}a[maxn];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&l,&k);
        for(int i=1;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].t);
        sort(a+1,a+n+1);
        dp[1][n][0]=max(a[1].x,a[1].t);
        dp[1][n][1]=max(a[n].x,a[n].t);
        for(int k=n-1;k>=1;k--)
            for(int i=1;i+k-1<=n;i++)
            {
                int j=i+k-1;
                dp[i][j][0]=dp[i][j][1]=INF;
                if(i>1)
                {
                    dp[i][j][0]=min(dp[i][j][0],dp[i-1][j][0]+a[i].x-a[i-1].x);
                    dp[i][j][1]=min(dp[i][j][1],dp[i-1][j][0]+a[j].x-a[i-1].x);
                }
                if(j<n)
                {
                    dp[i][j][0]=min(dp[i][j][0],dp[i][j+1][1]+a[j+1].x-a[i].x);
                    dp[i][j][1]=min(dp[i][j][1],dp[i][j+1][1]+a[j+1].x-a[j].x);
                }
                dp[i][j][0]=max(dp[i][j][0],a[i].t);
                dp[i][j][1]=max(dp[i][j][1],a[j].t);
            }
        int ans=INF;
        for(int i=1;i<=n;i++)ans=min(ans,min(dp[i][i][0],dp[i][i][1])+abs(a[i].x-k));
        printf("Case #%d: %d\n",Case++,ans);
    }
    return 0;
}