16. 贪心（Greedy）+分治（Divide And Conquer）

1 贪心

1. 贪心策略，也称为贪婪策略，每一步都采取当前状态下最优的选择（局部最优解），从而希望推导出全局最优解
2. 贪心策略并不一定能得到全局最优解
   1. 因为一般没有测试所有可能的解，容易过早做决定，所以没法达到最佳解
   2. 贪图眼前局部的利益最大化，看不到长远未来，走一步看一步
3. 优点：简单、高效、不需要穷举所有可能，通常作为其他算法的辅助算法来使用
4. 缺点：鼠目寸光，不从整体上考虑其他可能，每次采取局部最优解，不会再回溯，因此很少情况会得到最优解
5. 贪心的应用
   1. 哈夫曼树
   2. 最小生成树算法：Prim、Kruskal
   3. 最短路径算法：Dijkstra

1.1 练习1 – 最优装载问题（加勒比海盗）

1. 在北美洲东南部，有一片神秘的海域，是海盗最活跃的加勒比海
   1. 有一天，海盗们截获了一艘装满各种各样古董的货船，每一件古董都价值连城，一旦打碎就失去了它的价值。
   2. 海盗船的载重量为 W，每件古董的重量为 𝑥 i ，海盗们该如何把尽可能多数量的古董装上海盗船
   3. 比如 W 为 30，𝑥 i 分别为 3、5、4、10、7、14、2、11
2. 贪心策略：每一次都优先选择重量最小的古董
   1. 选择重量为 2 的古董，剩重量 28
   2. 选择重量为 3 的古董，剩重量 25
   3. 选择重量为 4 的古董，剩重量 21
   4. 选择重量为 5 的古董，剩重量 16
   5. 选择重量为 7 的古董，剩重量 9
   6. 最多能装载 5 个古董
3. Pirate

package com.mj;

import java.util.Arrays;

public class Pirate {
	public static void main(String[] args) {
		int[] weights = {3, 5, 4, 10, 7, 14, 2, 11};
		Arrays.sort(weights);
		int capacity = 30, weight = 0, count = 0;
		
		for (int i = 0; i < weights.length && weight < capacity; i++) {
			int newWeight = weight + weights[i];
			if (newWeight <= capacity) {
				weight = newWeight;
				count++;
				System.out.println(weights[i]);
			}
		}
		System.out.println("一共选了" + count + "件古董");
	}
}

1.2 练习2 – 零钱兑换

1. 例一：假设有 25 分、10 分、5 分、1 分的硬币，现要找给客户 41 分的零钱，如何办到硬币个数最少？
2. 贪心策略：每一次都优先选择面值最大的硬币
   1. 选择 25 分的硬币，剩 16 分
   2. 选择 10 分的硬币，剩 6 分
   3. 选择 5 分的硬币，剩 1 分
   4. 选择 1 分的硬币
   5. 最终的解是共 4 枚硬币，25 分、10 分、5 分、1 分硬币各一枚
3. 例二：假设有 25 分、20 分、5 分、1 分的硬币，现要找给客户 41 分的零钱，如何办到硬币个数最少？
4. 贪心策略：每一次都优先选择面值最大的硬币
   1. 选择 25 分的硬币，剩 16 分
   2. 选择 5 分的硬币，剩 11 分
   3. 选择 5 分的硬币，剩 6 分
   4. 选择 5 分的硬币，剩 1 分
   5. 选择 1 分的硬币
   6. 最终的解是 1 枚 25 分、3 枚 5 分、1 枚 1 分的硬币，共 5 枚硬币
   7. 但实际上本题的最优解是：2 枚 20 分、1 枚 1 分的硬币，共 3 枚硬币
5. CoinChange

package com.mj;

import java.util.Arrays;

public class CoinChange {
	public static void main(String[] args) {
//		coinChange(new Integer[] {25, 10, 5, 1}, 41);

		coinChange(new Integer[] {25, 20, 5, 1}, 41);
	}
	
	static void coinChange(Integer[] faces, int money) {
		// 1 5 20 25
		Arrays.sort(faces);
		int coins = 0, idx = faces.length - 1;
		while (idx >= 0) {
			while (money >= faces[idx]) {
				System.out.println(faces[idx]);
				money -= faces[idx];
				coins++;
			}
			idx--;
		}
		System.out.println(coins);
	}
	
	static void coinChange2(Integer[] faces, int money) {
		Arrays.sort(faces, (Integer f1, Integer f2) -> f2 - f1); 
		int coins = 0, i = 0;
		while (i < faces.length) {
			if (money < faces[i]) {
				i++;
				continue;
			}

			System.out.println(faces[i]);
			money -= faces[i];
			coins++;
		}
		System.out.println(coins);
	}
	
