一个公司有三个移动服务员，最初分别在位置1，2，3处。

如果某个位置（用一个整数表示）有一个请求，那么公司必须指派某名员工赶到那个地方去。

某一时刻只有一个员工能移动，且不允许在同样的位置出现两个员工。

从 p 到 q 移动一个员工，需要花费 c(p,q)。

这个函数不一定对称，但保证 c(p,p)=0。

给出N个请求，请求发生的位置分别为 p1~pN。

公司必须按顺序依次满足所有请求，且过程中不能去其他额外的位置，目标是最小化公司花费，请你帮忙计算这个最小花费。

输入格式

第1行有两个整数L,N，其中L是位置数量，N是请求数量，每个位置从1到L编号。

第2至L+1行每行包含L个非负整数，第i+1行的第j个数表示c(i,j) ，并且它小于2000。

最后一行包含N个整数，是请求列表。

一开始三个服务员分别在位置1，2，3。

输出格式

输出一个整数M，表示最小花费。

数据范围

3≤L≤200,
1≤N≤1000

输入样例：

5 9
0 1 1 1 1
1 0 2 3 2
1 1 0 4 1
2 1 5 0 1
4 2 3 4 0
4 2 4 1 5 4 3 2 1

输出样例：

5

典型线性DP问题，对于该问题我一直在想如何从维护的当前状态去找历史状态。看了题解之后发现，当一个问题对于它所依赖的状态不好求解时，不妨换个思路，即由当前状态去维护由它能到达的所有状态；这个思路就好像LIS中由i-1推出了i，是根据历史状态维护当前状态，而这个是由i推出i+1，即是根据当前状态去维护下一个状态，这种思路需要保证在计算下一状态时你的当前状态已经是最优的(无后效性)
思路：首先我们发现，必须一定要知道这三个服务员的具体位置，才能够求出相应的解，因为由一个位置移动到另一个位置都会有不同的权值，二维空间不足以维护这么多信息，所以我们规定f[i][x][y]是当前在第i个位置，且另外两个位置分别为x，y时的最小解，而由它能推出(更新)的状态有:f[i+1][x][y],f[i+1][arr[i]][y],f[i+1][x][arr[i]],当然你也可以令当前状态维护后两维相调换的结果,那样做的结果就是保证无顺序性，更新状态也只需要更新到f[i][x][x-1]
代码如下：


/*************************************************************************
    > File Name: acwing.cpp
# Author: Badwoman
# mail: 1194446133@qq.com
    > Created Time: 2020年12月06日 星期日 21时32分50秒
 ************************************************************************/

#include<set>
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<map>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#define ll long long
#define ull unsigned long long
#define pb push_back
#define mp make_pair
using namespace std;
const int N = 1e3+10,L = 2e2+10,inf = 0x3f3f3f3f;
int l,n,arr[N],c[L][L],f[N][L][L];
void solve(){
    scanf("%d%d",&l,&n);
    for(int i=1;i<=l;++i){
        for(int j=1;j<=l;++j){
            scanf("%d",&c[i][j]);
        }
    }
    for(int i=1;i<=n;++i)scanf("%d",&arr[i]);
    memset(f,inf,sizeof f);
    arr[0] = 3;
    f[0][1][2] = f[0][2][1] = 0;
    for(int i=0;i<n;++i){
        for(int x=1;x<=l;++x){
            for(int y=1;y<x;++y){
                int p = f[i][x][y];
                if(x==y||arr[i]==x||arr[i]==y)continue;
                f[i+1][x][y] = min(f[i+1][x][y],p+c[arr[i]][arr[i+1]]);
                f[i+1][y][x] = min(f[i+1][y][x],p+c[arr[i]][arr[i+1]]);
                f[i+1][y][arr[i]] = min(f[i+1][y][arr[i]],p+c[x][arr[i+1]]);
                f[i+1][arr[i]][y] = min(f[i+1][arr[i]][y],p+c[x][arr[i+1]]);
                f[i+1][x][arr[i]] = min(f[i+1][x][arr[i]],p+c[y][arr[i+1]]);
                f[i+1][arr[i]][x] = min(f[i+1][arr[i]][x],p+c[y][arr[i+1]]);
            }
        }
    }
    int ans = inf;
    for(int i=1;i<=l;++i){
        for(int j=1;j<=l;++j){
            int z = arr[n];
            if(z == i||z == j||i==j)continue;
            ans = min(ans,f[n][i][j]);
        }
    }
    printf("%d\n",ans);
}

int main(){
    solve();
    return 0;
}

写在最后，DP问题确定阶段时，如果阶段不能很容易的由已知量导出，进行附加信息操作。DP问题当所依赖状态不好思考时，不妨考虑维护被依赖状态。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章