codevs 1427 特种部队 (双路DP)

题意：一排按钮，从左边的第一个按钮开始向右按动，中间可以跳过某些按钮，按动到最右边的按钮后，反向向左按动。最终，每个按钮都要按且仅按一次。每两个相邻按钮上数字之差的总和的最小值，便是解开这把锁的密码。 

思路：

f[i][j]表示第一路扩展到i,第二路扩展到j的最优值.
对于max(i,j)后的一点k扩展 
(1~max(i,j)可以看做是被两路分成的两段不连续序列)
则:f[i][k]=min(f[i][k],f[i][j]+s[j][k]);//2路.
   f[k][j]=min(f[k][j],f[i][j]+s[i][k]);//1路.
最后枚举一个所谓的断点i求出贡献(因为不确定n点在哪一路). 

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn = 1e3+5;
const int INF = 0x3f3f3f3f;
int dis[maxn][maxn], dp[maxn][maxn], a[maxn], n;

int main(void)
{
    while(cin >> n)
    {
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                dis[i][j] = a[i]-a[j] < 0 ? a[j]-a[i] : a[i]-a[j];
        memset(dp, INF, sizeof(dp));
        dp[0][0] = 0;
        for(int i = 0; i <= n; i++)
            for(int j = 0; j <= n; j++)
            {
                int k = max(i, j)+1;
                dp[i][k] = min(dp[i][k], dp[i][j]+dis[j][k]);
                dp[k][j] = min(dp[k][j], dp[i][j]+dis[i][k]);
            }
        int ans = INF;
        for(int i = 0; i <= n; i++)
        {
            ans = min(ans, dp[i][n]+dis[i][n]);
            ans = min(ans, dp[n][i]+dis[i][n]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

思路2：

由于是双向的，而且是走到最后一个点再走回来

我们可以看做两条路同时从最后那个点往回走（相当于两条路有相同起点不同终点，除最后一点外，两条路不能经过相同一点）

那么可以在最先读入数组时就倒着存储，后面动规时从前到后计算便于理解和推理

我们可以用一个二维数组来动规求解，

dp[i][j]表示两条路分别走到i和j（i>j），并且从1到i的所有点都已经过

为了更直观些，我们设两条路分别为A和B，假设在一个状态下A走到i，B走到j

那么现在可以推出几个状态。

状态1：A上一步就在B的前面（那时B的位置<i-1），现在A又往前走了一步（从i-1走到i）

状态2：A上一步在B的后面（那时A所在位置<i-1），B在i-1处不变，这一步A超过B（从<i-1走到i）

然后惊讶的发现一个循环套循环可以解决所有状态

当j<i-1时状态都可以更新，同时可以满足状态更新的先后顺序

更新了dp[i][j],dp[i][i-1],然后dp[j][i],dp[i-1][i]也是相同道理

下面是代码：

//Serene

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdlib>

#include<cstdio>

#include<cmath>

using namespace std;

const int maxn=1000+10;

const long long INF=1e18;

long long dp[maxn][maxn],ans=INF;//dp的二维分别代表两次走到哪里

int n;int a[maxn];

int main()

{

scanf("%d",&n);

for(int i=1;i<=n;++i)

scanf("%d",&a[n-i+1]);//倒着存储

for(int i=1;i<=n;++i)

for(int j=1;j<=n;++j)

dp[i][j]=INF;//初始化

dp[1][1]=0;

dp[1][2]=dp[2][1]=abs(a[2]-a[1]);

for(int i=3;i<=n;++i)//从3开始j能存在，可以处理各种情况

for(int j=1;j<i-1;++j)

{

dp[i][j]=min(dp[i][j],dp[i-1][j]+abs(a[i]-a[i-1]));//上一步走在前面的再往前走的情况

dp[j][i]=min(dp[j][i],dp[j][i-1]+abs(a[i]-a[i-1]));

dp[i][i-1]=min(dp[i][i-1],dp[i-1][j]+abs(a[i]-a[j]));//上一步走在后面的超越前面的情况

dp[i-1][i]=min(dp[i-1][i],dp[j][i-1]+abs(a[i]-a[j]));

}

for(int i=1;i<=n;++i)

ans=min(ans,dp[i][n]);//只要有一个走到末尾就可以更新答案

cout<<ans;

return 0;

}