274. 移动服务

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

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

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

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

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

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

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

输入格式

第 11 行有两个整数 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,线性DP) O(NL2)
状态表示：

f[i][x][y]表示已经处理完前i个请求，且三个服务员分别在p[i], x, y的所有方案的集合；
f[i][x][y]的值是集合中所有方案的花费的最小值；
状态计算：
这里状态之间的拓扑关系比较特殊，f[i][x][y]所依赖的状态枚举起来不太方便，但f[i][x][y]被依赖的很容易枚举，只有3类：

位于p[i]的服务员出发前往p[i + 1]，此时状态变成f[i + 1][x][y] = f[i][x][y] + w[p[i]][p[i + 1]];
位于x的服务员出发前往p[i + 1]，此时状态变成f[i + 1][p[i]][y] = f[i][x][y] + w[x][p[i + 1]];
位于y的服务员出发前往p[i + 1]，此时状态变成f[i + 1][x][p[i]] = f[i][x][y] + w[y][p[i + 1]];
最终答案从f[m][1...n][1...n]取最小值即可。

时间复杂度
共有 NL2个状态，计算每个状态需要 O(1)的计算量，因此总时间复杂度是 O(NL2)。

参考链接

代码如下：

#include <bits/stdc++.h>

using namespace std;
int c[210][210],p[1010],dp[1010][210][210];
int l,n;
int main()
{
    cin>>l>>n;
    for(int i=1;i<=l;i++)
        for(int j=1;j<=l;j++)
            cin>>c[i][j];

    for(int i=1;i<=n;i++)cin>>p[i];
    p[0]=3;
    memset(dp,0x3f,sizeof dp);
    dp[0][1][2]=0;
    for(int i=0;i<n;i++)
    {
        for(int x=1;x<=l;x++)
        {
            for(int y=1;y<=l;y++)
            {
                int z=p[i],v=dp[i][x][y];
                if(x==y||y==z||z==x)continue;
                int u=p[i+1];
                dp[i+1][x][y]=min(dp[i+1][x][y],v+c[z][u]);
                dp[i+1][z][y]=min(dp[i+1][z][y],v+c[x][u]);
                dp[i+1][x][z]=min(dp[i+1][x][z],v+c[y][u]);
            }
        }
    }
    int ans=1e9;
    for(int x=1;x<=l;x++)
    {
        for(int y=1;y<=l;y++)
        {
            ans=min(ans,dp[n][x][y]);
        }
    }
    cout<<ans;
    return 0;
}