常用的五大算法代码示例

# 分治法：
# 分治法将问题分解成更小的子问题，并递归地解决它们，最后合并子问题的解得到最终解。
def divide_and_conquer(arr):
    # 基本情况：如果数组为空或只有一个元素，则直接返回
    if len(arr) <= 1:
        return arr

    # 将数组分成两部分
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    # 递归地对左右子数组进行排序
    left = divide_and_conquer(left)
    right = divide_and_conquer(right)

    # 合并左右子数组并返回结果
    return merge(left, right)

def merge(left, right):
    result = []
    i, j = 0, 0

    # 合并两个有序数组
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

# 示例
arr = [38, 27, 43, 3, 9, 82, 10]
sorted_arr = divide_and_conquer(arr)
print(sorted_arr)  # 输出 [3, 9, 10, 27, 38, 43, 82]


# 动态规划：
# 动态规划通过将问题分解成重叠子问题，并通过保存子问题的解来避免重复计算。
def dynamic_programming(n):
    dp = [0] * (n + 1)

    for i in range(1, n + 1):
        # 通过递推式计算dp[i]
        dp[i] = max(i, dp[i // 2] + dp[i // 3] + dp[i // 4])

    return dp[n]

# 示例
n = 10
result = dynamic_programming(n)
print(result)  # 输出 13 (10 = 3 + 3 + 4)


# 回溯法：
# 回溯法通过尝试所有可能的解，并在找到满足条件的解后继续搜索其他可能的解。
def backtrack(remaining, path, target):
    if target == 0:
        return [path]

    result = []

    for i, num in enumerate(remaining):
        if num <= target:
            result.extend(backtrack(remaining[i + 1:], path + [num], target - num))

    return result

# 示例
arr = [2, 4, 6, 8]
target_sum = 8
solutions = backtrack(arr, [], target_sum)
print(solutions)  # 输出 [[2, 6], [8]]


# 分支界限法：
# 分支界限法通过设定界限条件，剪枝不必要的搜索，以提高求解效率。
def branch_and_bound(arr, target):
    arr.sort(reverse=True)
    stack = [(0, 0, 0)]  # (当前累加和，当前索引，选择的元素个数)
    result = []

    while stack:
        curr_sum, idx, count = stack.pop()

        if curr_sum == target:
            result.append(arr[idx - count:idx][::-1])
            continue

        if idx == len(arr) or curr_sum > target:
            continue

        stack.append((curr_sum, idx + 1, count))
        stack.append((curr_sum + arr[idx], idx + 1, count + 1))

    return result

# 示例
arr = [10, 5, 12, 8, 3]
target_sum = 15
solutions = branch_and_bound(arr, target_sum)
print(solutions)  # 输出 [[5, 10], [3, 12]]


# 贪心算法：
# 贪心算法通过每一步选择局部最优解，以期望最终获得全局最优解。
def greedy_algorithm(coins, amount):
    coins.sort(reverse=True)
    result = []

    for coin in coins:
        while coin <= amount:
            result.append(coin)
            amount -= coin

    if amount == 0:
        return result
    else:
        return None


# 示例
coins = [20, 10, 5, 2, 1]
amount = 47
change = greedy_algorithm(coins, amount)
print(change)  # 输出 [20, 20, 5, 2]