核心思想
在对问题进行求解时,每步都选择局部最优解,希望最终可以得到全局最优解。
(贪心算法最终所得的结果不一定是全局最优解,但确是近似的最优解。)
经典问题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章 贪婪算法