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

最新推荐文章于 2022-12-04 16:58:04 发布

Demonslzh6

最新推荐文章于 2022-12-04 16:58:04 发布

阅读量6.2k

点赞数 10

CC 4.0 BY-SA版权

分类专栏：蓝桥杯文章标签：字符串 dfs 动态规划算法

本文链接：https://blog.youkuaiyun.com/Demonslzh/article/details/104477623

蓝桥杯专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一种解决数学问题的算法，给定一个数字N和一个总和sum，求出1到N的一个排列，使得经过一系列相邻数相加操作后的结果等于sum。文章详细描述了如何使用全排列和动态规划方法找到满足条件的序列，并确保输出的是字典序最小的解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

这题由已知结果推出原始序列，那么原始序列有多少种排列，就是我们第一步要求的，即求序列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;
    }
}