貪心演算法（貪婪演算法，greedy algorithm）

核心思想

在對問題進行求解時，每步都選擇區域性最優解，希望最終可以得到全域性最優解。
（貪心演算法最終所得的結果不一定是全域性最優解，但確是近似的最優解。）

---

經典問題——集合覆蓋問題

有n個集合，每個集合都含有若干個元素，從中找出m個集合，要求包含n個集合中所有的元素且m最小。
一般解決方法：
（1）列出n個集合的所有組合方案，因為每個集合都可以包含或不包含，所以共有$2^n$種組合方案。
（2）在這些組合方案中，找出含有所有元素的集合的組合，且組合中含有集合的個數最小。

該方法的時間複雜度為$O(2^n)$，隨著n的增加，時間將激增，不可用。

貪心演算法思路（近似演算法）：
（1）選出這樣一個集合，即它含有最多的未包含的元素。
（2）重複第一步，直到選出的集合包含了所有的元素。

貪心演算法的時間複雜度為$O(n^2)$.
舉例：
有如下幾個集合, 求解
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++) {
                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));
    }
}