【NBUOJ刷题笔记】递推_递归+分治策略1

最新推荐文章于 2024-05-20 21:56:33 发布

米饭好好吃.

最新推荐文章于 2024-05-20 21:56:33 发布

阅读量988

点赞数 27

分类专栏： NBUOJ刷题文章标签：笔记 java 算法

本文链接：https://blog.csdn.net/weixin_62533201/article/details/136904154

版权

NBUOJ刷题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

0. 前言

PS：本人并不是集训队的成员，因此代码写的烂轻点喷。。。本专题一方面是巩固自己的算法知识，另一方面是给NBU学弟学妹们参考解题思路（切勿直接搬运抄袭提交作业！！！）最后，该系列博客AC代码均以Java语言提交，C/C++的可以参考思路编写代码

1. 题目详情

1.1 题目一：王老师爬楼梯

1.1.1 题目信息

题目描述：
王老师爬楼梯，他可以每次走1级或者2级或者3级楼梯，输入楼梯的级数，求不同的走法数。（要求递推求解）如果N很大，需要高精度计算。
输入要求：
一个整数N，N<=1000。
输出要求：
共有多少种走法。
输入样例：
10
输出样例：
274
来源：
NBUOJ

1.1.2 算法思路（递推=>动态规划）

本题是动态规划的入门题，可以让同学较好的从递推的思维转向动态规划思维
动态规划五步走（重要）：

状态定义：这一步是相当重要的，定义一个合适的状态表示是解题的关键，我们假设dp[i]为走到第i级台阶的走法总数
状态转移方程：假设我们使用上一步骤的状态表示，那么我们需要思考 dp[i] 可以由哪些状态转移得到，根据题意王老师最后可以跨1步，也可以跨2步，也可以跨3步到达第i级台阶，因此可以得出状态转移方程为：dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3](其中i >= 4)
状态初始化：由于我们在i<4时直接套用该公式会造成数组越界，因此我们需要初始化dp[1]、dp[2]、dp[3]的值
填表顺序：根据我们的状态转移方程，我们发现dp[i]的值可以由前三项推出，因此填表顺序是从左往右填写的
返回值：根据题目含义我们需要输出第n级台阶的走法个数，因此我们填表完毕后需要返回的就是dp[n]

示例：我们假设输入为4进行举例：

即通俗来说，本题的递推思路就是将王老师走到第i级台阶的最后一步的步数进行分类，一共有三种情况：

case1（最后走了一步）：dp[i - 1]
case2（最后走了两步）：dp[i - 2]
case3（最后走了三步）：dp[i - 3]

1.1.3 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.1.3.1 温馨提示

由于本题的n值最大为1000，因此当n值过大时会溢出整数的表示范围（无论是Java的long类型还是C++的long long都不行），因此本题需要借助 大数相加 的模板，不过咱们Java程序员可以使用标准库提供的 BigInteger ，下面简单介绍相关常用的API

API	返回值	说明
new BigInteger(String str)	BigInteger实例	使用字符串表示的数值构造实例
BigInteger.valueOf(long num)	BigInteger实例	使用long类型表示的数值构造实例
x.add(BigInteger y)	BigInteger实例	返回x和y所表示的大数相加的结果
x.multiply(BigInteger y)	BigInteger实例	返回x和y所表示的大数相乘的结果

1.1.3.2 不带注释版本

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        BigInteger[] dp = new BigInteger[n + 1];
        dp[1] = BigInteger.valueOf(1);
        dp[2] = BigInteger.valueOf(2);
        dp[3] = BigInteger.valueOf(4);
        for (int i = 4; i <= n; i++) {
            dp[i] = dp[i - 1].add(dp[i - 2]).add(dp[i - 3]);
        }
        System.out.println(dp[n]);
    }
}

1.1.3.3 带注释版本

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        // 1. 状态定义：dp[i]表示王老师走到第i级台阶的走法数
        BigInteger[] dp = new BigInteger[n + 1];
        // 2. 状态初始化
        dp[1] = BigInteger.valueOf(1);
        dp[2] = BigInteger.valueOf(2);
        dp[3] = BigInteger.valueOf(4);
        // 3. 状态转移方程
        for (int i = 4; i <= n; i++) {
            dp[i] = dp[i - 1].add(dp[i - 2]).add(dp[i - 3]);
        }
        // 4. 返回值
        System.out.println(dp[n]);
    }
}

