暴力递归到动态规划

package com.atguigu;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;


public class Main {

    public static StringBuilder sb = new StringBuilder();
    public static HashMap<Integer, Integer> map;
    public static int mod = (int) 1e9 + 7;

    // 1.暴力递归
    public static int cois1(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        return processes1(arr,0,aim);
    }

    public static int processes1(int[] arr, int index, int aim) {
        int res = 0;
        if (index == arr.length) {
            res = aim == 0 ? 1 : 0;
        } else {
            for (int i = 0; arr[index] * i <= aim; i++) {
                res += processes1(arr,index + 1,aim - arr[index] * i);
            }
        }
        return res;
    }

    // 记忆搜索，暴力递归的初步优化方法
    public static int coins2(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        int[][] map = new int[arr.length + 1][aim + 1];
        return processes2(arr,0,aim,map);
    }

    public static int processes2(int[] arr, int index, int aim, int[][] map) {
        int res = 0;
        if (index == arr.length) {
            res = aim == 0 ? 1 : 0;
        } else {
            int mapValue = 0;
            for (int i = 0; arr[index] * i <= aim; i++) {
                mapValue = map[index + 1][aim - arr[index] * i];
                if (mapValue != 0) {
                    res = (res + (mapValue == -1 ? 0 : mapValue)) % mod;
                } else {
                    res = (res + processes2(arr,index + 1,aim - arr[index] * i, map)) % mod;
                }
            }
        }
        map[index][aim] = res == 0 ? -1 : res;
        return res;
    }

    // 动态规划
    public static int coins3(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        int[][] dp = new int[arr.length][aim + 1];
        for (int i = 0; i < arr.length; i++) {
            dp[i][0] = 1;
        }
        for (int j = 1; arr[0] * j <= aim; j++) {
            dp[0][arr[0] * j] = 1;
        }
        int num = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j <= aim; j++) {
                num = 0;
                for (int k = 0; j - arr[i] * k >= 0; k++) {
                    num = (num + dp[i - 1][j - arr[i] * k]) % mod;
                }
                dp[i][j] = num;
            }

        }
        return dp[arr.length - 1][aim];
    }

    // 动态规划优化
    public static int coins4(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        int[][] dp = new int[arr.length][aim + 1];
        for (int i = 0; i < arr.length; i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; arr[0] * i <= aim; i++) {
            dp[0][arr[0] * i] = 1;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j <= aim; j++) {
                dp[i][j] = dp[i - 1][j];
                dp[i][j] = (dp[i][j] + (j - arr[i] >= 0 ? dp[i][j - arr[i]] : 0)) % mod;
            }
        }
        return dp[arr.length - 1][aim];
    }

    // 动态规划 + 空间压缩
    public static int coins5(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        int[] dp = new int[aim + 1];
        for (int i = 0; arr[0] * i <= aim; i++) {
            dp[arr[0] * i] = 1;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j <= aim; j++) {
                dp[j] = (dp[j] + (j - arr[i] >= 0 ? dp[j - arr[i]] : 0)) % mod;
            }
        }
        return dp[aim];
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] line = br.readLine().split(" ");
        int m = Integer.parseInt(line[0]);
        int aim= Integer.parseInt(line[1]);
        int[] arr = new int[m];
        line = br.readLine().split(" ");
        for (int i = 0; i < m; i++) {
            arr[i] = Integer.parseInt(line[i]);
        }
        int num = coins5(arr, aim);
        System.out.println(num);
    }
}

暴力递归通用优化过程。对于在面试中遇到具体题目，面试者一旦想到暴力递归的过程，其实之后的优化过程是水到渠成的。首先看写出来的暴力递归函数，找到有哪些参数是不发生变化的，忽略这些变量。只看那些变化并且可以表示递归过程的参数，找出这些参数之后，记忆搜索其实可以很轻易地写出来，因为只是简单地修改，计算完就记录到map中，并在下次直接拿来使用，没计算过则依然进行递归计算。接下来观察记忆搜索过程中使用地map结构，看看该结构某一个具体位置地值是通过哪些位置地值求出来地，被依赖地位置先求，就能改出动态规划的方法。改出的动态规划方法中，如果有枚举的过程，看看枚举过程是否可以继续优化，常规的方法既有本题所实现的通过表达式来简化枚举状态的方式，也有“丢棋子问题”、“画匠问题”和“邮局选址问题”所涉及的四边形不等式的相关内容，有兴趣的读者可以进一步学习。