Algorithm 一个有趣的图形任务

有一棵树有n个顶点。我们被要求计算一个多集的最小大小，例如，对于树中的每条边（u，v），至少有以下一个保持：

• u&in；
• v&in；
• S中至少有两个顶点，每个顶点都与u或v相邻

由于S是一个多重集，一个顶点可能在S中多次出现

我的直觉如下。首先，我们考虑以下事实：在最优解中，每个顶点最多在S中两次。所以我们可以按后序遍历树，计算三种情况下的结果，其中一个顶点不在最优S中，它在一次和两次中

不幸的是，我不能将子问题之间的关系联系起来，我不确定这个想法是否正确

欢迎提供提示或参考。非常感谢。

代表这样的树（未经测试的Haskell）

树

  1
 /|\
2 3 4
  |
  5

是

这里有一个自下而上的验证函数

> type ZeroOneOrTwo = Int
> data Result = Failure
>             | Success { numDist0Provided :: ZeroOneOrTwo
>                       , numDist1Provided :: ZeroOneOrTwo
>                       , numDist1Required :: ZeroOneOrTwo
>                       }
>
> plus, minus :: ZeroOneOrTwo -> ZeroOneOrTwo -> ZeroOneOrTwo
> x `plus` y = min 2 (x + y)
> x `minus` y = max 0 (x - y)
>
> evaluate :: Tree ZeroOneOrTwo -> Bool
> evaluate t = case evaluate' t of
>   Failure -> False
>   s -> 0 == numDist1Required s
>
> evaluate' :: Tree ZeroOneOrTwo -> Result
> evaluate' (Node x) = Success { numDist0Provided = x
>                              , numDist1Provided = 0
>                              , numDist1Required = 0
>                              }
> evaluate' (Cons t1 t2) = case (evaluate' t1, evaluate' t2) of
>   (Failure, _) -> Failure
>   (_, Failure) -> Failure
>   (s1, s2) ->
>     if numDist0Provided s2 < numDist1Required s1 then Failure
>       else Success { numDist0Provided = numDist0Provided s2
>                    , numDist1Provided = numDist1Provided s2 `plus` numDist0Provided s1
>                    , numDist1Required = max (numDist1Required s2 `minus` numDist0Provided s1)
>                                           (if 0 < numDist0Provided s1 || 0 < numDist0Provided s2 then 0
>                                              else 2 `minus` (numDist1Provided s1 `plus` numDist1Provided s2))
>                    }

>键入ZeroOneOrTwo=Int
>数据结果=失败
>|成功{numDist0Provided:：ZeroOneOrTwo
>，numDist1Provided:：ZeroOneOrTwo
>，numDist1Required:：ZeroOneOrTwo
>                       }
>
>加，减：：零一或二->零一或二->零一或二
>x`plus`y=min2（x+y）
>x`减去`y=max 0（x-y）
>
>评估：：树zeroneortwo->Bool
>评估t=案例评估t
>失败->错误
>s->0==numdist1所需的s
>
>评估“：：树zeroneortwo->结果
>evaluate'（节点x）=成功{numDist0Provided=x
>，numDist1Provided=0
>，numDist1Required=0
>                              }
>评估’（Cons t1 t2）=案例（评估’t1，评估’t2）
>（失败，824;）->失败
>（_，故障）->故障
>（s1，s2）->
>如果NUMDIST0提供s2else Success{numDist0Provided=numDist0Provided s2
>，numDist1Provided=numDist1Provided s2`plus`numDist0Provided s1
>，numDist1Required=max（numDist1Required s2`减去'numdist0s1）
>（如果0else 2`减去'（NUMDist1提供的s1`加上'NUMDist1提供的s2））
>                    }

---

我将保留相应的线性时间DP作为练习。

听起来像是的相对值。谢谢。我以类似的方式表示一棵树，但我不知道如何实现DP算法。问题是，有很多案例。例如，位于S中的root的两个子项覆盖从root传出的其他边。所以也许贪婪的方法存在并且更容易编码…@SteveMadden不是

树zeroneortwo->Result

，而是

树（）->[（Result，Int）]

（

（）

在Haskell中意味着无效），而且，您可以扔掉成本更高的选项，以保持输出列表的大小最多为

27个
元素。
(Cons (Node 2)
      (Cons (Cons (Node 5) (Node 3))
            (Cons (Node 4) (Node 1)))) :: Tree Int .

> type ZeroOneOrTwo = Int
> data Result = Failure
>             | Success { numDist0Provided :: ZeroOneOrTwo
>                       , numDist1Provided :: ZeroOneOrTwo
>                       , numDist1Required :: ZeroOneOrTwo
>                       }
>
> plus, minus :: ZeroOneOrTwo -> ZeroOneOrTwo -> ZeroOneOrTwo
> x `plus` y = min 2 (x + y)
> x `minus` y = max 0 (x - y)
>
> evaluate :: Tree ZeroOneOrTwo -> Bool
> evaluate t = case evaluate' t of
>   Failure -> False
>   s -> 0 == numDist1Required s
>
> evaluate' :: Tree ZeroOneOrTwo -> Result
> evaluate' (Node x) = Success { numDist0Provided = x
>                              , numDist1Provided = 0
>                              , numDist1Required = 0
>                              }
> evaluate' (Cons t1 t2) = case (evaluate' t1, evaluate' t2) of
>   (Failure, _) -> Failure
>   (_, Failure) -> Failure
>   (s1, s2) ->
>     if numDist0Provided s2 < numDist1Required s1 then Failure
>       else Success { numDist0Provided = numDist0Provided s2
>                    , numDist1Provided = numDist1Provided s2 `plus` numDist0Provided s1
>                    , numDist1Required = max (numDist1Required s2 `minus` numDist0Provided s1)
>                                           (if 0 < numDist0Provided s1 || 0 < numDist0Provided s2 then 0
>                                              else 2 `minus` (numDist1Provided s1 `plus` numDist1Provided s2))
>                    }