	static void coinChange1() {
		int[] faces = {25, 5, 10, 1};
		Arrays.sort(faces); // 1, 5, 10, 25
		
		int money = 41, coins = 0;
		for (int i = faces.length - 1; i >= 0; i--) {
			if (money < faces[i]) {
				continue;
			}

			System.out.println(faces[i]);
			money -= faces[i];
			coins++;
			i = faces.length;
		}
		
		System.out.println(coins);
	}
}

1.3 练习3 – 0-1背包

1. 有 n 件物品和一个最大承重为 W 的背包，每件物品的重量是xi、价值是wi
   1. 在保证总重量不超过 W 的前提下，将哪几件物品装入背包，可以使得背包的总价值最大？
   2. 注意：每个物品只有 1 件，也就是每个物品只能选择 0 件或者 1 件，因此称为 0-1背包问题
2. 采取贪心策略，的3个方案
   1. 价值主导：优先选择价值最高的物品放进背包
   2. 重量主导：优先选择重量最轻的物品放进背包
   3. 价值密度主导：优先选择价值密度最高的物品放进背包（价值密度 = 价值 ÷ 重量）
      
3. Article

package com.mj.ks;

public class Article {
	public int weight;
	public int value;
	public double valueDensity;
	public Article(int weight, int value) {
		this.weight = weight;
		this.value = value;
		valueDensity = value * 1.0 / weight;
	}
	@Override
	public String toString() {
		return "Article [weight=" + weight + ", value=" + value + ", valueDensity=" + valueDensity + "]";
	}
}

4. Knapsack

package com.mj.ks;

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class Knapsack {
	public static void main(String[] args) {
		select("价值主导", (Article a1, Article a2) -> {
			return a2.value - a1.value;
		});
		select("重量主导", (Article a1, Article a2) -> {
			return a1.weight - a2.weight;
		});
		select("价值密度主导", (Article a1, Article a2) -> {
			return Double.compare(a2.valueDensity, a1.valueDensity);
		});
	}
	
	static void select(String title, Comparator<Article> cmp) {
		Article[] articles = new Article[] {
			new Article(35, 10), new Article(30, 40),
			new Article(60, 30), new Article(50, 50),
			new Article(40, 35), new Article(10, 40),
			new Article(25, 30)
		};
		Arrays.sort(articles, cmp);
		
		int capacity = 150, weight = 0, value = 0;
		List<Article> selectedArticles = new LinkedList<>();
		for (int i = 0; i < articles.length && weight < capacity; i++) {
			int newWeight = weight + articles[i].weight;
			if (newWeight <= capacity) {
				weight = newWeight;
				value += articles[i].value;
				selectedArticles.add(articles[i]);
			}
		}
		
		System.out.println("【" + title + "】");
		System.out.println("总价值：" + value);
		for (int i = 0; i < selectedArticles.size(); i++) {
			System.out.println(selectedArticles.get(i));
		}
		System.out.println("-----------------------------");
	}
}

2 分治

1. 分治，也就是分而治之。它的一般步骤是
   1. 将原问题分解成若干个规模较小的子问题（子问题和原问题的结构一样，只是规模不一样）
   2. 子问题又不断分解成规模更小的子问题，直到不能再分解（直到可以轻易计算出子问题的解）
   3. 利用子问题的解推导出原问题的解
2. 因此，分治策略非常适合用递归
3. 需要注意的是：子问题之间是相互独立的
4. 分治的应用
   1. 快速排序
   2. 归并排序
   3. Karatsuba算法（大数乘法）
      
5. 主定理（Master Theorem）
   1. 假设：使用分治解决问题时，数据规模为n，分解成 a 个规模为n/b的子问题，然后在O(n ^d )时间内将子问题的解合并起来
   2. 也就是说算法运行时间为：T(n) = aT(n/b)+O(n^d)，a > 0,b > 1,d ≥ 0，那么有如下时间复杂度计算公式
      1. d和logb(a)如果不相等，复杂度就是n的最大那个数次方
      2. 如果相等，就是n的d次方乘logn
         
   3. 比如归并排序的运行时间是：T (n) = 2T(n/2)+O(n)，a = 2,b = 2,d = 1 ，所以 T (n) = O(nlogn)
6. 采取分治策略性能提升的原因
   1. 因为我们知道传统的冒泡排序，时间复杂度为O(n^ 2)
   2. 那么对n/2个数据排序，其实复杂度会降为O((n/2)^2)，也就是O((n ^2)/4)
   3. 因此将数据分成两份，分别排序，总时间复杂度就是O((n^2)/2)+O(merge)(合并操作的时间复杂度)
   4. 此时可以想象，只要合并操作的时间复杂度只要不超过O((n^2)/2)，那么分治的效率就会比原来的更高
   5. 所以说分治的效率主要取决于合并操作的时间复杂度

