【Python蓝桥杯】数字游戏给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。

原创已于 2023-03-03 09:50:47 修改 · 2.4k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#python #蓝桥杯

于 2023-03-02 00:04:16 首次发布

Python蓝桥杯——算法训练专栏收录该内容

4 篇文章

订阅专栏

文章介绍了如何使用回溯算法和深度优先搜索（DFS）解决蓝桥杯竞赛中关于排列和数字相加的问题。通过分析数据模式，发现与杨辉三角的关系，从而优化搜索策略。在搜索过程中，当数值累加超过给定和时，采用回溯方法尝试其他排列，最终找到字典序最小的正确排列。

最近在刷蓝桥杯题目，按题目做一下笔记整理，顺便分享交流一下，有更好的解决方案欢迎大家共同提出探讨，以下源代码为系统提交满分答案

数字游戏

问题描述

资源限制
Python时间限制：5.0s
问题描述
给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
　　例如:
　　3 1 2 4
　　4 3 6
　　7 9
　　16
　　现在如果知道N和最后得到的数字sum，请求出最初序列a[i]，为1～N的一个排列。若有多种答案，则输出字典序最小的那一个。数据保证有解。
输入格式
第1行为两个正整数n，sum
输出格式
一个1～N的一个排列
样例输入
4 16
样例输出
3 1 2 4
数据规模和约定
0<n<=10

源代码

def YH_tri(row_num):    #  返回杨辉三角第n行
    if row_num == 1:
        result = [1]
    else:
        result = [[0 for i in range(0,row_num)]for i in range(0,row_num)]
        for i in range(0,row_num):
            for j in range(0,row_num):
                result[i][0] = 1
                if i == j:
                    result[i][j] = 1
        for x in range(2,row_num):
            for y in range(1,x):
                result[x][y] = result[x-1][y-1] + result[x-1][y]
    return result[row_num-1]

n,Sum = map(int,input().split())
yh_tri = YH_tri(n)      #  杨辉三角第n行
res = []     #  用于保存最终结果
used = [0 for i in range(n+1)]        #  构建n+1个值为0的列表，标记数据是否已被使用，由于循环从1开始，第0个元素不使用，因此需要n+1
flag = 0
def dfs(num,temp_sum):      #  num记录深度搜索到第几位，temp_sum是目前的和
    global flag
    if temp_sum > Sum:      #  当前和大于给定值，一定错误，直接返回
        return
    if num == n:
        if temp_sum == Sum:     #  成功找到
            for x in res:
                print(x,'',end='')
            flag = 1        #  不可直接返回，直接return返回是到上一层dfs，还会继续循环往下执行，应使用某些操作（例如标志变量）将后续操作'截停'
            return
        else:
            return

    for i in range(1,n+1):
        if used[i] == 0:
            used[i] = 1     #  使用过（存在于res）的数字置1
            res.append(i)
            dfs(num + 1, temp_sum + yh_tri[num] * i)
            if flag == 1:
                return
            else:
                used[i] = 0     #  flag!=1说明上一组排列不满足，将最后一位数字恢复置零，进行下一组判断
                res.pop()

if n == 1:      #  一位数直接返回sum值
    print(Sum)
else:
    dfs(0,0)

问题分析

⚠首先就是，一定要好好读题！由于我最开始没注意到1~N的一个排列，以为是随机数，研究了好几个小时没有头绪！
ok现在我们知道结果为1~N的一个排列，也就是如果输入n==4的话，答案输出为[1，2，3，4]排列方式的一种，再来看一看数据规模，0<n<=10，最大为10! = 3628800种情况，无法暴力破解，考虑dfs深度优先遍历，方法已经暂定了，我们来尝试一下。
1️⃣首先注意到数据规模过大，我们进行条件（相加和==sum）判断时不能简单进行逐层相加，否则时间复杂度太高，对程序运行时间是个极大的考验，尝试把数据相加依次写出，找出第i层和sum的规律，看能否直接由第i层的数计算sum
🍩构建数据

🥘数据累加分析

🍝在分析完数据后，惊奇的发现，哟这不是杨辉三角吗

🍪得出结论：sum的值为n个输出值与第n层杨辉三角依次相乘累加
2️⃣**实现dfs大致思路就是从1~N为其赋值（题目要求若有多种答案，则输出字典序最小的那一个，因此要是递增顺序）并逐次询问是否满足条件，如果乘积累加值大于sum(无论走到哪一步，只要大于sum一定是错的，直接return)或是循环结束仍不等于sum，将最后一个数取出，换下一种排列方式，即换下一个数重新尝试

Python中又称试探算法（回溯算法），它实际上是一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。
用回溯算法解决问题的一般步骤：

针对所给问题，定义问题的解空间，它至少包含问题的一个（最优）解。
确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间。
以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

确定了解空间的组织结构后，回溯法就从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。这个开始结点就成为一个活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点。这个新结点就成为一个新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。
基本思想总结起来就是：从一条路往前走，能进则进，不能进则退回来，换一条路再试，直到走出为止

