ALGO-1005 蓝桥杯 数字游戏 python

问题描述
　　给定一个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

---

先写出给出排列得出sum的方法

# 累加器
def fun1(L):
    arr = [L]
    n = len(L)
    for j in range(1, n):
        arr.append([])
        for i in range(n - j)[::-1]:
            arr[j].append(arr[j - 1][i] + arr[j - 1][i + 1])
    return arr

---

首先想到的是直接枚举全排列，然后带入这个累加器方法，求生sum，然后判断是否相等，相等返回。

全排列组合的可能性就是n^n，但是每一个全排列组合就要算n！,那么总共要(n^n)*n!很容易超时

---

但是很明显，不同位置上加上1个数字，sum在不同位置变化是相同的，故可以算出每个列表对应增长的变化率

# 梯度计算器
def fun2():
    L = [0]*n
    dl = list()
    for i in range(n):
        L[i] = 1
        arr1 =fun1(L)
        dl += [arr1[-1][-1]]
        L[i] = 0
    return dl

---

根据传入l1与已经算好的arr和sum1比较得出l1的newsum

# 计算新的sum
def newSum(l1,arr,sum1):
    newsum = sum1
    for i in range(n):
        dn = l1[i] - arr[i]
        ln = dn*dr[i]
        newsum += ln
    return newsum

---

最后写一个全排，我用的是我以前写的排列组合的函数

def mypermutations(arr:list,b:int)->list:
    out = [0] * b
    n = len(arr)
    L = list()
    def fun(t=0):
        lenarr = len(arr)
        if t==b:
            L.append(tuple(out))
            return
        for i in range(lenarr):
            loop = arr.pop(i)
            out[t] = loop
            fun(t+1)
            arr.insert(i,loop)
    fun()
    return L

修改排列组合

def mypermutations(arr:list,b:int)->list:
    out = [0] * b
    n = len(arr)
    global is_get
    is_get = False
    def fun(t=0):
        global is_get
        lenarr = len(arr)
        if t==b:
            if newSum(out, L2, sum1) == sum:
                for d in out:
                    print(d,end=' ')
                is_get = True
            return
        for i in range(lenarr):
            loop = arr.pop(i)
            out[t] = loop
            fun(t+1)
            if is_get:
                return
            arr.insert(i,loop)
    fun()

---

补充

n,sum= list(map(int,input().split()))

L = list(range(1,n+1))
L2 = list(range(1,n+1))
sum1 = fun1(L)[-1][-1]
dr = fun2()
mypermutations(L,n)

---

完整代码

# 累加器
def fun1(L):
    arr = [L]
    n = len(L)
    for j in range(1, n):
        arr.append([])
        for i in range(n - j)[::-1]:
            arr[j].append(arr[j - 1][i] + arr[j - 1][i + 1])
    return arr
# 梯度计算器
def fun2():
    L = [0]*n
    dl = list()
    for i in range(n):
        L[i] = 1
        arr1 =fun1(L)
        dl += [arr1[-1][-1]]
        L[i] = 0
    return dl
# 计算新的sum
def newSum(l1,arr,sum1):
    newsum = sum1
    for i in range(n):
        dn = l1[i] - arr[i]
        ln = dn*dr[i]
        newsum += ln
    return newsum
# 产生排列组合
def mypermutations(arr:list,b:int)->list:
    out = [0] * b
    n = len(arr)
    global is_get
    is_get = False
    def fun(t=0):
        global is_get
        lenarr = len(arr)
        if t==b:
            if newSum(out, L2, sum1) == sum:
                for d in out:
                    print(d,end=' ')
                is_get = True
            return
        for i in range(lenarr):
            loop = arr.pop(i)
            out[t] = loop
            fun(t+1)
            if is_get:
                return
            arr.insert(i,loop)
    fun()



n,sum= list(map(int,input().split()))

L = list(range(1,n+1))
L2 = list(range(1,n+1))
sum1 = fun1(L)[-1][-1]
dr = fun2()
mypermutations(L,n)

---

但是只能得90分

 

---

那只能优化代码

在递归中把大于sum的剪掉

        if newsum>=sum:
            return

def mypermutations(arr:list,b:int)->list:
    out = [0] * b
    n = len(arr)
    global is_get
    is_get = False
    global newsum
    newsum = 0
    def fun(t=0):
        global is_get
        global newsum
        lenarr = len(arr)
        if t==b:
            if newsum== sum:
                pass
                for d in out:
                    print(d,end=' ')
                is_get = True
                return
        if newsum>=sum:
            return
        for i in range(lenarr):
            loop = arr.pop(i)
            newsum += dr[t]*loop
            out[t] = loop
            fun(t+1)
            if is_get:
                return
            newsum -= dr[t] * loop
            arr.insert(i,loop)
    fun()

 这个就通过了测试

---

完整代码：

# 累加器
def fun1(L):
    arr = [L]
    n = len(L)
    for j in range(1, n):
        arr.append([])
        for i in range(n - j)[::-1]:
            arr[j].append(arr[j - 1][i] + arr[j - 1][i + 1])
    return arr
# 梯度计算器
def fun2():
    L = [0]*n
    dl = list()
    for i in range(n):
        L[i] = 1
        arr1 =fun1(L)
        dl += [arr1[-1][-1]]
        L[i] = 0
    return dl
def mypermutations(arr:list,b:int)->list:
    out = [0] * b
    n = len(arr)
    global is_get
    is_get = False
    global newsum
    newsum = 0
    def fun(t=0):
        global is_get
        global newsum
        lenarr = len(arr)
        if t==b:
            if newsum== sum:
                pass
                for d in out:
                    print(d,end=' ')
                is_get = True
                return
        if newsum>=sum:
            return
        for i in range(lenarr):
            loop = arr.pop(i)
            newsum += dr[t]*loop
            out[t] = loop
            fun(t+1)
            if is_get:
                return
            newsum -= dr[t] * loop
            arr.insert(i,loop)
    fun()



n,sum= list(map(int,input().split()))

L = list(range(1,n+1))
dr = fun2()
mypermutations(L,n)