回溯法python（迷宫模板）和01背包问题

1.题目： 一个 N × M的二维数组 maze 表示一个迷宫，其中的1表示墙壁，0表示可以走，只能横着走或竖着走，不能斜着走，找出从左上角到右下角的最短路线。入口点为[0,0]，既第一空格是可以走的。

回溯法：

# 走迷宫
def move(i, j):
    global path
    
    # 当前点变为1，表示已经走过，避免循环绕圈走不出去
    maze[i][j] = 1
    temp_path.append((i, j))
    # 如果已经走到了出口，即右下角，判断是不是最短路径
    if i == N - 1 and j == M - 1:
        if len(path) == 0 or len(temp_path) < len(path):
            path = []
            path.extend(temp_path)
	# 向下走
    if 0 <= i + 1 < N and not maze[i + 1][j]:
        move(i + 1, j)
    # 向右走
    if 0 <= j + 1 < M and not maze[i][j + 1]:
        move(i, j + 1)
    # 向上走
    if 0 <= i - 1 < N and not maze[i - 1][j]:
        move(i - 1, j)
    # 向左走
    if 0 <= j - 1 < M and not maze[i][j - 1]:
        move(i, j - 1)

	# 如果上下左右都走不通或者已经走到出口了，退回上一步，恢复现场
    temp_path.pop()
    maze[i][j] = 0


while True:
    try:
	    # 输入迷宫大小
        N, M = map(int, input().split())
        maze = []
        path = []
        temp_path = []
        # 输入迷宫地图
        for _ in range(N):
            maze.append(list(map(int, input().split())))

		# 走迷宫
        move(0, 0)

		# 打印路径
        for p in path:
            print('(' + str(p[0]) + ',' + str(p[1]) + ')')

    except:
        break

2.01背包问题代码

def knapsack(p, w, v):
    n = len(p)
    lists,arr = [],[[0] * (v + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(1, v + 1):
            if w[i - 1] <= j:  # 如果当前物品的体积不超过背包的容量，p[i-1]当前物品的价值，w[i-1]当前物品的体积
                arr[i][j] = max(arr[i - 1][j], p[i - 1] + arr[i - 1][j - w[i - 1]])
            else: #如果当前物品的体积超过背包的容量
                arr[i][j] = arr[i - 1][j]
            print(arr[i][j])
    remain = v

    for i in range(n, 0, -1):
        if arr[i][remain] > arr[i - 1][remain]:
            lists.append(i - 1)  # (i-1)为当前物品的编号
            remain -= w[i - 1]  # 容积减去已经找到的物品，再次寻找

    return arr[-1][-1], lists


if __name__ == '__main__':
    p = [700 ,500, 800 ,600 ,520]  # 物品的价值
    w = [3, 2, 9, 4, 3] # 物品占的体积
    v = 8  # 背包的容量
    print(knapsack(p, w, v))

3.快速排序

def partition(arr, low, high):
    i = (low - 1)  # 最小元素索引
    pivot = arr[high]

    for j in range(low, high):

        # 当前元素小于或等于 pivot
        if arr[j] <= pivot:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]

    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return (i + 1)

# 快速排序函数
def quickSort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)

        quickSort(arr, low, pi - 1)
        quickSort(arr, pi + 1, high)



if __name__ == '__main__':
    arr = [10, 7, 8, 9, 1, 5]
    n = len(arr)
    quickSort(arr, 0, n - 1)
    print("排序后的数组:")
    for i in range(n):
        print("%d" % arr[i])

4.并归排序

# 归并排序

    def merge_sort(ary):
        
        if len(ary) <= 1:
            return ary
        
        median = int(len(ary)/2)    # 二分分解
        left = merge_sort(ary[:median])
        right = merge_sort(ary[median:])
        return merge(left, right)    # 合并数组
    
    def merge(left, right):
     '''合并操作，
    将两个有序数组left[]和right[]合并成一个大的有序数组'''
        res = []
        i = j = k = 0
        while(i < len(left) and j < len(right)):
            if left[i] < right[j]:
                res.append(left[i])
                i += 1
            else:
                res.append(right[j])
                j += 1
                
        res = res + left[i:] + right[j:]
        return res