回溯算法类型题目，重在理解其工作过程（如何遍历及如何递归的）才能会使用，一些细节的处理相对不是那么难理解，在此不多做赘述，在代码的注释中为大家直接标注**,下面为大家展示了给定输入数据（4 16）在代码中的运行过程，供大家进一步理解：
🧆
进入,i=1,num=0,sum=0：
[1]
[0, 1, 0, 0, 0]
进入,i=2,num=1,sum=1：
[1, 2]
[0, 1, 1, 0, 0]
进入,i=3,num=2,sum=7：
[1, 2, 3]
[0, 1, 1, 1, 0]
进入,i=4,num=3,sum=16：
[1, 2, 3, 4]
[0, 1, 1, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[1, 2, 3]
[0, 1, 1, 1, 0]
删除：
[1, 2]
[0, 1, 1, 0, 0]
进入,i=4,num=2,sum=7：
[1, 2, 4]
[0, 1, 1, 0, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[1, 2]
[0, 1, 1, 0, 0]
删除：
[1]
[0, 1, 0, 0, 0]
进入,i=3,num=1,sum=1：
[1, 3]
[0, 1, 0, 1, 0]
进入,i=2,num=2,sum=10：
[1, 3, 2]
[0, 1, 1, 1, 0]
进入,i=4,num=3,sum=16：
[1, 3, 2, 4]
[0, 1, 1, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[1, 3, 2]
[0, 1, 1, 1, 0]
删除：
[1, 3]
[0, 1, 0, 1, 0]
进入,i=4,num=2,sum=10：
[1, 3, 4]
[0, 1, 0, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[1, 3]
[0, 1, 0, 1, 0]
删除：
[1]
[0, 1, 0, 0, 0]
进入,i=4,num=1,sum=1：
[1, 4]
[0, 1, 0, 0, 1]
进入,i=2,num=2,sum=13：
[1, 4, 2]
[0, 1, 1, 0, 1]
数值累乘和超出sum范围，删除：
[1, 4]
[0, 1, 0, 0, 1]
进入,i=3,num=2,sum=13：
[1, 4, 3]
[0, 1, 0, 1, 1]
数值累乘和超出sum范围，删除：
[1, 4]
[0, 1, 0, 0, 1]
本次循环完成，删除：
[1]
[0, 1, 0, 0, 0]
删除：
[]
[0, 0, 0, 0, 0]
进入,i=2,num=0,sum=0：
[2]
[0, 0, 1, 0, 0]
进入,i=1,num=1,sum=2：
[2, 1]
[0, 1, 1, 0, 0]
进入,i=3,num=2,sum=5：
[2, 1, 3]
[0, 1, 1, 1, 0]
进入,i=4,num=3,sum=14：
[2, 1, 3, 4]
[0, 1, 1, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[2, 1, 3]
[0, 1, 1, 1, 0]
删除：
[2, 1]
[0, 1, 1, 0, 0]
进入,i=4,num=2,sum=5：
[2, 1, 4]
[0, 1, 1, 0, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[2, 1]
[0, 1, 1, 0, 0]
删除：
[2]
[0, 0, 1, 0, 0]
进入,i=3,num=1,sum=2：
[2, 3]
[0, 0, 1, 1, 0]
进入,i=1,num=2,sum=11：
[2, 3, 1]
[0, 1, 1, 1, 0]
进入,i=4,num=3,sum=14：
[2, 3, 1, 4]
[0, 1, 1, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[2, 3, 1]
[0, 1, 1, 1, 0]
删除：
[2, 3]
[0, 0, 1, 1, 0]
进入,i=4,num=2,sum=11：
[2, 3, 4]
[0, 0, 1, 1, 1]
数值累乘和超出sum范围，本次循环完成，删除：
[2, 3]
[0, 0, 1, 1, 0]
删除：
[2]
[0, 0, 1, 0, 0]
进入,i=4,num=1,sum=2：
[2, 4]
[0, 0, 1, 0, 1]
进入,i=1,num=2,sum=14：
[2, 4, 1]
[0, 1, 1, 0, 1]
数值累乘和超出sum范围，删除：
[2, 4]
[0, 0, 1, 0, 1]
进入,i=3,num=2,sum=14：
[2, 4, 3]
[0, 0, 1, 1, 1]
数值累乘和超出sum范围，删除：
[2, 4]
[0, 0, 1, 0, 1]
本次循环完成，删除：
[2]
[0, 0, 1, 0, 0]
删除：
[]
[0, 0, 0, 0, 0]
进入,i=3,num=0,sum=0：
[3]
[0, 0, 0, 1, 0]
进入,i=1,num=1,sum=3：
[3, 1]
[0, 1, 0, 1, 0]
进入,i=2,num=2,sum=6：
[3, 1, 2]
[0, 1, 1, 1, 0]
进入,i=4,num=3,sum=12：
[3, 1, 2, 4]
[0, 1, 1, 1, 1]
3 1 2 4