蓝书（算法竞赛进阶指南）刷题记录——CH2601 & 洛谷2243 电路维修（双端队列bfs）

题目：CH2601/luogu2243.
题目大意：给定一张$r\ast c$的电路，边的状态给定，为/或\，求使得点$(1,1)$与$(r,c)$连通的最小交换边数.
$1\le r,c\le 500$，数据组数$\le 5$.

首先这道题我们转换为一张无向图，那么我们可以连边，当两个点之间的边与这个格点上的状态重合时，我们将边权设为$0$，否则设为$1$.

接下来我们就得到了一张只有$0$或$1$作为边权的图，要求图的最短路.

这个时候我们直接跑最短路吗？我们可以不用最短路，而用双端队列BFS.

我们可以在扩展的时候，经过边权为$0$的边插入队头，为$1$的边插入队尾.这样我们可以保证队列中的元素只有两种权值以及单调.

然后这时候当我们的队头被我们取出后，我们可以发现队头的值已经不可能被再次更新了.但不意味着每个元素只会被更新一次，只要这个元素还未出队或未进队，这个元素就可以被重复更新.

所以这个算法的时间复杂度为$O(rc+m)$，其中$m$表示连的边数，由于一个点最多会连出$4$条边，所以我们可以将时间复杂度看成$O(5rc)$，省略常数后为$O(rc)$.

代码如下：

#include<bits/stdc++.h>
  using namespace std;
#define Abigail inline void
const int _x[4]={-1,-1,1,1},_y[4]={-1,1,1,-1};
const int N=500;
const int INF=(1<<30)-1;
int v[N+9][N+9][4],n,m;
int dis[N+9][N+9],use[N+9][N+9];
struct node{
  int x,y;
  node(int a,int b){
    x=a,y=b;
  }
};
deque<node>q;
char rc(){
  char c=getchar();
  while (c^'/'&&c^'\\') c=getchar();
  return c;
}
void bfs(int sx,int sy){
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      use[i][j]=0,dis[i][j]=INF;
  use[sx][sy]=1;dis[sx][sy]=0;
  q.push_back(node(sx,sy));
  while (!q.empty()){
    node t=q.front();q.pop_front();
    use[t.x][t.y]=1;
    for (int i=0;i<4;i++){
      int nh=t.x+_x[i],nl=t.y+_y[i];
      if (use[nh][nl]||nh>n||nh<1||nl>m||nl<1) continue;
      dis[nh][nl]=min(dis[t.x][t.y]+v[t.x][t.y][i],dis[nh][nl]);
      if (use[nh][nl]) continue;
      if (v[t.x][t.y][i]) q.push_back(node(nh,nl));
      else q.push_front(node(nh,nl));
    }
  }
}
Abigail into(){
  int dis;
  char c;
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++){
      c=rc();
      dis=c=='/'?1:0;
      v[i][j][2]=dis;v[i+1][j+1][0]=dis;
      v[i+1][j][1]=dis^1;v[i][j+1][3]=dis^1;
    }
  n++;m++;
}
Abigail work(){
  bfs(1,1);
}
Abigail outo(){
  if (use[n][m]) printf("%d\n",dis[n][m]);
  else printf("NO SOLUTION\n");
}
int main(){
  int T;
  scanf("%d",&T);
  while (T--){
    into();
    work();
    outo();
  }
  return 0;
}