3.贪心算法

贪心算法（又称贪婪算法）

是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

基本要素

贪心选择

贪心选择是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。

贪心选择是采用从顶向下、以迭代的方法做出相继选择，每做一次贪心选择就将所求问题简化为一个规模更小的子问题。对于一个具体问题，要确定它是否具有贪心选择的性质，我们必须证明每一步所作的贪心选择最终能得到问题的最优解。通常可以首先证明问题的一个整体最优解，是从贪心选择开始的，而且作了贪心选择后，原问题简化为一个规模更小的类似子问题。然后，用数学归纳法证明，通过每一步贪心选择，最终可得到问题的一个整体最优解。

最优子结构

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。运用贪心策略在每一次转化时都取得了最优解。问题的最优子结构性质是该问题可用贪心算法或动态规划算法求解的关键特征。贪心算法的每一次操作都对结果产生直接影响，而动态规划则不是。贪心算法对每个子问题的解决方案都做出选择，不能回退；动态规划则会根据以前的选择结果对当前进行选择，有回退功能。动态规划主要运用于二维或三维问题，而贪心一般是一维问题。

实例

哈夫曼编码

（算法详解）

class Greedy:
    def __init__(self):
        pass

    '''
    哈夫曼编码
    '''
    class Node:
        '''
        实现节点类
        '''
        def __init__(self, kv):
            self.left = None
            self.right = None
            self.father = None
            self.kv = kv

        def is_left(self):
            if self.father is not None:
                return self.father.left == self

    def create_nodes(self, kvs):
        '''
        为每一个节点赋值
        :param kvs:
        :return:
        '''
        return [self.Node(kv) for kv in kvs]

    def create_huffman_tree(self, nodes):
        '''
        创建哈夫曼树
        :param nodes:
        :return: 根节点
        '''
        queue = nodes[:]
        while len(queue) > 1:
            queue.sort(key=lambda item: item.kv[1])
            node_left = queue.pop(0)
            node_right = queue.pop(0)
            node_father = self.Node((None, node_left.kv[1] + node_right.kv[1], None))
            node_father.left = node_left
            node_father.right = node_right
            node_left.father = node_father
            node_right.father = node_father
            queue.append(node_father)
        return queue[0]

    def huffman_encoding(self, nodes, root):
        '''
        遍历叶节点，保存路径
        :param nodes:
        :param root:
        :return:
        '''
        for i in range(len(nodes)):
            node_tmp = nodes[i]
            while node_tmp != root:
                if node_tmp.is_left():
                    nodes[i].kv[2] += '0'
                else:
                    nodes[i].kv[2] += '1'
                node_tmp = node_tmp.father

    def get_huffman_code(self, string, nodes):
        '''
        哈夫曼加密
        :param string:
        :param nodes:
        :return:
        '''
        code = ''
        for character in string:
            for node in nodes:
                if character == node.kv[0]:
                    code += node.kv[2]
                    break
        return code

    def get_huffman_string(self, code, root):
        '''
        哈夫曼解密
        :param code:
        :param root:
        :return:
        '''
        string = ''
        node = root
        for elem in code:
            if elem == '0':
                node = node.left
            if elem == '1':
                node = node.right
            if node.left is None and node.right is None:
                string += node.kv[0]
                node = root
        return string




if __name__ == '__main__':
    greedy = Greedy()
    nodes = greedy.create_nodes([
        ['A', 5, ''],
        ['B', 4, ''],
        ['C', 3, ''],
        ['D', 2, ''],
        ['E', 1, ''],
    ])
    root = greedy.create_huffman_tree(nodes)
    for node in nodes:
        print(node.kv)
    greedy.huffman_encoding(nodes, root)
    for node in nodes:
        print(node.kv)
    code = greedy.get_huffman_code('ACE', nodes)
    print(code)
    string = greedy.get_huffman_string(code, root)
    print(string)

单源最短路径（算法详解）

最小生成树（算法详解）

转载于:https://my.oschina.net/gain/blog/3061700