代码随想录day14--图论

最新推荐文章于 2024-10-31 23:58:13 发布

梦里背包去旅行

最新推荐文章于 2024-10-31 23:58:13 发布

阅读量95

点赞数

文章标签：图论深度优先算法

两者大概的区别：

dfs是可一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯）。

bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。

就地递归函数的下面，例如如下代码：

void dfs(参数) {
    处理节点
    dfs(图，选择的节点); // 递归
    回溯，撤销处理结果
}

回溯算法，其实就是dfs的过程，这里给出dfs的代码框架：

void dfs(参数) {

    if (终止条件) {

        存放结果;

        return;

    }


    for (选择：本节点所连接的其他节点) {

        处理节点;

        dfs(图，选择的节点); // 递归

        回溯，撤销处理结果

    }

}

代码随想录day14--图论_回溯算法

代码随想录day14--图论_搜索_02

代码随想录day14--图论_搜索_03

代码随想录day14--图论_搜索_04

797.所有可能的路径

深搜三部曲来分析题目：

1；确认递归函数，参数

首先我们dfs函数一定要存一个图，用来遍历的，还要存一个目前我们遍历的节点，定义为x

至于单一路径，和路径集合可以放在全局变量，那么代码是这样的：

vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 0节点到终点的路径
// x：目前遍历的节点
// graph：存当前的图
void dfs (vector<vector<int>>& graph, int x)

2；确认终止条件

什么时候我们就找到一条路径了？

当目前遍历的节点为最后一个节点的时候，就找到了一条，从出发点到终止点的路径。

当前遍历的节点，我们定义为x，最后一点节点，就是 graph.size() - 1（因为题目描述是找出所有从节点 0 到节点 n-1 的路径并输出）。

所以但 x 等于 graph.size() - 1 的时候就找到一条有效路径。代码如下：

// 要求从节点 0 到节点 n-1 的路径并输出，所以是 graph.size() - 1
if (x == graph.size() - 1) { // 找到符合条件的一条路径
    result.push_back(path); // 收集有效路径
    return;
}

3；处理目前搜索节点出发的路径

接下来是走当前遍历节点x的下一个节点。

首先是要找到 x节点链接了哪些节点呢？遍历方式是这样的：

接下来就是将选中的x所连接的节点，加入到单一路径来。

二维数组中，graph[x][i] 都是x链接的节点，当前遍历的节点就是 graph[x][i] 。

进入下一层递归

回溯法 (opens new window)的代码框架

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

回溯算法，其实就是dfs的过程，这里给出dfs的代码框架：

void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本节点所连接的其他节点) {
        处理节点;
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}

#邻接矩阵的写法  二维矩阵
def dfs(graph, x, n, path, result):
    if x == n:
        result.append(path.copy())  # 节点i添加到当前路径path ，path.copy() 是因为路径列表 path 在后续的递归中会被修改。
        return
    for i in range(1, n + 1):
        if graph[x][i] == 1:
            path.append(i)
            dfs(graph, i, n, path, result)
            path.pop() #节点i从当前路径移除
            
def main():
    n, m = map(int, input().split())  # input 读取一行输入，用空格分隔，split空格分成列表 map 字符串转换为整数
                                      #返回一个迭代器  （5，10）
    graph = [[0] * (n + 1) for _ in range(n + 1)]
    #[0] * (n + 1) 表达式会生成一个包含 n + 1 个 0 的列表。例如，如果 n 是 5，则 [0] * (6) 生成 [0, 0, 0, 0, 0, 0]
#这个循环部分生成 n + 1 个这样的列表。循环变量 _ 是一个占位符，因为在这种情况下它的值并不重要。
#实际上，循环会执行 n + 1 次，每次生成一个 [0] * (n + 1) 的列表
#range(n + 1) 生成 range(4)，即 0, 1, 2, 3
#[[0] * (n + 1) for _ in range(n + 1)] 生成一个 4 x 4 的矩阵

'''
[
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
]

'''


    
    for _ in range(m):
        s, t = map(int, input().split())
        graph[s][t] = 1

    result = []
    dfs(graph, 1, n, [1], result)

    if not result:
        print(-1)
    else:
        for path in result:
            print(' '.join(map(str, path)))

if __name__ == "__main__":
    main()

#邻接表的写法
from collections import defaultdict

result = []  # 收集符合条件的路径
path = []  # 1节点到终点的路径

def dfs(graph, x, n):
    if x == n:  # 找到符合条件的一条路径
        result.append(path.copy())
        return
    for i in graph[x]:  # 找到 x指向的节点
        path.append(i)  # 遍历到的节点加入到路径中来
        dfs(graph, i, n)  # 进入下一层递归
        path.pop()  # 回溯，撤销本节点

def main():
    n, m = map(int, input().split())

    graph = defaultdict(list)  # 邻接表
    for _ in range(m):
        s, t = map(int, input().split())
        graph[s].append(t)

    path.append(1)  # 无论什么路径已经是从1节点出发
    dfs(graph, 1, n)  # 开始遍历

    # 输出结果
    if not result:
        print(-1)
    for pa in result:
        print(' '.join(map(str, pa)))

if __name__ == "__main__":
    main()