算法31：针对算法30货币问题进行拓展 + 时间复杂度 + 空间复杂度优化--------从左往右尝试模型

适合java程序员的算法

已于 2024-02-20 11:25:25 修改

阅读量1k

点赞数 16

分类专栏：算法数据结构文章标签：算法

于 2024-01-04 17:26:05 首次发布

本文链接：https://blog.csdn.net/chen_yao_kerr/article/details/135381741

版权

算法同时被 2 个专栏收录

55 篇文章 1 订阅

订阅专栏

数据结构

37 篇文章 0 订阅

订阅专栏

在算法30中，我们说过从左往右尝试模型，口诀就是针对固定集合：张数固定，值不同，就是讨论要和不要的累加和。

那么对于非固定集合，我们应该怎么做呢？

针对非固定集合：张数无限，面值固定且值不同。口诀就是讨论要与不要，要的话逐步讨论要几张的累加和

题目:

* arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。

* 每个值都认为是一种面值，且认为张数是无限的。

* 返回组成aim的方法数

分析：

* 例如：arr = {1,2}，aim = 4

* 方法如下：1+1+1+1、1+1+2、2+2 * 一共就3种方法，所以返回3

递归写法：

 //递归版本
    public static int ways(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        return process(arr, 0, aim);
    }

    public static int process (int[] arr, int index, int aim)
    {
        if (index == arr.length) { // 没钱了
            return aim == 0 ? 1 : 0;
        }

        //讨论不同货币组成aim的可能
        int ways = 0;
        //因为货币张数无限，所有需要讨论每一种情况。此次，就不是简单的要与不要的问题了
        for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {
            /**
             * 此处，还是讨论要与不要的问题。
             * 0张代表不要
             * 要的话需要讨论要几张 :
             * 要1 张， 那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
             * 要2 张，那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
             *  依次类推
             */
            ways += process(arr, index + 1, aim - zhangshu * arr[index]);
        }
        return ways;
    }

动态规划

1. 套路还是老样子。以数组为横坐标，以aim为纵坐标。并且行与列都新增1个。

2. 根据递归

if (index == arr.length) { // 没钱了
    return aim == 0 ? 1 : 0;
}

可以推导出最后一行的第一列为1，其余全部为0.

	aim 0	aim 1	aim 2	aim 3	aim 4
index 0 (1)
index 1 (2)
index 2	1	0	0	0	0

3. 根据递归：

int ways = 0;
//因为货币张数无限，所有需要讨论每一种情况。此次，就不是简单的要与不要的问题了
for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {
    /**
     * 此处，还是讨论要与不要的问题。
     * 0张代表不要
     * 要的话需要讨论要几张 :
     * 要1 张， 那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
     * 要2 张，那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
     *  依次类推
     */
    ways += process(arr, index + 1, aim - zhangshu * arr[index]);
}

可以得到：

1. zhangshu * arr[index] <= aim必须成立，否则不做推导；直接返回0

2. 如果zhangshu * arr[index] <= aim成立，那么当前行当前列的值依赖于下一行的aim - zhangshu * arr[index]列。

	aim= 0	aim= 1	aim= 2	aim= 3	aim= 4
index 0 (1)
index 1 (2)	aim - zhangshu * arr[index] = 0 - 张数 2；讨论：* 面值为2：张数为0，则计算值为0 dp[1][0] = dp[2][0] = 1; 即只存在1种解法。	讨论：张数为0 dp[1][1] = dp[2][1] = 0 张数为1 可得 1 - 2 < 0;取值0 0+0=0,最终取值0	讨论张数0 dp[1][2] = dp[2][2] = 0; 张数为1，可得 2 - 2 =0; 可得dp[1][2] = dp[2][0] = 1; 张数为2，可得 2 - 2*2 <0;直接取0；即1种解法，即0+1+0=1	讨论1：张数为0 dp[1][3] ]= dp[2][3] = 0; 张数为1，可得 3 - 2 =1; 可得: dp[1][3] = dp[2][1] = 0; 张数为2。可得3 - 22 < 0取值0；张数为3. 即3-32<0,直接取0 0+0+0+0=0,最终取值0	张数为0， dp[1][4] = dp[2][4] = 0; 张数为1，可得 4 - 2 =2; dp[1][4] = dp[2][2] = 0; 张数为2. 可得4 - 22 = 0. dp[1][4] = dp[2][0] = 1; 张数为3：* 4-32 < 0;直接取0 张数为4，4-42 < 0;直接取0 0+0+1+0+0=1 最终可得1种解法。
index 2	1	0	0	0	0

