这题算是一个典型的区间DP,方程式和奶牛零食极其的像,思想也是
我们定义
d
p
[
i
]
[
j
]
[
0
/
1
]
dp[i][j][0/1]
dp[i][j][0/1]表示区间
[
i
,
j
]
[i,j]
[i,j]内,除了
i
(
0
)
i(0)
i(0) 和
j
(
1
)
j(1)
j(1)其他都没选的最短时间
方程式的转移就很简单
我们思考一个简单的贪心策略
对于一段任务区间,如果我们先选了开门早的中间节点,那么我们一定会返回至两个区间端点处
如果此时端点处在到达前就已开门,我们一定会浪费时间,所以我们一定是先选取端点处的任务
在从一个端点至另一个端点时完成中间的任务
至于先选左还是选右,我们全部求出来取最小值就好了
于是转移就一目了然
d
p
i
,
j
,
1
=
m
a
x
{
d
p
i
,
j
+
1
,
1
+
m
a
x
(
p
o
s
j
+
1
−
p
o
s
j
,
s
t
a
r
t
t
i
m
e
j
)
,
d
p
i
−
1
,
j
,
0
+
m
a
x
(
p
o
s
j
−
p
o
s
i
−
1
,
s
t
a
r
t
t
i
m
e
j
)
}
dp_{i,j,1}=max\{dp_{i,j+1,1}+max(pos_{j+1}-pos_j,starttime_j),dp_{i-1,j,0}+max(pos_j-pos_{i-1},starttime_j)\}
dpi,j,1=max{dpi,j+1,1+max(posj+1−posj,starttimej),dpi−1,j,0+max(posj−posi−1,starttimej)}
d
p
i
,
j
,
0
=
m
a
x
{
d
p
i
,
j
+
1
,
1
+
m
a
x
(
p
o
s
j
+
1
−
p
o
s
i
,
s
t
a
r
t
t
i
m
e
i
)
,
d
p
i
−
1
,
j
,
0
+
m
a
x
(
p
o
s
i
−
p
o
s
i
−
1
,
s
t
a
r
t
t
i
m
e
i
)
}
dp_{i,j,0}=max\{dp_{i,j+1,1}+max(pos_{j+1}-pos_i,starttime_i),dp_{i-1,j,0}+max(pos_i-pos_{i-1},starttime_i)\}
dpi,j,0=max{dpi,j+1,1+max(posj+1−posi,starttimei),dpi−1,j,0+max(posi−posi−1,starttimei)}
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 1007;
struct node{
int x,t;
}task[maxn];
bool cmp1(node a,node b){
return a.x<b.x;
}
const int INF = 2147483647;
int n,m,p,dp[maxn][maxn][2];
int main(){
scanf("%d%d%d",&n,&m,&p);
for(int i=1;i<=n;i++)
scanf("%d%d",&task[i].x,&task[i].t);
//cout<<"!";
sort(task+1,task+1+n,cmp1);
memset(dp,0x3f,sizeof(dp));
dp[1][n][0]=max(task[1].x,task[1].t);
dp[1][n][1]=max(task[n].x,task[n].t);
for(int i=1;i<=n;i++){
for(int j=n;j>=i;j--){
dp[i][j][1]=min(dp[i][j][1],max(dp[i][j+1][1]+task[j+1].x-task[j].x,task[j].t));
dp[i][j][1]=min(dp[i][j][1],max(dp[i-1][j][0]+task[j].x-task[i-1].x,task[j].t));
dp[i][j][0]=min(dp[i][j][0],max(dp[i][j+1][1]+task[j+1].x-task[i].x,task[i].t));
dp[i][j][0]=min(dp[i][j][0],max(dp[i-1][j][0]+task[i].x-task[i-1].x,task[i].t));
}
}
int ans=INF;
for(int i=1;i<=n;i++){
ans=min(ans,min(dp[i][i][0],dp[i][i][1])+abs(p-task[i].x));
}
cout<<ans;
}