个人随想录（算法题）

代码随想录

最长回文子串（回文子串）

• 给你一个字符串 s，找到 s 中最长的回文子串。
  输入：babad
  输出：bab

import java.util.Scanner;

public class HW1 {
    public static void main(String[] args) {
        //cin
        //boolean isHui(String){}
        //滑动区间
        //if true<isHui(String) String.size()>String.size() String = String
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        int len = 1;
        StringBuilder stringBuilder = new StringBuilder();
        while (len<=str.length()){
            for(int i=0;i<=str.length()-len;i++){
                String substring = str.substring(i, i + len);
                if(isHui(substring)){
                    stringBuilder.delete(0,stringBuilder.length());
                    stringBuilder.append(substring);
                }
            }
            len++;
        }
        System.out.println(stringBuilder.toString());
    }
    public static boolean isHui(String str){
        int first = 0;
        int last = str.length()-1;
        boolean flag = true;
        while(first<last){
            if(str.charAt(first)!=str.charAt(last)){
                flag =false;
            }
            first++;
            last--;
        }
        return  flag;
    }
}

• 对于数组和字符串的操作，主要是对指针的操作。
• 子函数：将大问题化小问题。
• i<=str.length()-len 表示最后一段len会被计算。

组合总数问题（组合问题）

• 给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

import java.util.*;

public class KuoHao {
    public static void main(String[] args) {
        //cin
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        String[] chars = str.split(",");
        int[] nums = new int[chars.length];
        for(int i=0;i<chars.length;i++){
            nums[i]=Integer.parseInt(chars[i]);
        }
        int target = scanner.nextInt();
        //回溯
        HashSet<List<Integer>> res = new HashSet<>();
        List<Integer> path = new ArrayList<>();
        Hui(nums,target,res,path,0);
        System.out.println(res);
    }

    public static void Hui(int[] nums,int target,HashSet<List<Integer>> res,List<Integer> path,int index){
            //一定要先搜集结果。
            Integer sum=0;
            for(Integer item:path){
                sum+=item;
            }
            //收集结果，==情况
            if(sum==target){
                res.add(new ArrayList<Integer>(path).stream().sorted().toList());
            }
            //截止条件
            if(sum>target){
                return;
            }
            if(index==nums.length){
                return;
            }
//                //可重复情况
//                path.add(nums[index]);//添加元素
//                Hui(nums,target,res,path,index);//情况1：对nums[index]重复以上操作：下一个操作继续添加该元素。
//                path.remove(path.size()-1);//回溯选择第2种情况：撤销上一次递归的那种情况。
//                Hui(nums,target,res,path,index+1);//情况2：对nums[index+1]重复以上操作：下一个操作添加该元素的下一个元素。

                //不重复情况
                path.add(nums[index]);
                Hui(nums,target,res,path,index+1);
                path.remove(path.size()-1);//撤销上面两条语句执行结果。
                //不添加此元素
                Hui(nums,target,res,path,index+1);
            }
        }

数青蛙（间断字符串匹配）

• 给你一个字符串 croakOfFrogs，它表示不同青蛙发出的蛙鸣声（字符串 “croak” ）的组合。由于同一时间可以有多只青蛙呱呱作响，所以 croakOfFrogs 中会混合多个 “croak” 。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CroakOfFrogs {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        //通过HashMap记录字符数，字符数不一致，返回-1
        //匹配字符串字符串，匹配成功则截断匹配字串已经匹配字符，直至主串遍历完成，或则匹配串截断完成，则重新生成完整匹配串，重复以上过程
        HashMap<String, Integer> map = new HashMap<>();
        for(int i=0;i<str.length();i++){
            map.put(String.valueOf(str.charAt(i)),map.getOrDefault(str.charAt(i),0)+1);
        }
        Integer pre = -1;
        for(Map.Entry<String,Integer> entry: map.entrySet()){
            if(pre==null){
                pre = entry.getValue();
            }
            else {
               if(entry.getValue()!= pre){
                   System.out.println(-1);
                   return ;
               }
            }
        }
        String strp = "croak";
        Integer indexstr = 0;//主串指针
        Integer indexstrp = 0;//匹配串指针
        Integer count = 0;
        //截止条件
        while(indexstr<str.length()){
            if(strp.charAt(indexstrp)==str.charAt(indexstr)){
                strp=strp.substring(indexstrp+1,strp.length());
                if (strp==""){
                    count++;
                    strp="croak";
                }
            }
            indexstr++;
        }
        System.out.println(count);

    }
}

最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
输入：abcde ace
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。

import java.util.Scanner;

public class LongSubsequence {
    public static void main(String[] args) {
        //数据装配
        Scanner scanner = new Scanner(System.in);
        String str1 = scanner.next();
        String str2= scanner.next();
        //每次匹配到一个字符，删除字符，更新字串，重复上述过程；
        //使用sum记录匹配匹配总字符数，使用indexi指向字符主串位置，使用indexj指向字符子串位置；
        int indexi = 0;
        int indexj = 0;
        int sum = 0;
        for(;indexi<str1.length()&&str2.length()!=0;indexi++){
            if(str1.charAt(indexi)==str2.charAt(indexj)){
                sum++;
                str2=str2.substring(indexj+1,str2.length());
            }
        }
        System.out.println(sum);
    }
}