接着，我们推导出第一行的数据：

	aim= 0	aim= 1	aim= 2	aim= 3	aim= 4
index 0 (1)	面值为1 张数为0，dp[0][0] = dp[1][0] = 1;	面值为1 张数为0，dp[0][1] = dp[1][1] = 0; 张数为1： dp[0][1]=dp[1][0] = 1; 累计1种	张数为0： dp[0][2] = dp[1][2] = 1; 张数为1： dp[0][2] = dp[1][1] = 0; 累计1种	张数为0： dp[0][3] = dp[1][3] = 0; 张数为1： dp[0][3] = dp[1][2] = 1; 张数为2： dp[0][3] = dp[1][1] = 0; 累计1种	张数为0; dp[0][4]=[1][4-0] = dp[1][4] = 1 张数为1： dp[0][4] = dp[1][4-11] = dp[1][3] = 0; 张数为2：* dp[0][4] = dp[1][4-21] = dp[1][2] = 1; 张数为3：* dp[0][4] = dp[1][4-31] = dp[1][1] = 0; 张数为4：* dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1; 累计1+1+1=3；
index 1 (2)	aim - zhangshu * arr[index] = 0 - 张数 2；讨论：* 面值为2：张数为0，则计算值为0 dp[1][0] = dp[2][0] = 1; 即只存在1种解法。	讨论：张数为0 dp[1][1] = dp[2][1] = 0 张数为1 可得 1 - 2 < 0;取值0 0+0=0,最终取值0	讨论张数0 dp[1][2] = dp[2][2] = 0; 张数为1，可得 2 - 2 =0; 可得dp[1][2] = dp[2][0] = 1; 张数为2，可得 2 - 2*2 <0;直接取0；即1种解法，即0+1+0=1	讨论1：张数为0 dp[1][3] ]= dp[2][3] = 0; 张数为1，可得 3 - 2 =1; 可得: dp[1][3] = dp[2][1] = 0; 张数为2。可得3 - 22 < 0取值0；张数为3.* 即3-3*2<0,直接取0 0+0+0+0=0,最终取值0	张数为0， dp[1][4] = dp[2][4] = 0; 张数为1，可得 4 - 2 =2; dp[1][4] = dp[2][2] = 0; 张数为2. 可得4 - 22 = 0. dp[1][4] = dp[2][0] = 1; 张数为3：* 4-32 < 0;直接取0 张数为4，4-42 < 0;直接取0 0+0+1+0+0=1 最终可得1种解法。
index 2	1	0	0	0	0

最终需要的是第一行最后一列数据：

1. aim为4，面值为1的一张都没有。可得dp[0][4]=[1][4-0] = dp[1][4] = 1

2. aim 为4，面值为1的只有一张。可得 dp[0][4] = dp[1][4-1*1] = dp[1][3] = 0;

3. aim 为4，面值为1的只有两张。可得 dp[0][4] = dp[1][4-2*1] = dp[1][2] = 1;

4. aim 为4，面值为1的只有三张。可得 dp[0][4] = dp[1][4-3*1] = dp[1][1] = 0;

5. aim 为4，面值为1的只有四张。可得 dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1;

