274. 移动服务

一个公司有三个移动服务员，最初分别在位置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

思路：线性动规，具体思路在代码注释

#include <bits/stdc++.h>
using namespace std;
#define N 1010
int dp[N][201][201];//执行到第i个请求，其他两个点所在的位置（一共有三个点，但是其中一个点的位置是确定的，也就是p[i])
int l,n;
int p[N];//请求
int w[201][201];

int main()
{
    scanf("%d %d",&l,&n);
    for(int i=1;i<=l;i++)
    {
        for(int j=1;j<=l;j++)
        {
            scanf("%d",&w[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i]);
    }
    memset(dp,0x3f3f3f3f,sizeof(dp));
    dp[0][1][2]=0;
    p[0]=3;
    for(int i=0;i<n;i++)//因为此次dp是求出状态的被依赖状态，所以要从0开始
    {
        for(int x=1;x<=l;x++)
        {
            for(int y=1;y<=l;y++)
            {
                int z=p[i],u=p[i+1];//z代表第三个点所在的地方，u代表下一个指定要求的地点
                if(x==z||y==z||x==y) continue;
                int v=dp[i][x][y];//代表此状态
                //三种方案
                dp[i+1][x][y]=min(dp[i+1][x][y],v+w[z][u]);//从z->u
                dp[i+1][z][y]=min(dp[i+1][z][y],v+w[x][u]);//从x->u,所以x就会被z代替
                dp[i+1][x][z]=min(dp[i+1][x][z],v+w[y][u]);//从y->u,所以y就会被z代替
            }
        }
    }
    int ans=0x3f3f3f3f;
    for(int x=1;x<=l;x++)
    {
        for(int y=1;y<=l;y++)
        {
            int z=p[n];
            if(x==z||y==z||x==y) continue;
            ans=min(ans,dp[n][x][y]);
        }
    }
    cout<<ans<<endl;
    return 0;
}