门 | GATE CS 2018 |简体中文第58章

本篇笔记是根据GATE CS 2018考试中的第58章整理而来，主要涵盖了以下知识点：

• 递归和非递归深度优先搜索
• 拓扑排序
• 最短路径算法：Dijkstra和Floyd-Warshall算法
• 动态规划

深度优先搜索

深度优先搜索是一种基于栈的搜索算法，它的核心思想是遍历图的所有节点，并且只要找到一个未访问的节点就继续深入探索，直到该节点没有未访问的子节点，然后回溯到之前的节点继续搜索。

递归深度优先搜索

递归深度优先搜索是深度优先搜索的一种实现方式，它适用于图的规模较小的情况。

def DFS_recursive(graph, visited, v):
    visited[v] = True
    print(v, end=' ')
    for i in graph[v]:
        if not visited[i]:
            DFS_recursive(graph, visited, i)

非递归深度优先搜索

非递归深度优先搜索是深度优先搜索的另一种实现方式，它使用了栈来记录每个节点的状态，遍历过的节点会被标记为已访问。

def DFS_iterative(graph, visited, v):
    stack = []
    stack.append(v)
    while stack:
        v = stack.pop()
        if not visited[v]:
            visited[v] = True
            print(v, end=' ')
        for i in graph[v]:
            if not visited[i]:
                stack.append(i)

拓扑排序

拓扑排序是一种基于有向图的算法，它能够将有向图中的所有节点按照一定的拓扑序列进行排序，满足若存在一条从节点x到节点y的路径，则在排序后x一定排在y的前面。

拓扑排序实现

拓扑排序的实现通常使用BFS（广度优先搜索）来实现，它需要使用一个队列来记录每个节点的入度，并将入度为0的节点加入队列中，随后在遍历过程中将所有邻接的节点减少1，然后将入度为0的节点加入队列中。

def topological_sort(graph, indegree):
    queue = []
    for i in range(len(indegree)):
        if indegree[i] == 0:
            queue.append(i)
    while queue:
        v = queue.pop(0)
        print(v, end=' ')
        for w in graph[v]:
            indegree[w] -= 1
            if indegree[w] == 0:
                queue.append(w)

最短路径算法

最短路径算法是一种计算图中最短路径的算法，它可以计算任意两个节点之间的最短路径。

Dijkstra算法

Dijkstra算法是一种基于贪心的算法，它使用了一个数组来记录每个节点的距离，最初的距离都为无穷大，随后从起点开始，将起点的距离设为0，然后遍历所有邻近的节点，并计算新节点的距离，如果该节点的距离小于已知的距离，则更新距离并将该节点加入最短路径中。

def dijkstra(graph, start):
    dist = [float('inf')] * len(graph)
    visited = [False] * len(graph)
    dist[start] = 0
    for i in range(len(graph)):
        u = find_min_distance(dist, visited)
        visited[u] = True
        for v in range(len(graph)):
            if graph[u][v] > 0 and not visited[v] and dist[u] + graph[u][v] < dist[v]:
                dist[v] = dist[u] + graph[u][v]
    return dist

def find_min_distance(dist, visited):
    min_distance = float('inf')
    min_node = -1
    for i in range(len(dist)):
        if dist[i] < min_distance and not visited[i]:
            min_distance = dist[i]
            min_node = i
    return min_node

Floyd-Warshall算法

Floyd-Warshall算法是一种动态规划算法，它能够计算图中任意两个节点之间的最短路径。

它的思路是从i到j的最短路径要么就是i到j直接相连的路径，要么就是i通过某些中间节点k到j的路径，因此我们可以定义一个中间节点为k，然后通过动态规划的方式计算出i到k和k到j的最短路径，然后将它们相加即可得到i到j的最短路径。

def floyd_warshall(graph):
    dist = []
    for i in range(len(graph)):
        dist.append(graph[i].copy())
    for k in range(len(graph)):
        for i in range(len(graph)):
            for j in range(len(graph)):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
    return dist

动态规划

动态规划是一种简单而强大的算法，它可以解决一些优化问题，如最短路径问题等。

动态规划的核心思想是将问题划分为子问题，并保存已经解决的子问题的结果，在计算新问题时可以直接使用已经解决的子问题的结果，从而大大减少计算量。

最大子序列和问题

最大子序列和问题是动态规划中的一个经典问题，它的目标是在给定整数序列中找到连续子序列，使得该子序列内所有数字的和最大。

def max_subarray(arr):
    curr_max = max_so_far = arr[0]
    for i in range(1,len(arr)):
        curr_max = max(arr[i], curr_max + arr[i])
        max_so_far = max(max_so_far, curr_max)
    return max_so_far

以上就是对GATE CS 2018考试第58章的介绍，本篇笔记覆盖了深度优先搜索，拓扑排序，最短路径算法和动态规划等几个重要的知识点，相信能够为各位读者提供一些帮助。