蓝书（算法竞赛进阶指南）刷题记录——CH2601 电路维修

题目：CH2601.

题目大意：给定一张电路，边的状态给定，为'/'或'\'，求使得点(1,1)与(r,c)连通的最小交换边数.

首先这道题我们转换为一张无向图，那么我们可以连边，当两个点之间的边与这个格点上的状态重合时，我们将边权设为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];      //use[i][j]为0表示未进队，为1表示进队但未出队，为2表示出队
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();
    use[t.x][t.y]=2;
    q.pop_front();     //必须写在这里，不然删除的不一定是这个状态 
    for (int i=0;i<4;i++){
      int nh=t.x+_x[i],nl=t.y+_y[i];
      if (use[nh][nl]==2||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;
}

蓝书（算法竞赛进阶指南）刷题记录——CH2601 电路维修

猜你喜欢