贪心算法 Greedy Algroithm

贪心算法简介

贪心算法是一种在每一步选择中都采取在当前看来最好选择的算法。它的基本思想是从问题的某个初始解出发，通过一步步地进行，根据某个优化测度，每一步都要确保能获得局部最优解。贪心算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度做最优选择，而不考虑各种可能的整体情况，省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪心算法采用自顶向下的方法，以迭代的方式做出相继贪心的选择，可得到问题的一个最优解。虽然每一步上都要保证能获得局部最优解，但由此产生的全局解不一定是最优的，所以贪心算法不要回溯。

贪心算法的应用场景

贪心算法的应用非常广泛，包括但不限于最短路径问题、单位密度问题。这些问题的共同特点是可以通过贪婪选择属性与最优子结构属性，利用贪心算法解决。贪婪选择属性指的是通过在每个步骤中选择最优选择，可以得到一个全局(总体)最优解。

贪心算法的经典例子

1.找零钱问题（Greedy Chang-Making Problem）

假设有一定面值的纸币和硬币，当要找零钱时，贪心算法会选择最大面值的纸币和硬币，当要找零钱时，贪心算法会选择最大面值的纸币或硬币，直到零钱找完。

import java.util.Arrays;public class GreedyAlgorithm {public static void main(String[] args) {int totalAmount = 16;int[] coins = {1, 2, 5, 10};int[] change = getChange(totalAmount, coins);System.out.println("Change: " + Arrays.toString(change));}public static int[] getChange(int totalAmount, int[] coins) {int[] change = new int[coins.length];int remainingAmount = totalAmount;for (int i = coins.length - 1; i >= 0; i--) {int numCoins = remainingAmount / coins[i];change[i] = numCoins;remainingAmount -= numCoins * coins[i];}return change;}
}

2.区间调度问题（Interval Scheduling Problem）

假设有一系列的任务需要在特定时间完成，每个任务都有一个开始时间和结束时间，贪心算法会优先选择结束时间最早的任务，然后选择下一个结束时间最早的任务，一次类推。

区间调度问题是指给定一组区间，找到能够完全覆盖这些区间的最少的区间数。这个问题可以使用贪心算法来解决。

贪心算法的思路是，先按照区间的结束时间进行排序，然后从第一个区间开始遍历，依次选取结束时间最早的区间，并且这个区间的开始时间要晚于前一个区间的结束时间。这样就可以保证选取的区间数最少。

下面是用Java实现的代码：

