凑零钱-钱币的组合有多少种II(java)

钱币的组合有多少种II

arr是货币数组，其中的值都是正数。
再给定一个正数aim。
每个值都认为是一张货币，
认为值相同的货币没有任何不同，
返回组成aim的方法数
例如：arr = {1,2,1,1,2,1,2}，
aim = 4 方法：1+1+1+1、1+1+2、2+2
一共就3种方法，所以返回3

暴力递归

我们这里需要先把每种面值的钱币和数量分开，形成对应关系，
递归时才能去递归每种钱币被选择的次数。
base case ,aim == 0 时 说明当前组合有效，返回1.
钱币数组走完时，没有选择时，aim == 0 说明前面选择有效，返回1，反之0；

代码演示

     * 钱币面值和数量的对应关系
     */
    public class Info{
        //钱币种类
        int[]coins;
        //数量
        int[]nums;

        public Info(int[] coins, int[] nums) {
            this.coins = coins;
            this.nums = nums;
        }
    }

	 /**
     * 把钱币和数量分开  形成一一对应的关系
     * @param arr
     * @return
     */
    public static Info getInfo(int[]arr){
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int a : arr){
            if (!map.containsKey(a)){
                map.put(a,1);
            }else{
                map.put(a,map.get(a)  + 1);
            }
        }
        int N = map.size();
        int[] coins = new int[N];
        int[] nums = new int[N];
        int index = 0;
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            coins[index] = entry.getKey();
            nums[index++] = entry.getValue();
        }
        return new Info(coins,nums);
    }

递归代码

    /**
     * 计算有多少种方式。
     * @param arr
     * @param aim
     * @return
     */
    public static int coinsWay(int[] arr, int aim) {
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        Info info = getInfo(arr);
        return process(info.coins,info.nums,0,aim);
    }

    /**
     * 暴力递归
     * @param coins 钱币数组
     * @param nums 钱币的数量 和钱币一一对应
     * @param index 数组下标
     * @param aim 要组成的钱币
     * @return
     */
    public static int process(int[]coins,int[]nums,int index,int aim){
        //base case aim == 0 前面组合有效，返回1
        if(aim == 0){
            return 1;
        }
        //没有钱币可以选择时 aim == 0  返回1 否则返回0
        if (index == coins.length){
            return aim == 0 ? 1 : 0;
        }
        int ans = 0;
        //每种钱币从0张选择到小于aim 之间都去递归
        for (int i = 0;coins[index] * i <= aim && i <= nums[index];i++){
            ans += process(coins,nums,index + 1,aim - (coins[index] * i));
        }
        return ans;
    }

动态规划

动态规划就是对递归流程的改写，还是固定套路。
三个步骤，
1.根据base case 去初始化动态规划表
2.递归规程改成从表中取数据的过程
3.返回递归调用的最初始化状态。

代码演示

    /**
     * 动态规划
     * @param arr
     * @param aim
     * @return
     */
    public static int dp(int[] arr, int aim){
        if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        Info info = getInfo(arr);
        int[] coins = info.coins;
        int[] nums = info.nums;
        int N = coins.length;
        //动态规划表
        int[][] dp = new int[N + 1][aim + 1];
        //根据base case 初始化
        dp[N][0] = 1;
        //递归过程改写
         for (int i = N - 1;i >= 0;i--){
            for (int j = 0;j <= aim;j++){
                int ans = 0;
                for (int k = 0;k <= nums[i] && coins[i] * k <= j;k++){
                    ans += dp[i + 1][j - (coins[i] * k)];
                }
                dp[i][j] = ans;
            }
        }
        //返回递归调用的初始状态。
        return dp[0][aim];
    }

动态规划专题

leetcode–N 皇后 II

背包问题–填满背包的最大价格

数字转字符串,有多少种转化结果

leetcode1143. 最长公共子序列

最长回文子序列

象棋里马走到指定位置的方法数