第七章　递归，ｄｆｓ，剪枝，回溯（下）

最新推荐文章于 2022-07-14 19:19:35 发布

陈一Kristian

最新推荐文章于 2022-07-14 19:19:35 发布

阅读量229

点赞数

本文链接：https://blog.csdn.net/h_666666/article/details/87104127

版权

本文探讨了四个涉及递归和动态规划的问题：1. 使用1和2两种长度的瓷砖铺地板的不同方法数；2. 计算N年后农场中母牛的数量；3. 确定在特定规则下，A能否在两人轮流取球游戏中获胜；4. 字符串到字母的转换。文章通过实例解析了如何解决这些问题，包括避免溢出、优化递归为迭代等策略。

摘要由CSDN通过智能技术生成

１、

描述

有一长度为N(1<=Ｎ<=1000)的地板，给定两种不同瓷砖：一种长度为1，另一种长度为2，数目不限。

要将这个长度为N的地板铺满，一共有多少种不同的铺法？

为了防止溢出，请将结果Mod 1000000007

输入

一个整数N。(1 <= N <= 1000)

输出

铺法的数量Mod 1000000007

第一次写的代码，，，但是我不知道怎么把ｍｏｄ加进去，不知道直接在ｆ函数里面加一句（ｃ　＝　ｃ％ｍｏｄ）可以不

ｍｏｄ一个数字在时间上不影响的，如果超时，那就是递归改成迭代

import java.util.Scanner;

public class Main{
    static int N;
    static int num=0;
    static int mod= 1000000007;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        f(0);
        System.out.println(num);
    }
    static void f(int c){
        if(c==N){
            num ++;
            return;
        }
        if(c>N){
            return;
        }
        f(c+1);
        f(c+2);
    }
}

后来把代码改成了这样　，然后超时了；

import java.util.Scanner;

public class Main{
    static int N;
    static int mod= 1000000007;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        long res = f(N);
        System.out.println(res);
    }
    static long f(int N){
        if(N==1) return 1;
        if(N==2) return 2;
        return f(N-1)%mod+f(N-2)%mod;
    }
}

最后改成了迭代，，ａｃ，代码如下

import java.util.Scanner;

public class Main{
    static int N;
    static int num=0;
    static int mod= 1000000007;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        System.out.println(f(N));
    }
    static int f(int c){
        int x1 = 1;
        int x2 = 2;
        for(int i=3;i<=c;i++){
            int x_1 = x1;
            x1 =x2 %mod;
            x2  = (x1+x_1)%mod;
        }
        return x2;
    }
}

2、

假设农场中成熟的母牛每年只会生一头小母牛，并且永远不会死。第一年农场有１只成熟的牛，从第二年开始，母牛开始生小母牛。每只小母牛３年之后成熟又可以生小母牛。

给定整数Ｎ，返回Ｎ年后牛的数量

为防止溢出,请将结果结果mod 1000000007

输入

N(1<=N<=1000)

输出

N年后牛的数量 mod 1000000007

样例输入

样例输出

哎，比较诡异，就是一样的思路还是超时的，，知道问题后改回来

import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = f(n);
        System.out.println(x);
    }
    static int f(int n){
        if (n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 3;
        return (f(n-1)+f(n-3))%1000000007;
    }
}

这里我没有重复利用，，如果重复利用的话因为要跳空我不知道改保存多少个，所以我全部保存了

import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = f(n);
        System.out.println(x);
    }
    static int f(int n){
        int [] number  = new int[n+1];
        if (n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 3;
        number[1] = 1;
        number[2] = 2;
        number[3] = 3;
        for(int i=4;i<=n;i++){

            number[i]  = (number[i-3]+number[i-1])%1000000007;
        }
        return number[n];
    }
}

３、

描述

今盒子里有 n个小球，A 、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，
也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。

我们约定：

每个人从盒子中取出的球的数目必须是： 1，3 ，7或者 8个。

轮到某一方取球时不能弃权！

A先取球，然后双方交替取球，直到取完。

被迫拿到最后一个球的一方为负方（输方）

请编程确定出在双方都不判断失误的情况下，对于特定的初始球数， A是否能赢？

输入

先是一个整数 n(n<100)，表示接下来有n个整数。然后是 n个整数，每个占一行（整数 <10000），表示初始球数。

输出

输出 n行，表示A 的输赢情况（输为 0，赢为1 ）。

样例输入

样例输出

暴风哭泣，，，，不知道为啥ｗａ掉了，这个就是ｗａ了，也不是超时了，我也没有把他改成迭代试一下

import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        for(int i=0;i<N;i++){
            int n = sc.nextInt();
            if(test(n)){
                System.out.println(1);
            }else {
                System.out.println(0);
            }

        }
    }
    static boolean test(int n){
        if(n>=1){
            switch (n){
                case 1:return false;//轮到他的时候只剩下一个求，他是最后一个拿球的，所以输掉了
                case 3:return false;
                case 7:return false;
                case 8:return true;//这里注意！！！８＝１＋７
                default: return (!test(n-8)|| !test(n-7) || !test(n-3) || !test(n-1));//能除得尽就说明他是最后一个就输了，所以这里要取反
            }
        }else
            return false;
    }

}

４、

描述
给定一个字符串str，str全部由数字字符组成，如果str中某一个或者某相邻两个字符组成的子串在1~26之间，则这个子串可以转换为一个字母。

规定“1”转换为“A”，“2”转换为“B”……“26”转换为“Z”。求str有多少种不同的转换结果。

输入
字符串str(|str|<20)

输出
可转换结果的数目

样例输入

12345678
样例输出

3
https://www.jianshu.com/p/80e1841909b7写的超级好

关于动归那里，可以理解为如果这个数加上之后这个数和上一个数不能转化为一个字符的话　，那么这个数的情况就等于上一个数字的情况，如果可以转为一个字符的话，这个数字的情况就等于上一个的情况加上上上一个情况。（妈呀，这里我不太懂，，数学能加一下但是道理我不太懂啊）

然后我需要把递归的写法填上去https://blog.csdn.net/u012317785/article/details/78185966这里有一个递归的思路，

这里先是动归的写法，但是这个代码是ａｃ８０分

import java.util.Scanner;
 
class Main{
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        String s = sc.next();
 
        System.out.println(gettranslationcount(s));
    }
    static int gettranslationcount(String  number){
        if(number.length()==1) return 1;
        int f1 = 1;
        int f2 =1;
        int g =0;
        int temp=0;
        for(int i = number.length()-2;i>=0;i--){
            if(Integer.parseInt(number.charAt(i)+""+number.charAt(i+1))<26){
                g=1;
            }else {
                g= 0;
            }
            temp =f2;
            f2 = f2+g*f1;
            f1 = temp;
        }
        return f2;
    }
}