Question

Could the running time of algorithm max_ind_set_improved() be improved by using dynamic programming or memoization? And if so, which of the two approaches would be preferable? Justify your answer.

def max_ind_set(nodes, edges):
    if len(nodes) <= 1: return len(nodes)
    node = nodes[0] # pick a node

    # case 1: node lies in independent set => remove neighbours as well
    nodes1 = [ n for n in nodes if n != node and (node, n) not in edges ]
    size1 = 1 + max_ind_set(nodes1, edges)

    # case 2: node does not lie in independent set
    nodes2 = [ n for n in nodes if n != node ]
    size2 = max_ind_set(nodes2, edges)

    return max(size1, size2)

def max_ind_set_improved(nodes, edges):
    if len(nodes) <= 1: return len(nodes)
    node = nodes[0] # pick a node

    # case 1: node lies in independent set => remove neighbours as well
    nodes1 = [ n for n in nodes if n != node and (node, n) not in edges ]
    size1 = 1 + max_ind_set_improved(nodes1, edges)

    if len([ n for n in nodes if (node, n) in edges ]) <= 1:
        return size1

    # case 2: node does not lie in independent set
    nodes2 = [ n for n in nodes if n != node ]
    size2 = max_ind_set_improved(nodes2, edges)

    return max(size1, size2)

if __name__ == '__main__':
    nodes = [1,2,3,4,5,6,7,8]
    edges = [(1,2),(1,3),(2,3),(2,4),(3,5),(4,5),(4,6),(5,7),(6,7),(6,8),(7,8)]
    # undirected graph => edges go in both directions (simplifies algorithms)
    edges += [ (b,a) for (a,b) in edges ]
    print("max_ind_set = {}".format(max_ind_set(nodes,edges)))
    print("max_ind_set_improved = {}".format(max_ind_set_improved(nodes,edges)))

Answer 1

Please let me know if you require any further assistance.

Yes the running time of "max_ind_set_improved() " could be improved by using memoization. This is because if we use dynamic programming we will end up solving same sub-problems again and again. By using memoization we can effectively amortize that cost and produce an runtime complexity that is much more efficient in nature. for e.g. if we know node '3' lies in independent set, we can avoid computing the sub problem of finding if '3' lies in independent set again and again.