GATE-CS-2004 - 第48章

简介

本章主要涉及以下几个方面：

• 动态规划
• 分支限界
• 贪心算法
• 图算法

动态规划

动态规划是一种以空间换时间的算法，通常用于求解最优化问题。动态规划算法的核心是找到状态转移方程，建立状态转移表来存储中间状态，最终得到最优解。

下面是一个经典的动态规划问题“背包问题”的解法代码，其中N表示物品数量，W表示背包容量，w和v分别表示物品的重量和价值。

def knapsack(N, W, w, v):
    # 初始化状态转移表
    dp = [[0] * (W + 1) for _ in range(N + 1)]

    # 计算最大价值
    for i in range(1, N + 1):
        for j in range(1, W + 1):
            if j >= w[i - 1]:
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1])
            else:
                dp[i][j] = dp[i - 1][j]

    # 返回最大价值
    return dp[N][W]

分支限界

分支限界算法是一种用于求解最优化问题的算法，它通过枚举可能的解，并通过剪枝来减少搜索空间，最终得到最优解。

下面是一个经典的0/1背包问题的分支限界算法的代码，其中N表示物品数量，W表示背包容量，w和v分别表示物品的重量和价值。

class Node:
    def __init__(self, level, profit, weight):
        self.level = level
        self.profit = profit
        self.weight = weight

    def __lt__(self, other):
        return self.profit / self.weight > other.profit / other.weight

def knapsack(N, W, w, v):
    # 计算物品单位价值
    nodes = [Node(i, v[i] / w[i], w[i]) for i in range(N)]
    nodes.sort()

    # 初始化状态
    best_profit = 0
    queue = [Node(-1, 0, 0)]

    # 进行搜索
    while queue:
        node = queue.pop(0)

        if node.level == N - 1:
            continue

        # 选中当前物品
        if node.weight + nodes[node.level + 1].weight <= W:
            new_node = Node(node.level + 1, node.profit + v[node.level + 1], node.weight + w[node.level + 1])
            if new_node.profit > best_profit:
                best_profit = new_node.profit
            queue.append(new_node)

        # 不选当前物品
        new_node = Node(node.level + 1, node.profit, node.weight)
        bound = node.profit + (W - node.weight) * nodes[node.level + 1].profit
        if bound > best_profit:
            queue.append(new_node)

    # 返回最大价值
    return best_profit

贪心算法

贪心算法是一种通过选择当前最优解来得到整体最优解的算法。贪心算法的优点是简单快速，但其缺点是不能保证得到最优解。

下面是一个经典的区间调度问题的贪心算法的代码，其中n表示区间数量，interval是区间的起始和终止时间的列表。

def interval_scheduling(n, interval):
    # 按照区间结束时间排序
    interval.sort(key=lambda x: x[1])

    # 依次选择不相交区间
    selected = [interval[0]]
    for i in range(1, n):
        if interval[i][0] >= selected[-1][1]:
            selected.append(interval[i])

    # 返回最终选择的区间数量
    return len(selected)

图算法

图算法是一种用于求解图相关问题的算法，包括最短路径、最小生成树、最大流等问题。

下面是一个经典的最短路径问题的Dijkstra算法的代码，其中n表示节点数量，adj是邻接矩阵，s表示源节点。

import heapq

def dijkstra(n, adj, s):
    # 初始化距离向量和标记向量
    dis = [float('inf')] * n
    vis = [False] * n
    dis[s] = 0

    # 使用堆优化的Dijstra算法
    heap = [(0, s)]
    while heap:
        d, u = heapq.heappop(heap)
        if vis[u]:
            continue
        vis[u] = True
        for v in range(n):
            if not vis[v] and dis[u] + adj[u][v] < dis[v]:
                dis[v] = dis[u] + adj[u][v]
                heapq.heappush(heap, (dis[v], v))

    # 返回最短距离向量
    return dis

总结

本章介绍了动态规划、分支限界、贪心算法和图算法等常见算法，并给出了每个算法的经典应用问题的代码实现。程序员可以根据算法的特点和自己的需求来选择合适的算法，并参考代码来实现自己的算法。