1.1.4 扩展题

这里放一些跟本题类似的OJ题（读者可自行尝试解题）：

LeetCode70 爬楼梯：https://leetcode.cn/problems/climbing-stairs/
LeetCode118 斐波那契数列：https://leetcode.cn/problems/pascals-triangle/

1.2 题目二：铺砖

1.2.1 题目信息

题目描述：
对于一个2行N列的走道。现在用12或22的砖去铺满。问有多少种不同的方式（请用递推方式求解）。如果N很大，需要高精度计算。下图是一个2行17列的走道的某种铺法：

输入要求：
一个整数N，N<=1000。
输出要求：
共有多少种铺法。
输入样例：
30
输出样例：
715827883
来源：
NBUOJ

1.2.2 算法思路（递归=>动态规划）

动态规划五步走（重要）：

状态定义：这一步是相当重要的，定义一个合适的状态表示是解题的关键，我们假设dp[i]表示为2行i列的砖的铺法总数
状态转移方程：假设我们使用上一步骤的状态表示，那么我们需要思考 dp[i] 可以由哪些状态转移得到，根据题意我们可以根据最后一块砖的长度为1还是为2进行区分，因此可以得出状态转移方程为：dp[i] = dp[i - 1] + 2 * dp[i - 2](其中i >= 3)
状态初始化：由于我们在i<3时直接套用该公式会造成数组越界，因此我们需要初始化dp[1]、dp[2]的值
填表顺序：根据我们的状态转移方程，我们发现dp[i]的值可以由前两项推出，因此填表顺序是从左往右填写的
返回值：根据题目含义我们需要输出长度为n的铺砖方法数，因此我们填表完毕后需要返回的就是dp[n]

示例：也许上面的文字描述有点抽象，还是以画图进行举例：

相信此图一出，大家瞬间就明白公式：dp[i] = dp[i - 1] + 2 * dp[i - 2](其中i >= 3)的由来了，其实就是根据最后一块砖的摆法划分出不同的方案

1.2.3 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.2.3.1 温馨提示

API	返回值	说明
new BigInteger(String str)	BigInteger实例	使用字符串表示的数值构造实例
BigInteger.valueOf(long num)	BigInteger实例	使用long类型表示的数值构造实例
x.add(BigInteger y)	BigInteger实例	返回x和y所表示的大数相加的结果
x.multiply(BigInteger y)	BigInteger实例	返回x和y所表示的大数相乘的结果

1.2.3.2 不带注释版本

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        BigInteger[] dp = new BigInteger[n + 1];
        dp[1] = new BigInteger("1");
        dp[2] = new BigInteger("3");
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1].add(dp[i - 2].multiply(new BigInteger("2")));
        }
        System.out.println(dp[n]);
    }
}

1.2.3.3 带注释版本

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        // 1. 状态定义：dp[i]表示2行i列的铺法数
        BigInteger[] dp = new BigInteger[n + 1];
        // 2. 状态初始化
        dp[1] = new BigInteger("1");
        dp[2] = new BigInteger("3");
        // 3. 状态转移方程
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1].add(dp[i - 2].multiply(new BigInteger("2")));
        }
        // 4. 返回值
        System.out.println(dp[n]);
    }
}

1.3 题目三：整数分割(1)

1.3.1 题目信息

题目描述：
N年M月O日CX和ZJS同学在刚学玩整数加减后，就在那里比试谁厉害。比试内容是：将一个正整数N拆成若干个正整数的和。看谁拆的多谁就赢。为了赢得比赛，CX就向你求助一个整数的所有拆分方法。
输入要求：
输入N（ 1 <= N <= 50 ）。
输出要求：
对于N的拆分方法，请以字典序排列（数字越大越排前面）。每一种拆分之间以一个空格分开。
输入样例：
7
输出样例：

来源：
NBUOJ

1.3.2 算法思路（暴力DFS深搜）

