B F S 及其扩展

bfs的特点是逐层扩展，从源头到目标点扩展了几层，最短的路径就是多少

bfs使用的特征是 任意两个节点之间的相互距离是相同的(无向图)

bfs开始时，可以是单个源头，也可以是多个源头

bfs和队列结合使用，可以是单点弹出队列，也可以是整层弹出

bfs进行时，需要将进入的节点标记状态，防止同一个节点重复进出队列

bfs进行时，可能会有剪枝策略

模板

class Solution {
public:
    static const int maxnum = 101;
    int queue[maxnum * maxnum][2];
    bool visit[maxnum][maxnum];
    int move[5] = {-1, 0, 1, 0, -1};//常用的移动方向的技巧
    int maxDistance(vector<vector<int>>& grid) {
        int n = grid.size();
        int seas = 0;
        int m = grid[0].size();
        int l = 0, r = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    visit[i][j] = true;//陆地标为true
                    queue[r][0] = i;
                    queue[r++][1] = j;
                } else {
                    visit[i][j] = false;
                    seas++;
                }
            }
        }
        if (seas == 0 || seas == n * n)
            return -1;
        int level = 0;
        while (l < r) {
            level++;
            int size = r - l;//逐层展开
            for (int i = 0; i < size; i++) {
                int x = queue[l][0];
                int y = queue[l++][1];
                for (int j = 0; j < 4; j++) {
                    int nx = x + move[j];
                    int ny = y + move[j + 1];
                    if (nx >= 0 && nx < n && ny >= 0 && ny < n &&
                        visit[nx][ny] == false) {
                        visit[nx][ny] = true;
                        queue[r][0] = nx;
                        queue[r++][1] = ny;
                    }
                }
            }
        }
        return level - 1;
    }
};

 时间复杂度为O(m*n)

贴纸拼词

class Solution {
public:
    static const int maxnum = 401;
    vector<vector<string>> pragh;
    void build() {//将包含某字母的字符串放在一起
        for (int i = 0; i < 26; i++)
            pragh.push_back(vector<string>());
    }
    void getnewstring(string& s) {//将字符串按字典序排序
        int n = s.size();
        vector<char> rem(n, 'a');
        for (int i = 0; i < n; i++) {
            rem[i] = s[i];
        }
        sort(rem.begin(), rem.end());
        for (int i = 0; i < n; i++)
            s[i] = rem[i];
    }
    string nextstring(string s, string us) {//删除后的字符串
        string ans;
        int i = 0, j = 0;
        for (i = 0, j = 0; i < s.size() && j < us.size();) {
            if (s[i] == us[j]) {
                i++;
                j++;
            } else if (s[i] < us[j]) {
                ans += s[i];
                i++;
            } else
                j++;
        }
        while (i < s.size()) {
            ans += s[i++];
        }
        return ans;
    }
    int minStickers(vector<string>& stickers, string target) {
        build();
        getnewstring(target);
        for (int i = 0; i < stickers.size(); i++) {
            getnewstring(stickers[i]);
            for (int j = 0; j < stickers[i].size(); j++) {
                if (j == 0 || stickers[i][j] != stickers[i][j - 1])
                    pragh[stickers[i][j] - 'a'].push_back(stickers[i]);
            }
        }
        string queue[maxnum];
        int l = 0, r = 0;
        unordered_set<string> visit;
        queue[r++] = target;
        int level = 1;
        while (l < r) {
            int size = r - l;
            for (int i = 0; i < size; i++) {
                string cur = queue[l++];
                for (auto j : pragh[cur[0] - 'a']) {
                    string next = nextstring(cur, j);//下一个字符串
                    if (next.size() == 0)
                        return level;
                    else {
                        if (visit.find(next) == visit.end()) {
                            visit.insert(next);//记录，防止重复记录
                            queue[r++] = next;
                        }
                    }
                }
            }
            level++;
        }
        return -1;
    }
};

一个字符串cur如果被stickers里面的字符串贴完后，得到下一级字符串，这就和bfs一层一层遍历一样，最后第一次被贴完就是用的最少贴纸。这题优化点在于可以进行剪枝，我们先把target字符串按字典序排序，按照字符串首字母进行删除，不要开始将target用stickers里的字符串全部贴一遍，因为不管怎么贴，target里的每种字符最后都会被贴完，所以用含字符串首字母的stickers里的字符串贴，可以减少路径

0-1bfs ，适用于图中所有边的权重只有0和1两种值，求从原点到目标点最短的路径

时间复杂度为O(节点的数量+边的数量)。此类问题不可以用传统的bfs解决

过程：

1.distance[i]表示从源点到i点的最短距离，初始时所有的点的距离设置为无穷大

2.源点进入双端队列，distance[源点]设置初始值；

3.双端队列头部弹出x：

  1)如果x是目标节点，返回distance[x]

  2)考察从x出发的每一条边，假设某边去y点，边权为w

     如果w==0，y从头部进入双端队列，重复步骤3

     如果w==1，y从尾部进入双端队列，重复步骤3

4.直至双端队列为空为止

 

  此时distance数组就代替的visited数组的作用 

 到角落需要移除的最少障碍物

