acwing175.电路维修

电路维修

题目链接

题目描述

达达是来自异世界的魔女，她在漫无目的地四处漂流的时候，遇到了善良的少女翰翰，从而被收留在地球上。

翰翰的家里有一辆飞行车。

有一天飞行车的电路板突然出现了故障，导致无法启动。

电路板的整体结构是一个 R 行C 列的网格（R,C≤500），如下图所示。

每个格点都是电线的接点，每个格子都包含一个电子元件。

电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。

在旋转之后，它就可以连接另一条对角线的两个接点。

电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。

达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。

她准备通过计算，旋转最少数量的元件，使电源与发动装置通过若干条短缆相连。

不过，电路的规模实在是太大了，达达并不擅长编程，希望你能够帮她解决这个问题。

注意：只能走斜向的线段，水平和竖直线段不能走。

输入格式

输入文件包含多组测试数据。

第一行包含一个整数 T，表示测试数据的数目。

对于每组测试数据，第一行包含正整数 R 和 C，表示电路板的行数和列数。

之后 R 行，每行 C个字符，字符是"/“和”"中的一个，表示标准件的方向。

输出格式

对于每组测试数据，在单独的一行输出一个正整数，表示所需的最小旋转次数。

如果无论怎样都不能使得电源和发动机之间连通，输出 NO SOLUTION。

数据范围

1≤R,C≤500,

1≤T≤5≤

输入样例：

1
3 5
\\/\\
\\///
/\\\\

输出样例：

1

样例解释

样例的输入对应于题目描述中的情况。

只需要按照下面的方式旋转标准件，就可以使得电源和发动机之间连通。

分析：

边权为0或1的最短路问题，使用双端队列的bfs算法。是对bfs算法的一种优化。

暴力bfs做法 :

首先考虑直接使用bfs暴力，与bfs类似，每次取队列内的点进行扩展得到新的点，但是由于边权有0有1，所以第一次扩展得到的点并不一定是最短距离，即使不是第一次扩展遍历的点也要对其更新距离，如果成功更新了距离就要把这个点入队，用于更新其他点的距离。

实现代码：

    #include<bits/stdc++.h>
    using namespace std;
    const int N=505;
    char g[N][N];
    int dist[N][N];
    int r,c,t;
    int dx[4]={-1,-1,1,1},dy[4]={-1,1,1,-1};
    int fx[4]={-1,-1,0,0},fy[4]={-1,0,0,-1};
    string s="\\/\\/";
    int bfs()
    {
        queue<pair<int,int>>q;
        dist[0][0]=0;
        q.push({0,0});
        while(q.size())
        {
            auto t=q.front();
            q.pop();
            //cout<<t.first<<' '<<t.second<<endl;
            for(int i=0;i<4;i++)
            {
                int a=dx[i]+t.first,b=dy[i]+t.second;
                //cout<<"a="<<a<<' '<<"b="<<b<<endl;
                int fa=fx[i]+t.first,fb=fy[i]+t.second;
                if(a<0||a>r||b<0||b>c) continue;//出界
                if(g[fa][fb]==s[i])//可以直接通过
                {
                    //cout<<"yes"<<endl;
                    if(dist[a][b]==-1)//第一次走到这个点
                    {
                        dist[a][b]=dist[t.first][t.second];
                        //cout<<"first go ("<<a<<','<<b<<')'<<endl;
                        q.push({a,b});
                    }
                    else//之前走过这个点，保持之前的距离或者使用当前的距离
                    {
                        int w=dist[a][b];
                        dist[a][b]=min(dist[a][b],dist[t.first][t.second]);
                        if(dist[a][b]!=w)
                        {
                            //cout<<"("<<a<<','<<b<<')'<<endl;
                            q.push({a,b});//被更新了就加入q
                        }
                    }
                }
                else//需要翻转
                {
                    //cout<<"no"<<endl;
                    if(dist[a][b]==-1)//第一次走到这个点
                    {
                        //cout<<"first go ("<<a<<','<<b<<')'<<endl;
                        dist[a][b]=dist[t.first][t.second]+1;
                        q.push({a,b});
                    }
                    else//之前走过这个点，保持之前的距离或者使用当前的距离
                    {
                        int w=dist[a][b];
                        dist[a][b]=min(dist[a][b],dist[t.first][t.second]+1);
                        if(dist[a][b]!=w)
                        {
                            //cout<<"("<<a<<','<<b<<')'<<endl;
                            q.push({a,b});//被更新了就加入q
                        }
                    }
                }
            }
        }
        return dist[r][c];
    }
    int main()
    {
        ios::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        cin>>t;
        while(t--)
        {
            cin>>r>>c;
            for(int i=0;i<r;i++)
            for(int j=0;j<c;j++)
            {
                cin>>g[i][j];
            }
            memset(dist,-1,sizeof dist);
            int t=bfs();
            if(t==-1) cout<<"NO SOLUTION"<<endl;
            else cout<<t<<endl;
        }
    }

