【搜索】双端队列广搜

双端队列广搜

---

算法概述： 双端队列广搜是特殊的 dijkstra 算法，用来解决图中边的权值只有0或者1的最短路问题。算法复杂度是线性的。

具体操作见链接。

注意： 当一个点出队列的时候才意味着更新到了最短距离（和dij算法一样）。因此当一个点被其他点更新时，有可能不是最短距离。

讲解链接：AcWing 175. 电路维修

模板： 双端队列求最短路模板

---

175. 电路维修

题解：AcWing 175. 电路维修

AC代码：

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const int N = 510;

char str[N][N];
int n, m;
bool vis[N][N];
int dis[N][N];

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        cin >> n >> m;
        for(int i=0; i<n; i++) cin >> str[i];
        for(int i=0; i<=n; i++)
            for(int j=0; j<=m; j++) vis[i][j] = 0, dis[i][j] = 2e9;

        if(n + m & 1) { cout << "NO SOLUTION\n"; continue; }

        deque<pair<int, int> > deq;
        deq.push_back({0, 0});
        dis[0][0] = 0;

        while(!deq.empty())
        {
            auto t = deq.front(); deq.pop_front();
            int x = t.first, y = t.second;
            if(vis[x][y]) continue;
            vis[x][y] = 1; // 出队后才是最短距离

            for(int i=x - 1; i<=x; i++)
                for(int j = y - 1; j<=y; j++)
                {
                    int xx = x - 1 + 2 * (i - x + 1), yy = y - 1 + 2 * (j - y + 1);
                    if(i < 0 || i >= n || j < 0 || j >= m || vis[xx][yy]) continue;
                    int & d = dis[xx][yy];

                    if(i - x + 1 + j - y + 1 & 1){
                        if(str[i][j] == '\\'){
                            d = min(d, dis[x][y] + 1); 
                            deq.push_back({xx, yy});
                        }
                        else{
                            d = min(d, dis[x][y]); 
                            deq.push_front({xx, yy});
                        }
                    }else{
                        if(str[i][j] == '\\'){
                            d = min(d, dis[x][y]);
                            deq.push_front({xx, yy});
                        }
                        else{
                            d = min(d, dis[x][y] + 1);
                            deq.push_back({xx, yy});
                        }
                    }
                }
        }

        cout << dis[n][m] << endl;
    }
    

    system("pause");
    return 0;
}

关于这个代码的一些疑惑：

1 . 为什么 vis[] 数组不能合并到 dis[] 数组呢？

• 双端队列广搜是特殊的 dijkstra 算法。与堆优化dijkstra 一样，必须在出队时才知道每个点最终的最小值，不能合并。而一般的BFS是只要访问到就是最短距离，因此两数组可以合并，详见题解。
• 因此双端队列广搜写法也必须仿照 dijkstra 算法来写。