AcWing3187.奇怪的数列——学习笔记

Hokachi

已于 2023-02-19 16:40:49 修改

阅读量178

点赞数

分类专栏： AcWing 文章标签：学习算法 java 蓝桥杯递归

于 2023-02-19 16:39:10 首次发布

本文链接：https://blog.csdn.net/Hokachi/article/details/129111633

版权

AcWing 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

题目

3187. 奇怪的数列 - AcWing题库https://www.acwing.com/problem/content/3192/

代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String number = input.nextLine();
        int time = input.nextInt();
        String res = conversion(number,time);
        System.out.println(res);
        
    }
    //变换
    public static String conversion(String s,int time){
        if(time <= 0){
            return s;
        }

        int cur = 0;
        char[] cs = s.toCharArray();
        StringBuilder ans = new StringBuilder();
        while(cur < s.length()){
            int count = check(cur,cs);
            ans.append(count);
            ans.append(cs[cur]);
            cur += count;
        }
        return conversion(ans.toString(),time - 1);
    }

    //相同个数
    public static int check(int index,char[] s){
        if(index < 0 || index >= s.length){
            return -1;
        }
        if(s.length == 1 || index == s.length - 1){
            return 1;
        }
        int count = 1;
        for(int i = index + 1; i < s.length; i++){
            if(s[i - 1] == s[i]){
                count++;
            }else{
                break;
            }
        }
        return count;
    }

}

AC结果

思路

输入两行，第一行是初始值，第二行是需要转换的次数。转换的规则：如133由【一个一和两个三组成】，当他们完成了一次转换的时候为1123。每一次转换完成得到的串即是下一轮转换的初始串，因此我们利用递归完成多次的转换最后得到所求的串。

一、获取数据

        Scanner input = new Scanner(System.in);
        String number = input.nextLine();
        int time = input.nextInt();

第一行以字符串的形式获取，第二行以整数形式获取，以便后续处理。

二、判断相同个数

    //相同个数
    public static int check(int index,char[] s){
        if(index < 0 || index >= s.length){
            return -1;
        }
        if(s.length == 1 || index == s.length - 1){
            return 1;
        }
        int count = 1;
        for(int i = index + 1; i < s.length; i++){
            if(s[i - 1] == s[i]){
                count++;
            }else{
                break;
            }
        }
        return count;
    }

check方法用于判断，从index位置起，相同字符的个数。当index不合法（小于零或者大于等于数组长度时）则返回-1。如果数组仅有一个元素，又或者当前索引已经达到了数组的最后一个元素时，则直接返回1。其余情况，则遍历这个数组，判断前后元素是否相同，若相同则用count记录，最后返回count表示从index位置起字符连续相同的个数。

三、递归&输出

    //变换
    public static String conversion(String s,int time){
        if(time <= 0){
            return s;
        }

        int cur = 0;
        char[] cs = s.toCharArray();
        StringBuilder ans = new StringBuilder();
        while(cur < s.length()){
            int count = check(cur,cs);
            ans.append(count);
            ans.append(cs[cur]);
            cur += count;
        }
        return conversion(ans.toString(),time - 1);
    }

conversion是一个递归调用的方法，s是上一轮转换完成的串，而time表示还需要转换的次数。递归出口是，当time（小于）等于0时，则表示完成所有转换可以返回。为了方便后续处理，将字符串s转为char类型的数组cs，声明一个StringBuilder类型的对象ans用于构造新的一轮转换产生的串。遍历当前的串，利用check方法找到当前位置所对应的字符连续相等的个数，然后让cur+count位移到尚未判断的位置继续check。得到新的串用toString转为String类型作为下一轮转换的初始串开启下一轮转换。直至仍需转换次数为0，得到的最新的串就是题目所求。

        String res = conversion(number,time);
        System.out.println(res);

在主方法中调用conversion，用res存储递归得到的答案，最后打印出来即可。