import java.util.Arrays;
import java.util.Comparator;public class IntervalSchedule {public static int intervalSchedule(int[][] intervals) {//按结束时间对区间进行排序Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));int count = 1;  //选取的区间数int end = intervals[0][1];  //当前选择的区间的结束时间for (int i = 1; i < intervals.length; i++) {if (intervals[i][0] >= end) {//如果当前区间的开始时间晚于前一个区间的结束时间，可以选择这个区间count++;end = intervals[i][1];}}return count;}public static void main(String[] args) {int[][] intervals = {{1, 3}, {2, 4}, {3, 6}, {4, 7}, {5, 8}};int result = intervalSchedule(intervals);System.out.println("最少的区间数为：" + result);}
}

运行结果为：

最少的区间数为：3

注意，这里假设输入的区间数组是已经合法的，即每个区间的开始时间都小于结束时间。如果区间数组未按照开始时间进行排序，可以先进行排序再使用贪心算法。

3.分数背包问题（Fractional Knapsack Problem）

假设有一系列物品和一个背包，每个物品有自己的重量和价值，贪心算法会先选择性价比最高的物品放入背包，直到背包装满或者物品用完。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;class Item {int weight;int value;public Item(int weight, int value) {this.weight = weight;this.value = value;}
}class FractionalKnapsack {public static double getMaxValue(List<Item> items, int capacity) {// 排序，按照单位价值从高到低排序items.sort(Comparator.comparingDouble(o -> (double) o.value / o.weight));double totalValue = 0;for (Item item : items) {if (capacity >= item.weight) {// 如果背包容量可以装下当前物品，则装入整个物品totalValue += item.value;capacity -= item.weight;} else {// 否则，计算当前物品的单位价值，装入剩余容量的物品totalValue += item.value * ((double) capacity / item.weight);break;}}return totalValue;}public static void main(String[] args) {List<Item> items = new ArrayList<>();items.add(new Item(10, 60));items.add(new Item(20, 100));items.add(new Item(30, 120));int capacity = 50;double maxValue = getMaxValue(items, capacity);System.out.println("最大价值为：" + maxValue);}
}

4.最小生成树问题（Minimum Spanning Tree Problem）

假设有一张图，贪心算法会先选择连接两个点之间最短的边，然后选择下一个最短的边，直到所有的点都被连接。
贪心算法解决最小生成树问题的一种实现方式是使用Prim算法。以下是一个使用Java语言实现的Prim算法示例代码：

import java.util.*;class PrimMST {private int V; // 图的顶点数private int[][] graph; // 图的邻接矩阵表示public PrimMST(int v, int[][] graph) {V = v;this.graph = graph;}// 寻找最小生成树public void findMST() {boolean[] visited = new boolean[V]; // 记录顶点是否访问过int[] parent = new int[V]; // 记录最小生成树的父节点int[] key = new int[V]; // 记录顶点到最小生成树的最小权值// 初始化key数组Arrays.fill(key, Integer.MAX_VALUE);// 第一个顶点作为最小生成树的根节点key[0] = 0;parent[0] = -1;for (int i = 0; i < V-1; i++) {int u = findMinKey(key, visited); // 选择key值最小的顶点visited[u] = true; // 将选择的顶点标记为已访问// 更新与顶点u相邻的顶点的key值和parent值for (int v = 0; v < V; v++) {if (graph[u][v] != 0 && !visited[v] && graph[u][v] < key[v]) {key[v] = graph[u][v];parent[v] = u;}}}// 输出最小生成树System.out.println("边    权值");for (int i = 1; i < V; i++) {System.out.println(parent[i] + " - " + i + "   " + graph[i][parent[i]]);}}// 找到key值最小的顶点private int findMinKey(int[] key, boolean[] visited) {int minKey = Integer.MAX_VALUE;int minIndex = -1;for (int i = 0; i < V; i++) {if (!visited[i] && key[i] < minKey) {minKey = key[i];minIndex = i;}}return minIndex;}public static void main(String args[]) {int graph[][] = new int[][] {{ 0, 2, 0, 6, 0 },{ 2, 0, 3, 8, 5 },{ 0, 3, 0, 0, 7 },{ 6, 8, 0, 0, 9 },{ 0, 5, 7, 9, 0 }};PrimMST mst = new PrimMST(5, graph);mst.findMST();}
}

这是一个简单的Prim算法实现，假设图的顶点数为5，使用邻接矩阵表示图的连接关系。在findMST()方法中，我们使用一个visited数组来记录顶点是否已经访问过，使用parent数组来记录最小生成树的父节点，使用key数组来记录顶点到最小生成树的最小权值。在每次循环找到key值最小的顶点后，我们将其标记为已访问，并更新其相邻顶点的key值和parent值。最后，输出最小生成树的边和权值。

在main()方法中，我们使用一个邻接矩阵来表示图，并创建一个PrimMST对象来求解最小生成树。运行代码后，将输出最小生成树的边和权值。

5.哈夫曼编码问题（Huffman Coding Problem）

假设有一系列的字符和它们对应的频率，在使用最少的比特数来编码字符的同时，贪心算法会优先选择频率最高的字符编码长度最短。
下面是用Java实现贪心算法哈夫曼编码的示例代码：

import java.util.PriorityQueue;class HuffmanTreeNode implements Comparable<HuffmanTreeNode> {int frequency;char data;HuffmanTreeNode left, right;public HuffmanTreeNode(char data, int frequency) {this.data = data;this.frequency = frequency;}@Overridepublic int compareTo(HuffmanTreeNode node) {return this.frequency - node.frequency;}
}public class HuffmanEncoding {public static void main(String[] args) {String input = "Hello, world!";HuffmanTreeNode root = buildHuffmanTree(input);String encodedString = encode(input, root);String decodedString = decode(encodedString, root);System.out.println("Input: " + input);System.out.println("Encoded String: " + encodedString);System.out.println("Decoded String: " + decodedString);}public static HuffmanTreeNode buildHuffmanTree(String input) {int[] frequencyTable = new int[256];for (char c : input.toCharArray()) {frequencyTable[c]++;}PriorityQueue<HuffmanTreeNode> priorityQueue = new PriorityQueue<>();for (int i = 0; i < frequencyTable.length; i++) {if (frequencyTable[i] > 0) {priorityQueue.add(new HuffmanTreeNode((char) i, frequencyTable[i]));}}while (priorityQueue.size() > 1) {HuffmanTreeNode leftNode = priorityQueue.poll();HuffmanTreeNode rightNode = priorityQueue.poll();HuffmanTreeNode newNode = new HuffmanTreeNode('\0', leftNode.frequency + rightNode.frequency);newNode.left = leftNode;newNode.right = rightNode;priorityQueue.add(newNode);}return priorityQueue.poll();}public static String encode(String input, HuffmanTreeNode root) {StringBuilder sb = new StringBuilder();for (char c : input.toCharArray()) {sb.append(getEncodedString(c, root));}return sb.toString();}private static String getEncodedString(char c, HuffmanTreeNode root) {if (root == null) {return "";}if (root.data == c) {return "";}String left = getEncodedString(c, root.left);if (left != null) {return "0" + left;}String right = getEncodedString(c, root.right);if (right != null) {return "1" + right;}return null;}public static String decode(String encodedString, HuffmanTreeNode root) {StringBuilder sb = new StringBuilder();HuffmanTreeNode currentNode = root;for (char c : encodedString.toCharArray()) {if (c == '0') {currentNode = currentNode.left;} else if (c == '1') {currentNode = currentNode.right;}if (currentNode.data != '\0') {sb.append(currentNode.data);currentNode = root;}}return sb.toString();}
}