day18 训练①统计每个月兔子的总数(斐波那契数列)②.字符串通配符(动态规划)*

目录

①统计每个月兔子的总数

②.字符串通配符(动态规划)

---

①统计每个月兔子的总数

import java.util.*;
public class Main{
    public static int func(int m){
        //考察的是斐波那契数列
        int first=1;//第一个月的兔子
        int second=1;//第二个月的兔子数量
        int num=0;//兔子总数量
        for(int i=3;i<=m;i++){//for循环求和
            num=first+second;//兔子数量求和
            first=second;//下一个月的求和=前两个月累加
            second=num;//通过赋值得到前两个月的和
        }
        return num;
    }
    public static void main(String[]args){
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
             int m=scanner.nextInt();
            System.out.println(func(m));
        }
    }
}

递归实现

 public static int func(int m){
     if(m==1||m==2){
         return 1;
         //第一个月和第二个月的兔子数量均为1
     }
        //兔子数量为m之前两个月的兔子数量之和
        return func(m-1)+func(m-2);
    }

②.字符串通配符(动态规划)***********************

 

 

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String t = sc.nextLine();
            String s = sc.nextLine();
            System.out.println(match(t, s));
        }
    } 
    public static boolean match(String t, String s) {
        //将t和s分别转换为数组
        char[] ct = t.toCharArray();
        char[] cs = s.toCharArray();
        int lt = ct.length;
        int ls = cs.length;
        //布尔类型二维动态规划数组
        boolean[][] dp = new boolean[ls + 1][lt + 1];
        //为了让下面动态规划匹配多定义一格
        dp[0][0] = true;
        for (int i = 0; i <= ls; i++) {
            //使用通配符的第一个字符来匹配，在ct中即为j-1
            for (int j = 1; j <= lt; j++) {
                //*号时的处理方式
                if (ct[j - 1] == '*') {
                    //i=0时没有字符串来匹配
                    if (i == 0) {
                        dp[i][j] = dp[i][j - 1];
                    } else {
                        //i！=0时字符串有可能是下列这些情况
                        if (cs[i - 1] == '.' || (cs[i - 1] >= '0' && cs[i - 1] <= '9') ||
                                (cs[i - 1] >= 'a' && cs[i - 1] <= 'z') || (cs[i - 1] >= 'A' && cs[i - 1] <= 'Z')
                           ) {
                            //两者取或满足，即动态规划匹配才能取true
                            dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
                        }
                    }
                } else {
                    //不是通配符时的情况，看？或其它字符是否匹配
                    if (i > 0 && defs(ct[j - 1], cs[i - 1])) {
                        dp[i][j] = dp[i - 1][j - 1];
                    }
                }
            }
        } return dp[ls][lt];
    }
    public static boolean defs(char t, char s) {
        //通配符？时直接返回true
        if (t == '?') return true;
        //小写字母转大写字母
        if (t >= 'a' && t <= 'z') {
            t = (char)(t - 'a' + 'A');
        } if(s >= 'a' && s <= 'z') {
            s = (char)(s - 'a' + 'A');
        } return s == t;
    }
}