class Solution {
public:
    int move[5] = {-1, 0, 1, 0, -1};
    static const int maxnum = 100001;
    int minimumObstacles(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int distance[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                distance[i][j] = INT_MAX;
            }
        }
        vector<vector<int>> deque(maxnum * 2, vector<int>());
        int l = maxnum, r = maxnum;
        deque[r++] = {0, 0};
        distance[0][0] = 0;
        while (l < r) {
            int x = deque[l][0];
            int y = deque[l++][1];
            if (x == m - 1 && y == n - 1)
                return distance[x][y];
            for (int i = 0; i < 4; i++) {
                int nx = move[i] + x;
                int ny = move[i + 1] + y;
                if (nx >= 0 && nx < m && ny >= 0 && ny < n &&
                    distance[nx][ny] >
                        (long long)grid[nx][ny] + distance[x][y]) {
                    distance[nx][ny] = grid[nx][ny] + distance[x][y];
                    if (grid[nx][ny] == 0)
                        deque[--l] = {nx, ny};
                    else
                        deque[r++] = {nx, ny};
                }
            }
        }
        return -1;
    }
};

使网格连通的最少修改次数

class Solution {
public:
    int minCost(vector<vector<int>>& grid) {
        vector<vector<int>> move = {{0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        int m = grid.size();
        int n = grid[0].size();
        deque<vector<int>> de;
        int distance[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                distance[i][j] = INT_MAX;
            }
        }
        de.push_back({0, 0});
        distance[0][0] = 0;
        while (!de.empty()) {
            vector<int> rem = de.front();
            de.pop_front();
            int x = rem[0];
            int y = rem[1];
            if (x == m - 1 && y == n - 1)
                return distance[x][y];
            for (int i = 1; i <= 4; i++) {
                int nx = x + move[i][0];
                int ny = y + move[i][1];
                int weight = grid[x][y] != i ? 1 : 0;
                if (nx >= 0 && nx < m && ny >= 0 && ny < n &&
                    distance[x][y] + weight < distance[nx][ny]) {
                    distance[nx][ny] = distance[x][y] + weight;
                    if (weight == 0)
                        de.push_front({nx, ny});
                    else
                        de.push_back({nx, ny});
                }
            }
        }
        return -1;
    }
};

和"打通障碍"的过程基本一致，唯一的区别是打通障碍中每个点的权值是"静态的"，它只跟初始的设置有关；而此题中每个点的权值跟到这个点之前的点的方向有关

接雨水ll

bfs可以和堆结构结合使用

class Solution {
public:
    int move[5]={-1,0,1,0,-1};
    int trapRainWater(vector<vector<int>>& heightMap) {
        int n=heightMap.size();
        int m=heightMap[0].size();
        auto cmp=[](vector<int>a,vector<int>b){return a[2]>b[2];};
        priority_queue<vector<int>,vector<vector<int>>,decltype(cmp)>re(cmp);
        bool visit[n][m];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(i==0||i==n-1||j==0||j==m-1){
                    re.push({i,j,heightMap[i][j]});
                    visit[i][j]=true;
                }
                else visit[i][j]=false;
            }
        }
        int ans=0;
        while(!re.empty()){
            vector<int>rem=re.top();
            re.pop();
            int x=rem[0];
            int y=rem[1];
            int level=rem[2];
            ans+=level-heightMap[x][y];
            for(int i=0;i<4;i++){
                int nx=x+move[i];
                int ny=y+move[i+1];
                if(nx>=0&&nx<n&&ny>=0&&ny<m&&!visit[nx][ny]){
                    re.push({nx,ny,max(heightMap[nx][ny],level)});
                    visit[nx][ny]=true;
                }
            }

        }
        return ans;


    }
};

 首先最外围的点是不会积水的，他们的水线就是他们的高度(只不过水流走了而已)，而外围水线越低，内部的水越容易流走，所以从水线较低的地方开始，逐层的向内求出个点的水线，累加水量即可

单词接龙

class Solution {
public:
    unordered_set<string> next;
    unordered_set<string> cur;
    unordered_map<string, vector<string>> pragh;
    vector<string> path;
    vector<vector<string>> ans;
    unordered_set<string> dic;
    void build(vector<string>& wordList) {
        next.clear();
        cur.clear();
        pragh.clear();
        path.clear();
        ans.clear();
        dic = unordered_set<string>(wordList.begin(), wordList.end());
    }
    bool bfs(string beginWord, string endWord) {
        bool findone = false;
        cur.insert(beginWord);
        while (!cur.empty()) {
            for (auto i : cur)//删掉遍历过的string
                dic.erase(i);
            for (auto str : cur) {//不停的去找下一层string
                for (int i = 0; i < str.size(); i++) {
                    char a = str[i];
                    string s = str;
                    for (char ch = 'a'; ch <= 'z'; ch++) {
                        s[i] = ch;
                        if (dic.find(s) != dic.end() && s != str) {
                            if (s == endWord)
                            findone = true;//当找到target时就找到了最短路径
                            pragh[s].push_back(str);
                            next.insert(s);
                        }
                    }
                }
            }
            if (findone)
                return true;
            else {
                cur = next;
                next.clear();
            }
        }
        return false;
    }
    void dfs(string endWord, string beginWord) {
        path.insert(path.begin(), endWord);//首插
        if (endWord == beginWord)
            ans.push_back(path);
        else if (pragh.find(endWord) != pragh.end()) {
            for (auto str : pragh[endWord])
                dfs(str, beginWord);
        }
        path.erase(path.begin());//首删
    }
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        build(wordList);
        if (dic.find(endWord) == dic.end())
            return ans;
        if (bfs(beginWord, endWord)) {
            dfs(endWord, beginWord);
        }
        return ans;
    }
};

bfs还可以和dfs结合使用，想要找source到target的最短路径，首先用bfs建立target到source的反图，图上source和target的路径是最短的；然后从target向source dfs得到的路径就是最短路径