核心思想
在对问题进行求解时，每步都选择局部最优解，希望最终可以得到全局最优解。
（贪心算法最终所得的结果不一定是全局最优解，但确是近似的最优解。）
经典问题1——集合覆盖问题
有n个集合，每个集合都含有若干个元素，从中找出m个集合，要求包含n个集合中所有的元素且m最小。
一般解决方法：
（1）列出n个集合的所有组合方案，因为每个集合都可以在集合内或不在集合内，所以共有 2 n 2^n 2n种组合方案。
（2）在这些组合方案中，找出含有所有元素的集合的组合，且组合中含有集合的个数最小。
该方法的时间复杂度为 O ( 2 n ) O(2^n) O(2n)，随着n的增加，时间将激增，不可用。
贪心算法思路（近似算法）：
（1）选出这样一个集合，即它含有最多的未包含的元素。
（2）重复第一步，直到选出的集合包含了所有的元素。
贪心算法的时间复杂度为 O ( n 2 ) O(n^2) O(n2).
举例：
有如下几个集合, 求解
set1 = {1, 2, 3};
set2 = {1, 3, 4};
set3 = {2, 5, 6};
set4 = {2, 3};
set5 = {6, 7};
代码：
public class GreedyAlgorithm {
public Set<Integer> greedy(List<Set<Integer>> setList) {
//收集所有集合中的所有元素
Set<Integer> needed = new HashSet<>();
for (Set<Integer> set : setList) {
for (int i : set) {
needed.add(i);
}
}
Set<Integer> result = new HashSet<>();
while (!needed.isEmpty()) {
int bestSet = 0;
int bestCoveredSize = 0;
for (int i = 0; i < setList.size(); i++) {
if (result.contains(i)) {
continue;
}
int coveredSize = 0;
for (int j : setList.get(i)) {
if (needed.contains(j)) {
coveredSize++;
}
}
//体现出贪心算法，每次都选含有最多未包含元素的集合
if (coveredSize > bestCoveredSize) {
bestSet = i;
bestCoveredSize = coveredSize;
}
}
result.add(bestSet);
needed.removeAll(setList.get(bestSet));
}
return result;
}
public static void main(String[] args) {
List<Set<Integer>> setList = new ArrayList<>();
setList.add(new HashSet<>(Arrays.asList(1, 2, 3)));
setList.add(new HashSet<>(Arrays.asList(1, 3, 4)));
setList.add(new HashSet<>(Arrays.asList(2, 5, 6)));
setList.add(new HashSet<>(Arrays.asList(2, 3)));
setList.add(new HashSet<>(Arrays.asList(6, 7)));
System.out.println(new GreedyAlgorithm().greedy(setList));
}
}
经典问题2——旅行商问题
有一位旅行商需要从城市A出发去其余n个城市旅行，请为他规划旅行路线，使总旅程最短。
一般解决方法：
计算出 n ! n! n!条旅行路线，并从中选取路线最短的。时间复杂度为 O ( n ! ) O(n!) O(n!)。
贪心算法思路：
每次选择要去的下一个城市都选择还没去过的距离最近的城市。
代码
public class GreedyAlgorithm2 {
public static int[] greedyAlgorithm2(int[][] distance, int n) {
int[] result = new int[n];
Set<Integer> notBeenTo = new HashSet<>(n);
for (int i = 1; i <= n; i++) {
notBeenTo.add(i);
}
int from = 0;
for (int i = 0; i < result.length; i++) {
int next = 0;
for (int j : notBeenTo) {
//体现出贪心算法，每次都选还没去过的距离最近的城市
if (next == 0 || distance[from][next] > distance[from][j]) {
next = j;
}
}
result[i] = next;
from = next;
notBeenTo.remove(next);
}
return result;
}
//测试代码
public static void main(String[] args) {
int n = 4;
int[][] distance = new int[n + 1][n + 1];
//0表示旅行商当前所在城市A, 1...n表示要去的城市
Random rnd = new Random();
for (int i = 0; i < distance.length; i++) {
for (int j = 0; j < i; j++) {
if (i != j) {
distance[i][j] = distance[j][i] = rnd.nextInt(10) + 1;
}
}
}
for (int[] arr : distance) {
System.out.println(Arrays.toString(arr));
}
System.out.println();
int[] result = greedyAlgorithm2(distance, n);
System.out.println(Arrays.toString(result));
}
}
NP完全问题
关于什么是P问题，NP问题，NP完全问题（NPC)，NP-hard问题（NPH)，请自行百度，没有找到满意的答案（没看懂 ）。
- NP完全问题简单定义就是以难解著称的问题（不能在多项式时间内解决的问题），如集合覆盖问题和旅行商问题。
- 当判断一个问题属于NP完全问题时就不用去寻找完美的解决方案，而是使用近似算法即可。但是要判断一个问题是不是NP完全问题很难，因为易于解决的问题和NP完全问题的差别通常很小。如“两点间最短路径问题”和“旅行商问题”。
可以通过以下方法简单（不是一定的）判断问题是否为NP完全问题。
- 元素较少时算法的运行素的非常快，但随着元素数量增加，速度会变得非常慢。
- 涉及“所有组合”的问题通常是NP完全问题。
- 不能将问题分成小问题，必须考虑各种可能的情况。这可能是NP完全问题。
- 如果问题涉及序列（如旅行商问题中的城市序列）且难以解决，它可能就是NP完全问题。
- 如果问题涉及集合（如广播台集合）且难以解决，它可能就是NP完全问题。
- 如果问题可能转化为集合覆盖问题或旅行者问题，它肯定是NP完全问题。
参考：《算法图解》第8章 贪婪算法