动态规划算法

描述: 动态规划算法

 能用动归算法解决的问题，都有两个基本的要素
 1.最优子结构
 2.子问题划分有重叠
 


   动态规划解决问题，主要找出两样东西：
      1.“状态” dp[i] : 组成价值i所需要的最少的硬币的数量
      2.状态转移方程
     
      有面值1，3，5分的三种硬币，现在给出一个价值C，
      问组成价值C最少需要几枚硬币?  

public class Corn {
    public static void main(String[] args) {
        int[] arr = {1,3,5};
        int c = 15;
        int[] dp = new int[c+1];
        Arrays.fill(dp, -1);
        int num = func(arr, c, dp);
        System.out.println("num:" + num);
        System.out.println("number:" + number);
    }

    /**
     * arr数组放的是硬币, C是指定的价值，返回价值C最少需要的硬币的数量
     * @param arr
     * @param c
     * @param dp
     */
    static int number = 0;
    private static int func(int[] arr, int c, int[] dp) {

        if(dp[c] != -1){
            return dp[c];
        }

        number++;

        if(c == 0){
            dp[c] = 0;
            return 0;
        }

        if(c == 1 || c == 3 || c == 5){
            dp[c] = 1;
            return 1;
        }

        if(c < 3){
            dp[c] = 1 + func(arr, c-1, dp);
        } else if(c < 5){
            int n1 = 1 + func(arr, c-1, dp);
            int n2 = 1 + func(arr, c-3, dp);
            dp[c] = Math.min(n1, n2);
        } else {
            int n1 = 1 + func(arr, c - 1, dp);
            int n2 = 1 + func(arr, c - 3, dp);
            int n3 = 1 + func(arr, c - 5, dp);
            dp[c] = Math.min(Math.min(n1, n2), n3);
        }
        return dp[c];
    }
}