package class012;

import java.util.HashMap;

public class Code01_MoneyProblem {

	public static long func1(int[] d, int[] p) {
		return process(d, p, 0, 0);
	}

	// int[] d d[i]：i号怪兽的武力
	// int[] p p[i]：i号怪兽要求的钱
	// hp 当前你所具有的能力
	// index 来到了第index个怪兽的面前

	// 目前，你的能力是hp，你来到了index号怪兽的面前，如果要通过后续所有的怪兽，
	// 请返回需要花的最少钱数
	public static long process(int[] d, int[] p, int hp, int index) {
		if (index == d.length) { // base case
			return 0;
		}
		// index < d.length 还有怪兽要面对
		if (hp < d[index]) {
			return p[index] + process(d, p, hp + d[index], index + 1);
		} else { // hp >= d[index] 可以贿赂，也可以不贿赂
			return Math.min(p[index] + process(d, p, hp + d[index], index + 1),

					process(d, p, hp, index + 1));
		}
	}

	// 正数数组 d p
	public static int dp1(int[] d, int[] p) {
		if (d == null || d.length == 0) {
			return 0;
		}

		int sum = 0;
		for (int ability : d) {
			sum += ability;
		}
		int N = d.length;

		int[][] dp = new int[N + 1][sum + 1];

		// dp[N][...] = 0;
		for (int i = N - 1; i >= 0; i--) {
			for (int j = 0; j <= sum; j++) {
				// j 能力 i 怪兽号
				if (j + d[i] > sum) {
					continue;
				}
				if (j < d[i]) {
					dp[i][j] = p[i] + dp[i + 1][j + d[i]];
				} else {
					dp[i][j] = Math.min(p[i] + dp[i + 1][j + d[i]], dp[i + 1][j]);
				}
			}
		}

		return dp[0][0];

	}

	public static long func2(int[] d, int[] p) {
		int sum = 0;
		for (int num : d) {
			sum += num;
		}
		long[][] dp = new long[d.length + 1][sum + 1];
		for (int i = 0; i <= sum; i++) {
			dp[0][i] = 0;
		}
		for (int cur = d.length - 1; cur >= 0; cur--) {
			for (int hp = 0; hp <= sum; hp++) {
				// 如果这种情况发生，那么这个hp必然是递归过程中不会出现的状态
				// 既然动态规划是尝试过程的优化，尝试过程碰不到的状态，不必计算
				if (hp + d[cur] > sum) {
					continue;
				}
				if (hp < d[cur]) {
					dp[cur][hp] = p[cur] + dp[cur + 1][hp + d[cur]];
				} else {
					dp[cur][hp] = Math.min(p[cur] + dp[cur + 1][hp + d[cur]], dp[cur + 1][hp]);
				}
			}
		}
		return dp[0][0];
	}
	
	
	
	public static long func1dp(int[] d, int[] p) {
		HashMap<String,Long> dp = new HashMap<>();
		return processdp(d, p, 0, 0, dp);
	}

	// int[] d d[i]：i号怪兽的武力
	// int[] p p[i]：i号怪兽要求的钱
	// hp 当前你所具有的能力
	// index 来到了第index个怪兽的面前

	// 目前，你的能力是hp，你来到了index号怪兽的面前，如果要通过后续所有的怪兽，
	// 请返回需要花的最少钱数
	public static long processdp(int[] d, int[] p, int hp, int index,HashMap<String,Long> dp) {
		String key = String.valueOf(hp) + "_" + String.valueOf(index);
		if(dp.containsKey(key)) {
			return dp.get(key);
		}
		long ans = 0;
		if(index < d.length) {
			if (hp < d[index]) {
				ans = p[index] + process(d, p, hp + d[index], index + 1);
			} else { // hp >= d[index] 可以贿赂，也可以不贿赂
				ans = Math.min(p[index] + process(d, p, hp + d[index], index + 1),

						process(d, p, hp, index + 1));
			}
		}
		dp.put(key, ans);
		return ans;

	}
	

	public static long func3(int[] d, int[] p) {
		int sum = 0;
		for (int num : p) {
			sum += num;
		}
		// dp[i][j]含义：
		// 能经过0～i的怪兽，且花钱为j（花钱的严格等于j）时的武力值最大是多少？
		// 如果dp[i][j]==-1，表示经过0～i的怪兽，花钱为j是无法通过的，或者之前的钱怎么组合也得不到正好为j的钱数
		int[][] dp = new int[d.length][sum + 1];
		for (int i = 0; i < dp.length; i++) {
			for (int j = 0; j <= sum; j++) {
				dp[i][j] = -1;
			}
		}
		// 经过0～i的怪兽，花钱数一定为p[0]，达到武力值d[0]的地步。其他第0行的状态一律是无效的
		dp[0][p[0]] = d[0];
		for (int i = 1; i < d.length; i++) {
			for (int j = 0; j <= sum; j++) {
				// 可能性一，为当前怪兽花钱
				// 存在条件：
				// j - p[i]要不越界，并且在钱数为j - p[i]时，要能通过0～i-1的怪兽，并且钱数组合是有效的。
				if (j >= p[i] && dp[i - 1][j - p[i]] != -1) {
					dp[i][j] = dp[i - 1][j - p[i]] + d[i];
				}
				// 可能性二，不为当前怪兽花钱
				// 存在条件：
				// 0~i-1怪兽在花钱为j的情况下，能保证通过当前i位置的怪兽
				if (dp[i - 1][j] >= d[i]) {
					// 两种可能性中，选武力值最大的
					dp[i][j] = Math.max(dp[i][j], dp[i - 1][j]);
				}
			}
		}
		int ans = 0;
		// dp表最后一行上，dp[N-1][j]代表：
		// 能经过0～N-1的怪兽，且花钱为j（花钱的严格等于j）时的武力值最大是多少？
		// 那么最后一行上，最左侧的不为-1的列数(j)，就是答案
		for (int j = 0; j <= sum; j++) {
			if (dp[d.length - 1][j] != -1) {
				ans = j;
				break;
			}
		}
		return ans;
	}

	public static int[][] generateTwoRandomArray(int len, int value) {
		int size = (int) (Math.random() * len) + 1;
		int[][] arrs = new int[2][size];
		for (int i = 0; i < size; i++) {
			arrs[0][i] = (int) (Math.random() * value) + 1;
			arrs[1][i] = (int) (Math.random() * value) + 1;
		}
		return arrs;
	}

	public static void main(String[] args) {
		int len = 10;
		int value = 20;
		int testTimes = 1000000;
		for (int i = 0; i < testTimes; i++) {
			int[][] arrs = generateTwoRandomArray(len, value);
			int[] d = arrs[0];
			int[] p = arrs[1];
			long ans1 = func1(d, p);
			long ans2 = func2(d, p);
			long ans3 = func3(d, p);
			if (ans1 != ans2 || ans2 != ans3) {
				System.out.println("oops!");
			}
		}

	}

}