门| GATE CS Mock 2018年|套装2 |第55章

概览

GATE (Graduate Aptitude Test in Engineering) 是印度国家水平的入学考试，用来进行研究生课程申请。该测试涵盖了计算机科学和其他工程领域的各种主题和子主题。本文将介绍GATE CS Mock 2018年的第55章，主要涉及如下五个主题：

1. 哈密尔顿回路
2. 贪婪算法
3. 动态规划
4. 堆
5. 排序算法

哈密尔顿回路

哈密顿回路是一个从图中的任何顶点出发遍历所有顶点恰好一次，然后回到出发顶点的回路。哈密顿回路是NP完全问题，因此我们需要使用基于搜索的方法，如回溯法。参考资料：哈密尔顿回路

def hamilton(graph, path, current_vertex, remaining_vertices):
    if current_vertex is not None:
        path.append(current_vertex)
        remaining_vertices.remove(current_vertex)
        if not remaining_vertices:
            return path
    for vertex in remaining_vertices:
        if vertex in graph[current_vertex]:
            sub_path = hamilton(graph, path[:], vertex, remaining_vertices.copy())
            if sub_path:
                return sub_path
    return None

贪婪算法

贪婪算法是一种优化问题的算法，它寻求在每个步骤中选择可用的最佳选项，以使得最终结果最优。贪婪算法不一定总是能够找到确切的最优解，但在某些情况下，它可以给出很好的近似解。参考资料：贪心法

def fractional_knapsack(weights, values, capacity):
    items = list(zip(weights, values))
    items.sort(key=lambda x: x[1]/x[0], reverse=True)
    total_value = 0
    for weight, value in items:
        if capacity == 0:
            break
        fraction = min(1, capacity/weight)
        total_value += fraction*value
        capacity -= fraction*weight
    return total_value

动态规划

动态规划是一种解决最优化问题的算法，通过将问题分解为多个子问题并使用递归来解决。为了避免重复计算，动态规划会存储已经计算过的中间结果，并在需要时使用这些中间结果。参考资料：动态规划

def rod_cutting(lengths, prices, rod_length):
    dp = [0]*(rod_length+1)
    for i in range(1, rod_length+1):
        for j in range(len(lengths)):
            if lengths[j] <= i:
                dp[i] = max(dp[i], prices[j]+dp[i-lengths[j]])
    return dp[rod_length]

堆

堆是一种特殊的数据结构，其支持在 $O(\log n)$ 时间内执行插入和删除操作，并支持在 $O(1)$ 时间内查询堆顶元素。堆被广泛应用在各种算法中，如优先队列。参考资料：堆

import heapq

heap = []

heapq.heappush(heap, 10)
heapq.heappush(heap, 5)
heapq.heappush(heap, 15)
heapq.heappush(heap, 20)

print(heap)

max_item = heapq.heappop(heap)

print(max_item)
print(heap)

排序算法

排序算法是一种将元素按照一定顺序排列的算法。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。这些算法的复杂度各不相同，在不同的应用场景下可能会有不同的选择。参考资料：排序算法

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr)//2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)