数据结构与算法-164~167-贪心算法

164 贪心算法的基本介绍

集合覆盖问题
假设存在下面需要付费的广播台，以及广播台的信号可以覆盖的地区。如何选择最少的广播台，让所有的地区都可以接收到信号

广播台	覆盖地区
k1	北京，上海，天津
k2	广州，北京，深圳
k3	成都，上海，杭州
k4	上海，天津
k5	杭州 ，大连

贪心算法介绍

1. 贪心算法（贪婪算法）指在对问题进行求解时，在每一步选择中都采取最好或者最优（即最有利）的选择，从而希望能够导致结果是最好或者最优的算法
2. 贪心算法所得到的结果不一定最优的结果（有时候会是最优解），但是都是相对近似（接近）最优解的结果

思路分析：
最简单的方法，穷举法，列出每个可能的广播台的集合，这被称为幂集。假设总的有n个广播台，则广播台的组合总共有 2 ⁿ - 1 个，假设每秒可以计算10个子集，如图：

165 贪心算法解决集合覆盖思路图解

思路分析
目前并没有算法可以快速计算得到准备的值，使用贪心算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合：

1. 遍历所有的广播电台，找到一个覆盖了最多未覆盖的地区的电台（此电台可能 包含一些已覆盖的地区，但没有关系
2. 将这个电台加入到一个集合中（比如 ArrayList），想办法把该电台覆盖在地区下次比较时去掉
3. 重复第1步直到覆盖了全部的地区

166 贪心算法解决集合覆盖代码实现

package com.old.greedy_164_167;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class GreedyAlgorithm {

    public static void main(String[] args) {
        //创建广播电台，放入 Map
        Map<String, HashSet<String>> broadcasts = new HashMap<>();
        HashSet<String> addrSet1 = new HashSet<>();
        addrSet1.add("北京");
        addrSet1.add("上海");
        addrSet1.add("天津");
        broadcasts.put("k1", addrSet1);

        HashSet<String> addrSet2 = new HashSet<>();
        addrSet2.add("广州");
        addrSet2.add("北京");
        addrSet2.add("深圳");
        broadcasts.put("k2", addrSet2);

        HashSet<String> addrSet3 = new HashSet<>();
        addrSet3.add("成都");
        addrSet3.add("上海");
        addrSet3.add("杭州");
        broadcasts.put("k3", addrSet3);

        HashSet<String> addrSet4 = new HashSet<>();
        addrSet4.add("上海");
        addrSet4.add("天津");
        broadcasts.put("k4", addrSet4);

        HashSet<String> addrSet5 = new HashSet<>();
        addrSet5.add("杭州");
        addrSet5.add("大连");
        broadcasts.put("k5", addrSet5);

        System.out.println(broadcasts);

        HashSet<String> allAreas = new HashSet<>();
        broadcasts.values().forEach(allAreas::addAll);

        //所有地址

        /*allAreas.add("北京");
        allAreas.add("上海");
        allAreas.add("天津");
        allAreas.add("广州");
        allAreas.add("深圳");
        allAreas.add("成都");
        allAreas.add("杭州");
        allAreas.add("大连");*/

        System.out.println(allAreas);

        //创建ArraryList 存放选择的电台集合
        ArrayList<String> selects = new ArrayList<>();

        //定义一个临时的集合，在遍历的过程中上，存放遍历过程中的电台覆盖的地区和当前还没有覆盖的地区
        //的交集
        HashSet<String> tempSet = new HashSet<>();

        //定义给 maxKey，保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
        //如果 maxKey 不为null，则会加入到 selects
        String maxKey = null;


        while (!allAreas.isEmpty()) {

            //每进行一次需要，将 maxKey置空
            maxKey = null;
            for (String key : broadcasts.keySet()) {
                //每进行一次for
                tempSet.clear();
                //当前这个 key 覆盖的地区
                HashSet<String> areas = broadcasts.get(key);
                tempSet.addAll(areas);
                //求出 tempSet 和 allAreas的交集，交集会赋给 tempSet
                tempSet.retainAll(allAreas);

                //如果当前这个集合包含的未覆盖地区的数量，比 maxKey 指向的集合地区还多
                //tempSet.size() > broadcasts.get(maxKey).size() 这句体现出了贪心算法，每次都是选最优的
                if (tempSet.size() > 0 &&
                        (maxKey == null || tempSet.size() > broadcasts.get(maxKey).size())
                ) {
                    maxKey = key;
                }
            }

            //maxKey 不等于空，加入 selects
            if (maxKey != null) {
                selects.add(maxKey);
                //将 maxKey 指向的广播电台覆盖的地区，从 allAreas 去掉
                allAreas.removeAll(broadcasts.get(maxKey));
            }

        }

        //正确午安安：k1,k2,k3,k5
        System.out.println(selects);
    }
}

结果

{k1=[上海, 天津, 北京], k2=[广州, 北京, 深圳], k3=[成都, 上海, 杭州], k4=[上海, 天津], k5=[大连, 杭州]}
[成都, 上海, 广州, 天津, 大连, 杭州, 北京, 深圳]
[k1, k2, k3, k5]

167 贪心算法解决集合覆盖注意事项

1. 贪心算法所得到的结果不一定是最优的结果（有时候会是最优解）。但是都是相对挖（接近）最优解的结果
2. 比如上题的算法选出的是 k1, k2, k3, k5 符合覆盖了全部的地区
3. 但是发现：k2，k3，k4，k5 也可以覆盖全部地区，如果 k2 的使用成本低于 k1 ，那么上题的 k1, k2, k3, k5 虽然满足条件，但并不是最优解