2023-07-02：给定一个1~N的排列，每次将相邻两数相加，可以得到新的序列，长度是N-1 再对新的序列，每次将相邻两数相加，可以得到新的序列，长度是N-2 这样下去可以最终只剩一个数字 比如 :

2023-07-02：给定一个1~N的排列，每次将相邻两数相加，可以得到新的序列，长度是N-1

再对新的序列，每次将相邻两数相加，可以得到新的序列，长度是N-2

这样下去可以最终只剩一个数字

比如 :

3 1 2 4

4 3 6

7 9

16

现在如果知道N，和最后的数字sum，反推最原始的序列是什么

如果有多个答案，返回字典序最小的那个

字典序看做所有数字拼起来的字符串字典序

比如

1, 10, 2... 拼起来是 1102...

1, 2, 3, 4... 拼起来是 1234...

认为 1, 10, 2...的字典序更小

如果给定的n和sum，有答案，返回一个N长度的答案数组

如果给定的n和sum，无答案，返回一个1长度的数组{ -1 }

输入 : N = 4, sum = 16

输出 : 3 1 2 4

输入 : N = 10, sum = 4116

输出 : 1 3 5 7 10 9 8 6 4 2

答案2023-07-02：

大体步骤如下：

1.创建一个二维动态数组dp，大小为(1<<(n+1))x(sums[n]+1)。

2.定义一个变量status，其初始值为((1 << (n + 1)) - 1) ^ 1。

3.如果n小于1或大于10，或者sum大于sums[n]，则返回数组[-1]。

4.调用process函数处理状态status、剩余和rest、索引index、长度n、模数组modulus和动态数组dp，得到结果ans。

5.如果ans的值为-1，说明无法找到合适的序列，返回数组[-1]。

6.创建一个长度为n的答案数组ans，并初始化index为0，rest为sum。

7.当status不等于0时，执行以下循环：

• 将dp[status][rest]的值赋给ans[index]。

• 将status异或上1 << ans[index]，更新status。

• 将rest减去ans[index] * modulus[index]，更新rest。

• 将index加1。

8.返回答案数组ans。

总的时间复杂度：O(2^N * sum)，其中N为输入的n，sum为输入的sum。

总的空间复杂度：O(2^N * sum)，包括二维动态数组dp的空间。

go语言代码如下：

package main

import "fmt"

var moduluses = [][]int{
	{},
	{1},
	{1, 1},
	{1, 2, 1},
	{1, 3, 3, 1},
	{1, 4, 6, 4, 1},
	{1, 5, 10, 10, 5, 1},
	{1, 6, 15, 20, 15, 6, 1},
	{1, 7, 21, 35, 35, 21, 7, 1},
	{1, 8, 28, 56, 70, 56, 28, 8, 1},
	{1, 9, 36, 84, 126, 126, 84, 36, 9, 1},
}

var sums = []int{0, 1, 3, 9, 24, 61, 148, 350, 808, 1837, 4116}

func lsp(n int, sum int) []int {
	if n < 1 || n > 10 || sum > sums[n] {
		return []int{-1}
	}
	dp := make([][]int, 1<<(n+1))
	for i := range dp {
		dp[i] = make([]int, sums[n]+1)
	}
	status := ((1 << (n + 1)) - 1) ^ 1
	if !process(status, sum, 0, n, moduluses[n], dp) {
		return []int{-1}
	}
	ans := make([]int, n)
	index := 0
	rest := sum
	for status != 0 {
		ans[index] = dp[status][rest]
		status ^= 1 << ans[index]
		rest -= ans[index] * moduluses[n][index]
		index++
	}
	return ans
}

func process(status int, rest int, index int, n int, modulus []int, dp [][]int) bool {
	if rest < 0 {
		return false
	}
	if status == 0 {
		return rest == 0
	}
	if dp[status][rest] != 0 {
		return dp[status][rest] != -1
	}
	ans := -1
	if n == 10 && (status&(1<<10)) != 0 {
		if process(status^(1<<10), rest-modulus[index]*10, index+1, n, modulus, dp) {
			ans = 10
		}
	}
	if ans == -1 {
		for i := 1; i <= n; i++ {
			if (status & (1 << i)) != 0 {
				if process(status^(1<<i), rest-modulus[index]*i, index+1, n, modulus, dp) {
					ans = i
					break
				}
			}
		}
	}
	dp[status][rest] = ans
	return ans != -1
}

func main() {
	N1 := 4
	sum1 := 16
	ans1 := lsp(N1, sum1)
	for _, num := range ans1 {
		fmt.Printf("%d ", num)
	}
	fmt.Println()

	N2 := 10
	sum2 := 4116
	ans2 := lsp(N2, sum2)
	for _, num := range ans2 {
		fmt.Printf("%d ", num)
	}
	fmt.Println()

	N3 := 10
	sum3 := 3688
	ans3 := lsp(N3, sum3)
	for _, num := range ans3 {
		fmt.Printf("%d ", num)
	}
	fmt.Println()

	N4 := 10
	sum4 := 4013
	ans4 := lsp(N4, sum4)
	for _, num := range ans4 {
		fmt.Printf("%d ", num)
	}
	fmt.Println()
}