硬币问题（贪心）

动态规划和贪心算法都是一种递推的方法，当存在最优子结构的时候，用动态规划，贪心是动态规划的特例

 注意：那么当存在最的时候就要想到贪心和动态规划

1.深度优先剪枝策略 

分析 ：先按大的选，有结果就输出，没结果就倒退，选到出最佳方案后就就退出（剪枝）

import java.util.Scanner;

public class Main {
	public static int a[] = new int[6];
	public static int b[] = { 1, 5, 10, 50, 100, 500};
	public static int A;
	public static int count = 0;
	public static int flag = 0;

	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		for(int i = 0; i < 6; i ++) {
			a[i] = sca.nextInt();
		}
		A = sca.nextInt();
	        long start = System.currentTimeMillis();
		Todo(5);
		long end = System.currentTimeMillis();
                System.out.println("spend time :" + (end - start) + "ms!");
		

	}

	private static void Todo(int cur) {
		//跳出递归
		if(A <= 0 || cur == -1) {
			if(A == 0) {
				flag = 1;
				System.out.println(count);
			}
			return;
		}
		//当找到最优解就跳出循环，实现剪枝的效果
		if(flag == 1) {
			return;
		}
		
		//下一跳	
	 
			int t = A / b[cur];
			t = min(t,a[cur]);
			for(int i = t; i >= 0; i --) {
				A -= i * b[cur];
				count += i;
				Todo(cur - 1);
				//回溯
				count -= i;
				A += i * b[cur];
			}
			
		 
	}

	private static int min(int t, int i) {
		if(t < i) {
			return t;
		}		
		return i;
	}

}

输出结果：

3 2 1 3 0 2
620 
6
spend time :1ms!

 

2.优化方案（贪心策略）

注意：

1. 因为不存在倒退的情况（能用500就尽管用），所以，就可以直接用贪心的方法，而不用深搜回溯
2. 题目已经声明，至少存在一种支付方案，那么最后的1元零钱一定可以付完最后所差的，所以可用

         if(cur == 0) {
            return n;
        }

import java.util.Scanner;

public class Main {
	public static int a[] = new int[6];
	public static int b[] = { 1, 5, 10, 50, 100, 500};
	public static int A;
 
	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		for(int i = 0; i < 6; i ++) {
			a[i] = sca.nextInt();
		}
		A = sca.nextInt();
		long start = System.currentTimeMillis();
		System.out.println(Todo(A,5));
		long end = System.currentTimeMillis();
        System.out.println("spend time :" + (end - start) + "ms!");

	}

	private static int Todo(int n,int cur) {
		//跳出递归
		if(A == 0) {
			return 0;
		}
        if(cur == 0) {
        	return n;
        }
        
		int t = n / b[cur];
		t = min(t,a[cur]);
		//计算上一阶段	后来返回本次结束的硬币个数
  
		return t + Todo(n - t * b[cur],cur - 1);
		 
	}

	private static int min(int t, int i) {
		if(t < i) {
			return t;
		}		
		return i;
	}

}

运行结果：

3 2 1 3 0 2
620 
6
spend time :0ms!

可见在这里贪心策略的高效性比深搜要好