累计可得1+1+1 = 3, 即3种方法。

  //动态规划
    public static int ways2(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[][] dp = new int[N + 1][aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[N][0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim

                //此处是比较复杂的，完全套用递归内部的代码。这一层的for循环就是对
                //要的张数进行讨论。
                int ways = 0;
                //此处zhangshu * arr[row] <= col是唯一变化。重点理解
                for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++) {
                    /**
                     * 此处，还是讨论要与不要的问题。
                     * 0张代表不要
                     * 要的话需要讨论要几张 :
                     * 要1 张， 那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
                     * 要2 张，那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
                     *  依次类推
                     */
                    //根据ways += process(arr, row + 1, aim - zhangshu * arr[row]);推导
                    //此处的aim - zhangshu * arr[index] 需要变成 col - zhangshu * arr[index]
                    ways += dp[row + 1][col - (zhangshu * arr[row])];
                }
                dp[row][col] = ways;
            }
        }
        return dp[0][aim];
    }

那么如何进行时间复杂度优化呢？继续观察二维数组：

	aim= 0	aim= 1	aim= 2	aim= 3	aim= 4
index 0 (1)	面值为1 张数为0，dp[0][0] = dp[1][0] = 1;	面值为1 张数为0，dp[0][1] = dp[1][1] = 0; 张数为1： dp[0][1]=dp[1][0] = 1; 累计1种	张数为0： dp[0][2] = dp[1][2] = 1; 张数为1： dp[0][2] = dp[1][1] = 0; 累计1种	张数为0： dp[0][3] = dp[1][3] = 0; 张数为1： dp[0][3] = dp[1][2] = 1; 张数为2： dp[0][3] = dp[1][1] = 0; 累计1种	张数为0; dp[0][4]=[1][4-0] = dp[1][4] = 1 张数为1： dp[0][4] = dp[1][4-11] = dp[1][3] = 0; 张数为2：* dp[0][4] = dp[1][4-21] = dp[1][2] = 1; 张数为3：* dp[0][4] = dp[1][4-31] = dp[1][1] = 0; 张数为4：* dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1; 累计1+1+1=3；
index 1 (2)	aim - zhangshu * arr[index] = 0 - 张数 2；讨论：* 面值为2：张数为0，则计算值为0 dp[1][0] = dp[2][0] = 1; 即只存在1种解法。	讨论：张数为0 dp[1][1] = dp[2][1] = 0 张数为1 可得 1 - 2 < 0;取值0 0+0=0,最终取值0	讨论张数0 dp[1][2] = dp[2][2] = 0; 张数为1，可得 2 - 2 =0; 可得dp[1][2] = dp[2][0] = 1; 张数为2，可得 2 - 2*2 <0;直接取0；即1种解法，即0+1+0=1	讨论1：张数为0 dp[1][3] ]= dp[2][3] = 0; 张数为1，可得 3 - 2 =1; 可得: dp[1][3] = dp[2][1] = 0; 张数为2。可得3 - 22 < 0取值0；张数为3.* 即3-3*2<0,直接取0 0+0+0+0=0,最终取值0	张数为0， dp[1][4] = dp[2][4] = 0; 张数为1，可得 4 - 2 =2; dp[1][4] = dp[2][2] = 0; 张数为2. 可得4 - 22 = 0. dp[1][4] = dp[2][0] = 1; 张数为3：* 4-32 < 0;直接取0 张数为4，4-42 < 0;直接取0 0+0+1+0+0=1 最终可得1种解法。
index 2	1	0	0	0	0

1. 任何一行的每一列，当张数为0的时候，都是直接依赖下一行的当前列的值。也就是说这个值一定是依赖下一行的当前列的值。

2. col是aim的值，当 zhangshu * arr[row] <= col 的时候，我们是依赖 dp[row + 1][col - (zhangshu * arr[row])]的值的。这一点是非常非常重要的。由此我们可以推导出；

0张，我们依赖y1处的值