这里直接给大家介绍我的算法思路了：观察输出用例我们可以发现，数字的排列顺序就是从大到小的，因此我们可以从大到小不断添加元素（如果>=target就回溯，其中=target的时候就进行输出）这样我们就可以不重不漏的找到所有的拆分情况
算法步骤（重要）：

我们设计一个递归函数dfs(int[] numArr, int curLen, int curSum, int target, int curNum)用于查找所有的拆分情况，各个参数含义如下所示：

numArr：保存已经被拆分的数字
curLen：记录numArr的元素个数
curSum：当前numArr元素之和（即已经拆分元素之和）
target：拆分目标和
curNum：当前需要进行匹配的元素

然后从[curNum —— 1]不断从大到小尝试添加元素到拆分数组，直到所有情况都搜索完毕

1.3.3 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.3.3.1 优化点

本题如果使用Java语言是比较不容易过的，我的代码做优化的地方有如下几点：

输入输出优化：输入流将Scanner换成了BufferReader、输出流将System.out换成了PrintWriter
数据结构优化：使用List集合保存拆分元素，频繁调用add和remove方法，开销太大，因此我换用数组保存拆分元素；并且由于输入组数很多，打印频率非常高，于是我使用StringBuildler保存全部的结果，最后统一打印
函数参数优化：此时终于将时间变成了 2016ms！最后一步优化就是将StringBuilder和numArr数组从函数参数中抽离到成员变量，省去了函数调用过程中传参的开销，至此程序优化到1703ms！

1.3.3.2 不带注释版本

package week1.blog_code.exer1002;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

public class Main {
    private static int[] numArr = new int[51];
    private static StringBuilder stringBuilder = new StringBuilder();
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintStream printStream = new PrintStream(System.out);
        String line = null;
        while ((line = reader.readLine()) != null) {
            int target = Integer.parseInt(line);
            numArr = new int[51];
            stringBuilder = new StringBuilder();
            dfs(numArr, 0, 0, target, target);
            printStream.print(stringBuilder.toString());
        }

    }

    public static void dfs(int[] numArr, int curLen, int curSum, int target, int curNum) {
        if (curSum == target) {
            for (int i = 0; i < curLen - 1; i++) {
                stringBuilder.append(numArr[i] + " ");
            }
            stringBuilder.append(numArr[curLen - 1] + "\n");
            return;
        }
        for (int i = curNum; i >= 1; i--) {
            if (curSum + i <= target) {
                numArr[curLen] = i;
                dfs(numArr,curLen + 1, curSum + i, target, i);
            }
        }
    }
}

1.3.3.3 带注释版本

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

public class Main {
    private static int[] numArr = new int[51];
    private static StringBuilder stringBuilder = new StringBuilder();
    public static void main(String[] args) throws IOException {
        // 缓冲输入流（高级版平替scanner）
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        // 打印流（高级版平替System.out.print）
        PrintStream printStream = new PrintStream(System.out);
        String line = null;
        while ((line = reader.readLine()) != null) {
            int target = Integer.parseInt(line);
            numArr = new int[51];
            stringBuilder = new StringBuilder();
            dfs(numArr, 0, 0, target, target);
            printStream.print(stringBuilder.toString());
        }

    }

    /**
     * @param numArr 当前拆分元素构成的数组
     * @param curLen 当前拆分数组长度
     * @param curSum 当前拆分方法之和
     * @param target 目标和
     * @param curNum 当前遍历到的数
     */
    public static void dfs(int[] numArr, int curLen, int curSum, int target, int curNum) {
        // 出口：当前拆分和==目标和就不用继续搜索
        if (curSum == target) {
            for (int i = 0; i < curLen - 1; i++) {
                stringBuilder.append(numArr[i] + " ");
            }
            stringBuilder.append(numArr[curLen - 1] + "\n");
            return;
        }
        for (int i = curNum; i >= 1; i--) {
            if (curSum + i <= target) {
                // 将i值加入拆分数组中
                numArr[curLen] = i;
                // 继续深搜
                dfs(numArr,curLen + 1, curSum + i, target, i);
            }
        }
    }
}