Acwing 0x50 动态规划~移动服务

题目链接：https://www.acwing.com/problem/content/description/276/

题意：

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

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

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

从 到 移动一个员工，需要花费 。

这个函数不一定对称，但保证 。

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

公司必须按顺序依次满足所有请求，目标是最小化公司花费，请你帮忙计算这个最小花费。

，位置是的整数。

 

题解：

表示完成第个请求后，三个员工分别位于时，公司当前的最小花费，

显然有三种状态，也就是三种情况，派第一个人去，或者第二个人去，或者第三个人去。

然后写出他们对应的状态转移方程:

派第一个人的话：

派第二个人的话：

派第三个人的话：

其中代表第i个请求

这个时候，我们发现这个算法的复杂度是，

我们可对其优化，我们可以去掉第四维。

表示完成第个请求后，其中一人位于，另外两人位于时最小花费。

我们写出转移方程：

派第一个人去，

派第二个人去，

派第三个人去，

在此基础上，我们仍然可以对第一维进行空间优化，第一维只要互不影响就可以，我们采用滚顶数组对其空间优化。

最终的转移方程：

简单附代码：

#include <bits/stdc++.h>
#define Pair pair<int,int>
#define fir first
#define sec second
namespace fastIO{
  #define BUF_SIZE 100000
  #define OUT_SIZE 100000
  //fread->read
  bool IOerror=0;
//inline char nc(){char ch=getchar();if(ch==-1)IOerror=1;return ch;}
  inline char nc(){
    static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
      if(p1==pend){
        p1=buf;pend=buf+fread(buf,1,BUF_SIZE,stdin);
        if(pend==p1){IOerror=1;return -1;}
      }
      return *p1++;
  }
  inline bool blank(char ch){return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';}
  template<class T> inline bool read(T &x){
    bool sign=0;char ch=nc();x=0;
    for(;blank(ch);ch=nc());
    if(IOerror)return false;
    if(ch=='-')sign=1,ch=nc();
    for(;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
    if(sign)x=-x;
    return true;
  }
  inline bool read(double &x){
    bool sign=0;char ch=nc();x=0;
    for(;blank(ch);ch=nc());
    if(IOerror)return false;
    if(ch=='-')sign=1,ch=nc();
    for(;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
    if(ch=='.'){double tmp=1; ch=nc();for(;ch>='0'&&ch<='9';ch=nc())tmp/=10.0,x+=tmp*(ch-'0');}
      if(sign)x=-x;return true;
  }
  inline bool read(char *s){
    char ch=nc();
    for(;blank(ch);ch=nc());
    if(IOerror)return false;
    for(;!blank(ch)&&!IOerror;ch=nc())*s++=ch;
    *s=0;
    return true;
  }
  inline bool read(char &c){
    for(c=nc();blank(c);c=nc());
    if(IOerror){c=-1;return false;}
    return true;
  }
  template<class T,class... U>bool read(T& h,U&... t){return read(h)&&read(t...);}
  #undef OUT_SIZE
  #undef BUF_SIZE
};using namespace fastIO;using namespace std;
 
const int N=1e3+5;
const double eps=1e-7;
const double pi=acos(-1.0);
const int mod=998244353;
const int inf=0x3f3f3f3f;

int p[N],C[N][N];
int f[2][N][N];
signed main(){
  int n,m;read(n,m);
  for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
      read(C[i][j]);
  for(int i=1;i<=m;i++)read(p[i]);
  p[0]=3;
  
  memset(f,inf,sizeof f);
  f[0][1][2]=0;
  for(int i=1;i<=m;i++){//请求
    for(int x=1;x<=n;x++){//f[i][x][y][z]
      for(int y=1;y<=n;y++){
        if(f[i-1&1][x][y]!=inf){
          int z=p[i-1];
          if(y!=p[i]&&z!=p[i])f[i&1][y][z]=min(f[i&1][y][z],f[i-1&1][x][y]+C[x][p[i]]); 
          if(x!=p[i]&&z!=p[i])f[i&1][x][z]=min(f[i&1][x][z],f[i-1&1][x][y]+C[y][p[i]]);
          if(x!=p[i]&&y!=p[i])f[i&1][x][y]=min(f[i&1][x][y],f[i-1&1][x][y]+C[z][p[i]]);
          f[i-1&1][x][y]=inf;
        }
      }
    }
  }
  
  int res=inf;
  for(int x=1;x<=n;x++){
    for(int y=1;y<=n;y++)
      res=min(res,f[n&1][x][y]);
  }
  printf("%lld\n",res);
  return 0;
}