这种做法每个点都可能入队很多次，显然会超时。

双端队列bfs做法

每条边的边权为0或1，每次取出队头扩展，扩展出来的边如果权重是0就插入队头，权重是1就插入队尾。由于bfs的特性，队列中的点距离起点距离只有x和x+1两种，并且每次出队的元素一定是距离为x的元素。所以上面的插入元素方法显然可以保证第一次出队的点一定是最短距离。用st数组存已确定最短距离的点，即出过队的点。

• 需要注意有T组数据，每组数据都要先将st数组和dist数组初始化
• 虽然用st数组标记过了已确定最短路径的点，每次扩展时扩展到st标记过的点不用再进行处理，但每次扩展得到的新点即使没有被st数组标记，还是需要判断是否需要入队，否则可能出现某个点出队之前，重复入队此点太多次，导致需要重复出队此元素，时间复杂度太高而超时。

判断每次有点i扩展得到的没有被st数组标记的新点是否需要入队：

• 扩展的边权为0：
• 1. 若这个点距离为-1，即第一次访问，显然需要更新距离为x，将此点加入队头
  2. 若这个点距离为x，即与i的距离相同，显然这个点已经在队列内前半段，但还没有出队。通过i到达此点仍需要x的距离，没必要重复入队此元素，此时无需再入队。
  3. 若这个点距离为x+1，显然这个点已经在队列内后半段但还未出队，通过i到达这个点只需要x的距离，显然比之前入队的距离要短，所以需要更新距离为x并将此点加入队头。
• 扩展的边权为1：
  1. 若若这个点距离为-1，即第一次访问，显然需要更新距离为x+1，将此点加入队头
  2. 若这个点距离为x，即与i的距离相同，显然这个点已经在队列内前半段，但还没有出队。此时无需再入队。
  3. 若这个点距离为x+1，显然这个点已经在队列内后半段但还未出队，通过i到达这个点依然需要x的距离，显然没必要重复入队此元素，所以无需入队。

经过上述处理之后，可以确保每个点最多入队两次，第一次入队尾更新距离为x+1，第二次入队头距离为x。或者只入队一次更新距离为距离为x或x+1。做多计算O(2n)次。

实现代码：

    #include<bits/stdc++.h>
    using namespace std;
    const int N=505;
    char g[N][N];
    bool st[N][N];//判断是否已经确定最短距离
    int dist[N][N];
    int r,c,t;
    int dx[4]={-1,-1,1,1},dy[4]={-1,1,1,-1};
    int fx[4]={-1,-1,0,0},fy[4]={-1,0,0,-1};
    string s="\\/\\/";
    int bfs()
    {
        deque<pair<int,int>>q;
        dist[0][0]=0;
        q.push_back({0,0});
        while(q.size())
        {
            auto t=q.front();
            q.pop_front();
            st[t.first][t.second]=true;//第一次出队一定是最短距离
            for(int i=0;i<4;i++)
            {
                int a=dx[i]+t.first,b=dy[i]+t.second;
                int fa=fx[i]+t.first,fb=fy[i]+t.second;
                if(a<0||a>r||b<0||b>c) continue;//出界
                if(st[a][b]==true) continue;//已确定最短距离的点无需入队
                if(g[fa][fb]==s[i])//可以直接通过
                {
                    if(dist[a][b]!=dist[t.first][t.second])
                    {
                        dist[a][b]=dist[t.first][t.second];
                        q.push_front({a,b});
                    }
                }
                else//需要翻转
                {
                    if(dist[a][b]==-1)
                    {
                        dist[a][b]=dist[t.first][t.second]+1;//第一次到
                        q.push_back({a,b});
                    }
                }
            }
        }
        return dist[r][c];
    }
    int main()
    {
        ios::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        cin>>t;
        while(t--)
        {
            cin>>r>>c;
            for(int i=0;i<r;i++)
            for(int j=0;j<c;j++)
            {
                cin>>g[i][j];
            }
            memset(st,0,sizeof st);
            memset(dist,-1,sizeof dist);
            int t=bfs();
            if(t==-1) cout<<"NO SOLUTION"<<endl;
            else cout<<t<<endl;
        }
        
    }