2.1 练习1 – 最大连续子序列和

1. 给定一个长度为 n 的整数序列，求它的最大连续子序列和，比如 –2、1、–3、4、–1、2、1、–5、4 的最大连续子序列和是 4 + (–1) + 2 + 1 = 6
2. 这道题也属于最大切片问题（最大区段，Greatest Slice）
3. 概念区分
   1. 子串、子数组、子区间必须是连续的
   2. 子序列是可以不连续的，但必须是有序的，必须从左到右选数据
4. 解法1 – 暴力出奇迹：空间复杂度O(1)，时间复杂度O(n^ 3)，优化后达到O(n^2)
5. 解法2 – 分治
   1. 将序列均匀地分割成 2 个子序列，[begin , end) = [begin , mid) + [mid , end)，mid = (begin + end) >> 1
   2. 那么[begin , end) 最大子序列有三种可能
      1. 第一种：子序列元素全在[begin , mid)
      2. 第二种：子序列元素全在[mid , end)
      3. 第三种：子序列元素一部分在[begin , mid)，一部分在[mid , end)
   3. 将这三种情况的最大子序列的和，做比较，最大的就应该是其真正的最大子序列
   4. 第一种和第二种情况可以递归来查找最大子序列和，而第三种情况，可以遍历整个左边和右边就可以得到最大子序列值
   5. T(n)=2T(n/2)+O(n)，所以时间复杂度为O(nlogn)，空间复杂度为O(logn)
      
6. Main

package com.mj;

public class Main {
	public static void main(String[] args) {
		int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4 };
		System.out.println(maxSubArray(nums));
	}
	
	static int maxSubArray(int[] nums) {
		if (nums == null || nums.length == 0) return 0;
		return maxSubArray(nums, 0, nums.length);
	}
	
	/**
	 * 求解[begin, end)中最大连续子序列的和
	 * T(n) = T(n/2) + T(n/2) + O(n)
	 * T(n) = 2T(n/2) + O(n)
	 * logba = 1  d = 1
	 */
	static int maxSubArray(int[] nums, int begin, int end) {
//		if (end - begin < 2) return nums[begin];
//		int mid = (begin + end) >> 1;
//		int leftMax = Integer.MIN_VALUE;
//		int leftSum = 0;
//		for (int i = mid - 1; i >= begin; i--) {
//			leftSum += nums[i];
//			leftMax = Math.max(leftMax, leftSum);
//		}
//		
//		int rightMax = Integer.MIN_VALUE;
//		int rightSum = 0;
//		for (int i = mid; i < end; i++) {
//			rightSum += nums[i];
//			rightMax = Math.max(rightMax, rightSum);
//		}

		if (end - begin < 2) return nums[begin];
		int mid = (begin + end) >> 1;
		//查找最大连续子序列时横跨mid两端的这种情况，mid左边的最大值和mid右边的最大值
		int leftMax = nums[mid - 1];
		int leftSum = leftMax;
		//左边部分，需要从右不断向左加，找到最大值
		for (int i = mid - 2; i >= begin; i--) {
			leftSum += nums[i];
			leftMax = Math.max(leftMax, leftSum);
		}
		int rightMax = nums[mid];
		int rightSum = rightMax;
		//右边部分，需要从左往右加，找到最大值
		for (int i = mid + 1; i < end; i++) {
			rightSum += nums[i];
			rightMax = Math.max(rightMax, rightSum);
		}
		// 将数组从中间分成两半，最大子序列的元素分部，只有三种情况，要么都在左边，要么都在右边，要么左边一部分，右边一部分
		// 将都在左边、都在右边、以及在中间三种情况对应的值都得到，比对一下，哪个大，哪个就是最大子序列值
		return Math.max(leftMax + rightMax, 
					Math.max(
					maxSubArray(nums, begin, mid), 
					maxSubArray(nums, mid, end))
				);
	}
	
	static int maxSubarray2(int[] nums) {
		if (nums == null || nums.length == 0) return 0;
		int max = Integer.MIN_VALUE;
		for (int begin = 0; begin < nums.length; begin++) {
			int sum = 0;
			for (int end = begin; end < nums.length; end++) {
				// sum是[begin, end]的和
				sum += nums[end];
				max = Math.max(max, sum);
			}
		}
		return max;
	}
	
	static int maxSubarray1(int[] nums) {
		if (nums == null || nums.length == 0) return 0;
		int max = Integer.MIN_VALUE;
		for (int begin = 0; begin < nums.length; begin++) {
			for (int end = begin; end < nums.length; end++) {
				// sum是[begin, end]的和
				int sum = 0;
				for (int i = begin; i <= end; i++) {
					sum += nums[i];
				}
				max = Math.max(max, sum);
			}
		}
		return max;
	}
}