1张，依赖y2处的值。

2张，依赖y3处的值

3张，依赖y4处的值

4张，依赖y5处的值

5张，依赖y6处的值

那 x 不就是 y1 + y2 + y3 + y4 + y5 + y6 吗？

x1 不就是 y2 + y3 + y4 + y5 +y6 吗？

状态转移可得。 x = x1 + y1.

根据以上推导，我们是不是可以直接转化成完整的表格，即

既然我们知道

x = x1 + y1; 假设x处的列下标col为15. 那么x1处的小标不就是 col - value. 此处的value不就是一维数组中的arr[index]的值，即为3。那么x1处的下标不就是 15 - 3 = 12吗？

for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++)；循环是每次枚举下一行的值的。既然下一行的值已经存储在 x1 x2 x3 .......处，那我们还要这个for循环干嘛呢？

时间复杂度优化代码如下：

 //动态规划 针对时间复杂度的优化版
    public static int ways3(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[][] dp = new int[N + 1][aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[N][0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim

                // 每一列都存在aim为0张的情况，
                // 下一行的当前列
                dp[row][col] = dp[row + 1][col];

                //当前下标col, 那么前一处的下标不就是 col - arr[row] 吗 ？
                if (col - arr[row] >= 0) {
                    /**
                     * for循环中的 下一行的 dp[row + 1][col - (zhangshu * arr[row])]列
                     *
                     * 直接转化为当前行的 前 col - arr[row] 列。
                     */
                    dp[row][col] += dp[row][col - arr[row]];
                }
            }
        }
        return dp[0][aim];
    }

以上代码已经对时间复杂度进行了优化，下面按照空间压缩的思维，对空间复杂度再进行优化。

在算法28 算法28：力扣64题，最小路径和------------样本模型-CSDN博客 和算法29 算法29：不同路径问题（力扣62和63题）--针对算法28进行扩展-CSDN博客中，我已经详细的分析过空间压缩的技巧以及思维。下面直接上代码

空间压缩代码

//动态规划 针对空间复杂度的优化版
    public static int ways4(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[] dp = new int[aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim
                if (col - arr[row] >= 0) {
                    dp[col] += dp[col - arr[row]];
                }
            }
        }
        return dp[aim];
    }

从递归到动态规划，再对动态规划代码进行时间复杂度和空间复杂度进行双重优化。本文重点介绍了从左往右模型的技巧、动态规划的推理、时间复杂度的优化。至于空间复杂度，由于前面2篇博客已经重点分析了，所有没有过多累赘叙述。

从左往右模型总结：

1、 针对固定集合，值不同，就是讨论要和不要的累加和。

2. 针对非固定集合，面值固定，张数无限。口诀就是讨论要与不要，要的话逐步讨论要几张的累加和

下面贴出完整代码，并加入对数器进行海量数据测试：

package code03.动态规划_07.lesson4;

/**
 * arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。
 * 每个值都认为是一种面值，且认为张数是无限的。
 * 返回组成aim的方法数
 * 例如：arr = {1,2}，aim = 4
 * 方法如下：1+1+1+1、1+1+2、2+2
 * 一共就3种方法，所以返回3
 */
public class ContainWaysNotLimitPaper_05 {

    //递归版本
    public static int ways(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        return process(arr, 0, aim);
    }

    public static int process (int[] arr, int index, int aim)
    {
        if (index == arr.length) { // 没钱了
            return aim == 0 ? 1 : 0;
        }

        //讨论不同货币组成aim的可能
        int ways = 0;
        //因为货币张数无限，所有需要讨论每一种情况。此次，就不是简单的要与不要的问题了
        for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {
            /**
             * 此处，还是讨论要与不要的问题。
             * 0张代表不要
             * 要的话需要讨论要几张 :
             * 要1 张， 那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
             * 要2 张，那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
             *  依次类推
             */
            ways += process(arr, index + 1, aim - zhangshu * arr[index]);
        }
        return ways;
    }

