ALGO-228 蓝桥杯 算法训练 数字游戏

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

这题由已知结果推出原始序列，那么原始序列有多少种排列，就是我们第一步要求的，即求序列1、2、3…N的全排列，然后再对每一种排列方式进行加法运算，找到符号sum的值。

1、求1~N的全排列（dfs）

那么我们先来实现全排列（全排列我们的完成我们通过dfs来实现）。
为了方便进行全排列的操作，再写一个交换函数作为辅助。
全排列的实现通过定义起始指针，与终止指针，来遍历交换元素。
当起始与终止指针指向同一个元素时，则说明我们排列完了一种情况。

    public static void swap(int[] array ,int i,int j)
    {
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }
    
 	public static void permutation(int[] array,int start,int end) {
        if(start==end) {
            String str=Arrays.toString(array);//将数组转换为字符串
            str=Arrays.toString(array).replace("[","").replace("]","").replace(" ","");
            String[] ss=str.split(",");//去掉格式化字符串后的一些符号
            lists.add(ss);
        } else {
            for (int i = start; i <= end; i++) {
                array=swap(array,start,i);//将序列中的每个数放到首位，排列后面的内容
                permutation(array,start+1,end);//进行下一个数字的排列
                array=swap(array,start,i);//回溯
            }
        }
    }

2、求每个序列的和（dp）

实现了全排列，我们对于每种排列进行相邻元素的加法运算，这里可以通过一个简单的动态规划实现。

3 1 2 4
4 3 6
7 9
16

可以看到，对于3124这个序列，我们实际上进行了3次运算，每次运算的值都是上一行的数与其相邻数的和。那么对于dp[i][j]:第i步运算的第j个数的值状态方程：

dp[i][j] = Math.max(array[j]+array[j + 1]) ，dp[i - 1][j] + dp[i - 1][j + 1]);

这个过程我们定义一个函数addThem来实现

   public static int addThem(String[] array)
    {
        int[][] dp=new int[array.length][array.length];
        //如果传入的数组的长度大于1则遍历，否则直接返回该元素
        if(array.length>1) {
        for (int i = 1; i < array.length; i++)//n个数要进行n-1步运算
            for (int j = 0; j < array.length - i; j++)
                dp[i][j] = Math.max(Integer.valueOf(array[j]) + Integer.valueOf(array[j + 1]), dp[i - 1][j] + dp[i - 1][j + 1]);
        return dp[array.length - 1][0];
        }
        else
            return Integer.valueOf(array[0]);
    }

3、添加判断条件

遍历所有排列进行addThem()运算之后，如果该值满足sum，那么我们就返回，题目中说可能有多个条件满足，那么我们还要比较各个序列的大小，如下：

order="9999999999"//初始化序列，即我们的结果
int result=addThem(ss);
if(result==sum){
    String sss="";
    for(String s:ss)
        sss+=s;
    if(order.length()==sss.length())
    {
    //对于找到的序列，如果任意位数小于order，那么就可以返回了
        for(int i=0;i<order.length();i++) {
            if (order.toCharArray()[i] < sss.toCharArray()[i])
                return;
        }
    }
    if(order.compareTo(sss)>0)//比较两个字符串大小，order更大，则将sss的值赋给order
        order=sss;
}

上述代码的应该放在每次全排列完得到一个全排列时进行判断。完整代码如下：

import java.lang.reflect.Array;
import java.util.*;
public class 数字游戏 {
    static int sum;
    static String order;
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        sum=sc.nextInt();
        int add=0;
        int[] number=new int[n];
        order ="999999999999";//初始化序列，即我们的结果
        for(int i=0;i<n;i++)
            number[i]=i+1;
        permutation(number,0,n-1);

        for(char ch:order.toCharArray())
            System.out.print(ch+" ");

    }
    public static int addThem(String[] array)
    {
        int sum=0;
        int[][] dp=new int[array.length][array.length];
        if(array.length>1) {
            for (int i = 1; i < array.length; i++)//n个数要进行n-1步运算
                for (int j = 0; j < array.length - i; j++)//对于n个数需要进行n-1次加法操作
                    dp[i][j] = Math.max(Integer.valueOf(array[j]) + Integer.valueOf(array[j + 1]), dp[i - 1][j] + dp[i - 1][j + 1]);
            return dp[array.length - 1][0];
        }
        else
            return Integer.valueOf(array[0]);
    }
    public static void permutation(int[] array,int start,int end) {
        if(start==end) {
            String str=Arrays.toString(array);
            str=Arrays.toString(array).replace("[","").replace("]","").replace(" ","");
            String[] ss=str.split(",");
            int result=addThem(ss);
            if(result==sum){
                String sss="";
                for(String s:ss)
                    sss+=s;
                if(order.length()==sss.length())
                {
                    for(int i=0;i<order.length();i++) {
                        if (order.toCharArray()[i] < sss.toCharArray()[i])
                            return;
                    }
                }
                if(order.compareTo(sss)>0)//比较两个字符串大小，order更大，则将sss的值赋给order
                    order=sss;
            }
        } else {
            for (int i = start; i <= end; i++) {
                swap(array,start,i);
                permutation(array,start+1,end);
                swap(array,start,i);
            }
        }
    }
    public static void swap(int[] array ,int i,int j)
    {
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }
}