所有可能的路径---对何时使用bfs+状态压缩的稍微总结

题目

dfs回溯

没啥可说的，究极简单+标准

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> stk;

    void dfs(vector<vector<int>>& graph, int x, int n) {
        if (x == n) {
            ans.push_back(stk);
            return;
        }
        for (auto& y : graph[x]) {
            stk.push_back(y);
            dfs(graph, y, n);
            stk.pop_back();
        }
    }

    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        stk.push_back(0);
        dfs(graph, 0, graph.size() - 1);
        return ans;
    }
};

关于我为什么是伞兵这件事(何时使用bfs+状压)

总结就是 数组状压+bfs 只适用于图类型的最短距离。而且一般适用于多源bfs求最短路，或者是用于利用这个状压数组求出答案所在地的具体路径，而不是直接用 vector 的记录方式。

我是伞兵。。明明就很简单的的回溯思路求出所有路径。。我还以为会形成环。。还把它当多源来做了。。最重要的是我竟还以为我自己的写法很高明。。(想了贼久)强行用bfs+状态压缩写了出来。。。 > 但此方法也不是全然毫无用处—可用于有关最短路径问题中加了很多个限制条件的题目，比如限制为走完所有结点的最短路径。又比如计算图中走到某点最短距离的具体经过的路线。这种方法一般就是图的最短路径改编题。

struct node{
    int lable;
    int path;
};

class Solution {
public:
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        int n = graph.size();
        const int INF = 1<<n;
        queue<node>Q;
//用memo记录下到达n结点处经过的路径的上一个结点。不仅满足了path防止回头还记录了path的解析方式
        int memo[n][INF];
        memset(memo,0xff,sizeof(memo));
        Q.push({0,1<<0});
        auto func = [&](vector<vector<int>>&res,int path){
            vector<int>t;
            t.emplace_back(n-1);
            int new_path = path;
            for(int i=memo[n-1][path],j=n-1;i!=-1;i=memo[i][new_path]){
                t.emplace_back(i);
                new_path ^=(1<<j);
                j=i;
            }
            reverse(t.begin(),t.end());
            res.emplace_back(t);
        };
   
        vector<vector<int>>res;
        while(!Q.empty()){
            auto new_node = move(Q.front());Q.pop();
            if(new_node.lable==n-1) func(res,new_node.path);
            
            for(auto&& t:graph[new_node.lable]){
                int n_path = new_node.path | 1<<t;
                
                if(memo[t][n_path]!=new_node.lable){
                    memo[t][n_path] = new_node.lable;
                    Q.push({t,n_path});
                }
            }
        }
        return res;
    }
};