SRM144 DIV2 1100

图论题，题目重新叙述为：

一棵树从根出发遍历完所有节点的最短总路径之和

令 (p(x)) 表示节点 (x) 到根的路径长，(sum) 表示所求总路径之和，则：

(sum_{min}=2 imes sum_i ductLength_i - max{p(x)})

证明

最优解与深度优先遍历有关，先证明如下问题：

若最终遍历还要回到根节点，则最短路径之和 (sum2_{min}) 就是深度优先遍历的路径之和 (deepsum)

利用归纳法可以证明深度优先遍历路径和 (deepsum=2 imes sum_i ductLength_i)

若最终遍历回到根节点，则任何一条边必然至少被遍历两次，因此 (sum2_{min} geq 2 imes sum_i ductLength_i)，所以：

(sum2_{min}=deepsum=2 imes sum_i ductLength_i)

将回到根节点的遍历法分为两步：

1. 遍历到最后一个节点 (x)

2. 回到根节点

因此：

( sum2=sum+p(x))

(egin{equation}egin{split}sum_{min}&=sum2_{min}-max{p(x)} \ &=2 imes sum_i ductLength_i - max{p(x)}end{split}end{equation})

可以证明深度优先遍历时使得 (sum2) 取最小值和 (p(x)) 取最大值并不冲突，综上，命题得证

class Graph:
    def __init__(self, n):
        self.n = n                       # 节点个数
        self.g = [[] for i in range(n)]  # 邻接表表示的图模型

    def count(self):
        return self.n


    # 新增一条边
    def append(self, i, j, l=None):
        self.g[i].append((j, l))


    # 返回从x的后继边的集合
    def nexts(self, x):
        return self.g[x]

# DFS算法
class DeepFirstSearch:
    def __init__(self, begin, g):
        self.begin = begin         # 开始节点
        self.searchHandle = None   # 搜到新节点时触发
        self.g = g                 # 搜索图

    def _onSearch(self, prev, nextNode, l):
        if self.searchHandle != None:
            self.searchHandle(prev, nextNode, l)

    def do(self):
        a = [self.begin]
        marks = [False] * self.g.count()
        marks[self.begin] = True
        while len(a) > 0:
            x = a.pop()
            for yl in self.g.nexts(x):
                y = yl[0]
                l = yl[1]
                if not marks[y]:
                    self._onSearch(x, y, l)
                    marks[y] = True
                    a.append(y)


class PowerOutage:
    def search(self, x, y, l):
        self.deeps[y] = self.deeps[x] + l
        self.maxDeep = max(self.maxDeep, self.deeps[y])

    def estimateTimeOut(self, f, t, l):
        maxNodeCount = 50
        g = Graph(maxNodeCount)
        for i in range(len(f)):
            g.append(f[i], t[i], l[i])

        self.deeps = [0] * maxNodeCount
        self.maxDeep = 0
        dfs = DeepFirstSearch(0, g)
        dfs.searchHandle = self.search
        dfs.do()

        result = 2 * sum(l) - self.maxDeep
        return result


# test
o = PowerOutage()

# test case
assert(o.estimateTimeOut((0,), (1,), (10,)) == 10)
assert(o.estimateTimeOut((0,1,0), (1,2,3), (10,10,10)) == 40)
assert(o.estimateTimeOut((0,0,0,1,4), (1,3,4,2,5), (10,10,100,10,5)) == 165)
assert(o.estimateTimeOut((0,0,0,1,4,4,6,7,7,7,20), (1,3,4,2,5,6,7,20,9,10,31), (10,10,100,10,5,1,1,100,1,1,5)) == 281)
assert(o.estimateTimeOut((0,0,0,0,0), (1,2,3,4,5), (100,200,300,400,500)) == 2500)