1 贪心
- 贪心策略,也称为贪婪策略,每一步都采取当前状态下最优的选择(局部最优解),从而希望推导出全局最优解
- 贪心策略并不一定能得到全局最优解
- 因为一般没有测试所有可能的解,容易过早做决定,所以没法达到最佳解
- 贪图眼前局部的利益最大化,看不到长远未来,走一步看一步
- 优点:简单、高效、不需要穷举所有可能,通常作为其他算法的辅助算法来使用
- 缺点:鼠目寸光,不从整体上考虑其他可能,每次采取局部最优解,不会再回溯,因此很少情况会得到最优解
- 贪心的应用
- 哈夫曼树
- 最小生成树算法:Prim、Kruskal
- 最短路径算法:Dijkstra
1.1 练习1 – 最优装载问题(加勒比海盗)
- 在北美洲东南部,有一片神秘的海域,是海盗最活跃的加勒比海
- 有一天,海盗们截获了一艘装满各种各样古董的货船,每一件古董都价值连城,一旦打碎就失去了它的价值。
- 海盗船的载重量为 W,每件古董的重量为 𝑥 i ,海盗们该如何把尽可能多数量的古董装上海盗船
- 比如 W 为 30,𝑥 i 分别为 3、5、4、10、7、14、2、11
- 贪心策略:每一次都优先选择重量最小的古董
- 选择重量为 2 的古董,剩重量 28
- 选择重量为 3 的古董,剩重量 25
- 选择重量为 4 的古董,剩重量 21
- 选择重量为 5 的古董,剩重量 16
- 选择重量为 7 的古董,剩重量 9
- 最多能装载 5 个古董
- 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 – 零钱兑换
- 例一:假设有 25 分、10 分、5 分、1 分的硬币,现要找给客户 41 分的零钱,如何办到硬币个数最少?
- 贪心策略:每一次都优先选择面值最大的硬币
- 选择 25 分的硬币,剩 16 分
- 选择 10 分的硬币,剩 6 分
- 选择 5 分的硬币,剩 1 分
- 选择 1 分的硬币
- 最终的解是共 4 枚硬币,25 分、10 分、5 分、1 分硬币各一枚
- 例二:假设有 25 分、20 分、5 分、1 分的硬币,现要找给客户 41 分的零钱,如何办到硬币个数最少?
- 贪心策略:每一次都优先选择面值最大的硬币
- 选择 25 分的硬币,剩 16 分
- 选择 5 分的硬币,剩 11 分
- 选择 5 分的硬币,剩 6 分
- 选择 5 分的硬币,剩 1 分
- 选择 1 分的硬币
- 最终的解是 1 枚 25 分、3 枚 5 分、1 枚 1 分的硬币,共 5 枚硬币
- 但实际上本题的最优解是:2 枚 20 分、1 枚 1 分的硬币,共 3 枚硬币
- CoinChange
package com.mj;
import java.util.Arrays;
public class CoinChange {
public static void main(String[] args) {
coinChange(new Integer[] {25, 20, 5, 1}, 41);
}
static void coinChange(Integer[] faces, int money) {
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);
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背包
- 有 n 件物品和一个最大承重为 W 的背包,每件物品的重量是xi、价值是wi
- 在保证总重量不超过 W 的前提下,将哪几件物品装入背包,可以使得背包的总价值最大?
- 注意:每个物品只有 1 件,也就是每个物品只能选择 0 件或者 1 件,因此称为 0-1背包问题
- 采取贪心策略,的3个方案
- 价值主导:优先选择价值最高的物品放进背包
- 重量主导:优先选择重量最轻的物品放进背包
- 价值密度主导:优先选择价值密度最高的物品放进背包(价值密度 = 价值 ÷ 重量)
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/1901451c41349fbe846d150c58637371.png)
- 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 + "]";
}
}
- 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 分治
- 分治,也就是分而治之。它的一般步骤是
- 将原问题分解成若干个规模较小的子问题(子问题和原问题的结构一样,只是规模不一样)
- 子问题又不断分解成规模更小的子问题,直到不能再分解(直到可以轻易计算出子问题的解)
- 利用子问题的解推导出原问题的解
- 因此,分治策略非常适合用递归
- 需要注意的是:子问题之间是相互独立的
- 分治的应用
- 快速排序
- 归并排序
- Karatsuba算法(大数乘法)
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/e9f1d3480e47ef3a33e2dcf2c30a5ad2.png)
- 主定理(Master Theorem)
- 假设:使用分治解决问题时,数据规模为n,分解成 a 个规模为n/b的子问题,然后在O(n ^d )时间内将子问题的解合并起来
- 也就是说算法运行时间为:T(n) = aT(n/b)+O(n^d),a > 0,b > 1,d ≥ 0,那么有如下时间复杂度计算公式
- d和logb(a)如果不相等,复杂度就是n的最大那个数次方
- 如果相等,就是n的d次方乘logn
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/b451d580f1981837a3446a970ca70ba6.png)
- 比如归并排序的运行时间是:T (n) = 2T(n/2)+O(n),a = 2,b = 2,d = 1 ,所以 T (n) = O(nlogn)
- 采取分治策略性能提升的原因
- 因为我们知道传统的冒泡排序,时间复杂度为O(n^ 2)
- 那么对n/2个数据排序,其实复杂度会降为O((n/2)^2),也就是O((n ^2)/4)
- 因此将数据分成两份,分别排序,总时间复杂度就是O((n^2)/2)+O(merge)(合并操作的时间复杂度)
- 此时可以想象,只要合并操作的时间复杂度只要不超过O((n^2)/2),那么分治的效率就会比原来的更高
- 所以说分治的效率主要取决于合并操作的时间复杂度
2.1 练习1 – 最大连续子序列和
- 给定一个长度为 n 的整数序列,求它的最大连续子序列和,比如 –2、1、–3、4、–1、2、1、–5、4 的最大连续子序列和是 4 + (–1) + 2 + 1 = 6
- 这道题也属于最大切片问题(最大区段,Greatest Slice)
- 概念区分
- 子串、子数组、子区间必须是连续的
- 子序列是可以不连续的,但必须是有序的,必须从左到右选数据
- 解法1 – 暴力出奇迹:空间复杂度O(1),时间复杂度O(n^ 3),优化后达到O(n^2)
- 解法2 – 分治
- 将序列均匀地分割成 2 个子序列,[begin , end) = [begin , mid) + [mid , end),mid = (begin + end) >> 1
- 那么[begin , end) 最大子序列有三种可能
- 第一种:子序列元素全在[begin , mid)
- 第二种:子序列元素全在[mid , end)
- 第三种:子序列元素一部分在[begin , mid),一部分在[mid , end)
- 将这三种情况的最大子序列的和,做比较,最大的就应该是其真正的最大子序列
- 第一种和第二种情况可以递归来查找最大子序列和,而第三种情况,可以遍历整个左边和右边就可以得到最大子序列值
- T(n)=2T(n/2)+O(n),所以时间复杂度为O(nlogn),空间复杂度为O(logn)
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/0e7449dc2820982c14ed695b599b3e8c.png)
- 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);
}
static int maxSubArray(int[] nums, int begin, int end) {
if (end - begin < 2) return nums[begin];
int mid = (begin + end) >> 1;
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 += 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++) {
int sum = 0;
for (int i = begin; i <= end; i++) {
sum += nums[i];
}
max = Math.max(max, sum);
}
}
return max;
}
}