    //动态规划
    public static int ways2(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[][] dp = new int[N + 1][aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[N][0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim

                //此处是比较复杂的，完全套用递归内部的代码。这一层的for循环就是对
                //要的张数进行讨论。
                int ways = 0;
                //此处zhangshu * arr[row] <= col是唯一变化。重点理解
                for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++) {
                    /**
                     * 此处，还是讨论要与不要的问题。
                     * 0张代表不要
                     * 要的话需要讨论要几张 :
                     * 要1 张， 那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
                     * 要2 张，那么后面的数组需要进行递归继续讨论要还是不要，要的话要几张
                     *  依次类推
                     */
                    //根据ways += process(arr, row + 1, aim - zhangshu * arr[row]);推导
                    //此处的aim - zhangshu * arr[index] 需要变成 col - zhangshu * arr[index]
                    ways += dp[row + 1][col - (zhangshu * arr[row])];
                }
                dp[row][col] = ways;
            }
        }
        return dp[0][aim];
    }

    //动态规划 针对时间复杂度的优化版
    public static int ways3(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[][] dp = new int[N + 1][aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[N][0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim

                // 每一列都存在aim为0张的情况，
                // 下一行的当前列
                dp[row][col] = dp[row + 1][col];

                //当前下标col, 那么前一处的下标不就是 col - arr[row] 吗 ？
                if (col - arr[row] >= 0) {
                    /**
                     * for循环中的 下一行的 dp[row + 1][col - (zhangshu * arr[row])]列
                     *
                     * 直接转化为当前行的 前 col - arr[row] 列。
                     */
                    dp[row][col] += dp[row][col - arr[row]];
                }
            }
        }
        return dp[0][aim];
    }

    //动态规划 针对空间复杂度的优化版
    public static int ways4(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }

        //老样子
        int N = arr.length;
        int[] dp = new int[aim + 1];
        //最后一行的第一列为1，其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到
        dp[0] = 1;

        //双层for循环，动态规划的老套路。一维数组arr作为横坐标，aim作为纵坐标
        for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 index
            for (int col = 0; col <= aim; col++) {   //col代表递归中的 aim
                if (col - arr[row] >= 0) {
                    dp[col] += dp[col - arr[row]];
                }
            }
        }
        return dp[aim];
    }

    // 为了测试
    public static int[] randomArray(int maxLen, int maxValue) {
        int N = (int) (Math.random() * maxLen);
        int[] arr = new int[N];
        boolean[] has = new boolean[maxValue + 1];
        for (int i = 0; i < N; i++) {
            do {
                arr[i] = (int) (Math.random() * maxValue) + 1;
            } while (has[arr[i]]);
            has[arr[i]] = true;
        }
        return arr;
    }

    // 为了测试
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
     /*   int[] arr = {1,2,3};
        int aim = 13;
        System.out.println(ways(arr, aim));
        System.out.println(ways2(arr, aim));
        System.out.println(ways3(arr, aim));
        System.out.println(ways4(arr, aim));*/

        // 为了测试

            int maxLen = 10;
            int maxValue = 30;
            int testTime = 1000000;
            System.out.println("测试开始");
            for (int i = 0; i < testTime; i++) {
                int[] arr = randomArray(maxLen, maxValue);
                int aim = (int) (Math.random() * maxValue);
                int ans1 = ways(arr, aim);
                int ans2 = ways2(arr, aim);
                int ans3 = ways3(arr, aim);
                int ans4 = ways4(arr, aim);
                if (ans1 != ans2 || ans1 != ans3 || ans1 != ans4) {
                    System.out.println("Oops!");
                    printArray(arr);
                    System.out.println(aim);
                    System.out.println(ans1);
                    System.out.println(ans2);
                    System.out.println(ans3);
                    break;
                }
            }
            System.out.println("测试结束");

    }
}