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

最新推荐文章于 2021-02-08 14:21:28 发布

原创最新推荐文章于 2021-02-08 14:21:28 发布 · 385 阅读

1 ·

CC 4.0 BY-SA版权

贪心同时被 3 个专栏收录

142 篇文章

订阅专栏

计蒜客

16 篇文章

订阅专栏

区间DP

15 篇文章

订阅专栏

本文介绍了一种解决黑客攻击多台电脑并返回安全地点的问题的算法。通过将电脑按位置排序，并采用动态规划方法，计算出黑客完成任务所需的最短时间。适用于网络安全策略制定与优化。

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

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;
}