【问题标题】:find the most valuable vertex among all reachable vertices在所有可达顶点中找到最有价值的顶点
【发布时间】:2021-04-15 21:58:20
【问题描述】:

我有一个有向图G=(V,E),每个顶点v 有两个属性:

  • r表示有价值
  • m 表示最高的v' 的r(其中v' 是从v 到达的顶点)。

我需要在O(|V|+|E|) 时间内为所有顶点找到ms。

例如,

初始G

A(r = 1, m = 1) → B(r = 3, m = 3) ← C(r = 2, m = 2)
↓
D(r = 4, m = 4)

必须是

A(r = 1, m = 4) → B(r = 3, m = 3) ← C(r = 2, m = 3)
↓
D(r = 4, m = 4)

我搜索了一些Here,但其中一个答案没有及时约束,另一个答案解释得很糟糕。这里有更简单的想法吗?

【问题讨论】:

  • 等等,你的意思是可以通过中间的步骤到达还是直接可以到达(相邻)?
  • @orlp 这意味着您可以从 a 转到 b 并且 b 可以通过 a 到达。清楚了吗?
  • @orlp 请查看其他帖子算法。我在问题中提到了链接
  • 我的问题是,假设我们有a -> b -> c。在这种情况下,c 是否可以从a 访问?
  • 确定@orlp 你的例子是正确的,

标签: java python algorithm math data-structures


【解决方案1】:

我从 Python 中的链接问题中实现了我的答案。未引用 minreach 的行紧跟 Wikipedia 对 Tarjan 的 SCC 算法的描述。

import random


def random_graph(n):
    return {
        i: {random.randrange(n) for j in range(random.randrange(n))} for i in range(n)
    }


class SCC:
    def __init__(self, graph):
        self.graph = graph
        self.index = {}
        self.lowlink = {}
        self.stack = []
        self.stackset = set()
        self.minreach = {}
        self.components = []

    def dfs(self, v):
        self.lowlink[v] = self.index[v] = len(self.index)
        self.stack.append(v)
        self.stackset.add(v)
        self.minreach[v] = v
        for w in self.graph[v]:
            if w not in self.index:
                self.dfs(w)
                self.lowlink[v] = min(self.lowlink[v], self.lowlink[w])
            elif w in self.stackset:
                self.lowlink[v] = min(self.lowlink[v], self.index[w])
            self.minreach[v] = min(self.minreach[v], self.minreach[w])
        if self.lowlink[v] == self.index[v]:
            component = set()
            while True:
                w = self.stack.pop()
                self.stackset.remove(w)
                self.minreach[w] = self.minreach[v]
                component.add(w)
                if w == v:
                    break
            self.components.append(component)

    def scc(self):
        for v in self.graph:
            if v not in self.index:
                self.dfs(v)
        return self.components, self.minreach


if __name__ == "__main__":
    g = random_graph(6)
    print(g)
    components, minreach = SCC(g).scc()
    print(components)
    print(minreach)

【讨论】:

    【解决方案2】:

    我添加了这个答案,虽然在我之前有正确的答案和赞成票,只是因为你标记了 和。所以我现在将添加 java 实现,如果需要,python 实现将随之而来。

    算法

    这是对经典拓扑排序的调整:

    1. foreach 顶点:
      1. foreach 邻居:
        1. 如果还没有计算m,请计算。
      2. 为自己和邻居争取最大的利益。将自己标记为已访问,如果再次询问m,则返回计算结果。

    在calculateMostValuableVertex实现。

    时间计算复杂度

    1. foreach 顶点 (O(|V|)) 2. foreach edge(O(|E|) 完全,因为它最终会越过每条边一次。):

      1. 如果尚未计算,请计算 m。

    请注意,对于每个顶点,它将在第 1 阶段或第 3 阶段计算。不是两次,因为在计算之前会检查它。 因此该算法的时间复杂度为 O(|V| + |E|)

    假设

    此解决方案在很大程度上依赖于这样一个事实,即 Java 中的 HashMap 执行诸如 O(1) 中的添加/更新之类的操作。平均而言是这样,但如果这还不够,同样的想法只能用数组完全实现,这将在最坏的情况下将解决方案改进为O(|V|+|E|)。

    实施

    让我们首先定义基本类:

    1. 顶点:

      import java.util.ArrayList;
      
      class Vertex {
          String label;
          public int r; // Worthiness
          public int m; // Highest worthiness.
      
          Vertex(String label, int r, int m) {
              this.label = label;
              this.r = r;
              this.m = m;
          }
      
          @Override
          public int hashCode() {
              final int prime = 31;
              int result = 1;
              result = prime * result * r * m
                      + ((label == null) ? 0 : label.hashCode());
              return result;
          }
      
          @Override
          public boolean equals(final Object obj) {
              if (this == obj)
                  return true;
              if (obj == null)
                  return false;
              if (getClass() != obj.getClass())
                  return false;
              final Vertex other = (Vertex) obj;
      
              boolean labelEquals;
              if (label == null) {
                  labelEquals = other.label == null;
              } else {
                  labelEquals = label.equals(other.label);
              }
              return labelEquals && r == other.r && m == other.m;
          }
      
          @Override
          public String toString() {
              return "Vertex{" +
                      "label='" + label + '\'' +
                      ", r=" + r +
                      ", m=" + m +
                      '}';
          }
      }
      

      定义 equals 和 hashCode 方法很重要,以便稍后它们的哈希计算将按预期工作。

    2. 图表:

      class Graph {
      
          private final Map<Vertex, List<Vertex>> adjVertices = new HashMap<>();
          private final Map<String, Vertex> nameToVertex = new HashMap<>();
          private final List<Vertex> vertices = new ArrayList<>();
      
          void addVertex(String label, int r, int m) {
              Vertex vertex = new Vertex(label, r, m);
              adjVertices.putIfAbsent(vertex, new ArrayList<>());
              nameToVertex.putIfAbsent(label, vertex);
              vertices.add(vertex);
          }
      
          void addEdge(String label1, String label2) {
              adjVertices.get(nameToVertex.get(label1)).add(nameToVertex.get(label2));
          }
      
          public void calculateMostValuableVertex() {
              Map<Vertex, Boolean> visitedVertices = new HashMap<>();
              for (Vertex vertex : vertices) {
                  visitedVertices.put(vertex, false);
              }
      
              for (Vertex vertex : vertices) {
                  if (visitedVertices.get(vertex)) {
                      continue;
                  }
      
                  calculateMostValuableVertexInternal(vertex, visitedVertices);
              }
          }
      
          public void calculateMostValuableVertexInternal(Vertex vertex, Map<Vertex, Boolean> visitedVertices) {
              List<Vertex> neighbours = adjVertices.get(vertex);
              visitedVertices.put(vertex, true);
              int max = vertex.r;
      
              for (Vertex neighbour: neighbours) {
                  if (visitedVertices.get(neighbour)) {
                      max = Math.max(max, neighbour.m);
                  } else {
                      calculateMostValuableVertexInternal(neighbour, visitedVertices);
                      max = Math.max(max, neighbour.m);
                  }
              }
      
              vertex.m = max;
          }
      
          @Override
          public String toString() {
              StringBuilder sb = new StringBuilder();
              Iterator<Map.Entry<Vertex, List<Vertex>>> iter = adjVertices.entrySet().iterator();
              while (iter.hasNext()) {
                  Map.Entry<Vertex, List<Vertex>> entry = iter.next();
                  sb.append(entry.getKey());
                  sb.append('=').append('"');
                  sb.append(entry.getValue());
                  sb.append('"');
                  if (iter.hasNext()) {
                      sb.append(',').append('\n');
                  }
              }
      
              return "Graph{" +
                      "adjVertices=\n" + sb +
                      '}';
          }
      }
      

    最后,要运行上面的逻辑,你可以这样做:

    Graph g = new Graph();
    
    g.addVertex("A", 1, 1);
    g.addVertex("B", 3, 3);
    g.addVertex("C", 2, 2);
    g.addVertex("D", 4, 4);
    
    g.addEdge("A", "B");
    g.addEdge("C", "B");
    g.addEdge("A", "D");
    
    g.calculateMostValuableVertex();
    
    System.out.println(g);
    

    上面的输出是:

    Graph{adjVertices=
    Vertex{label='A', r=1, m=4}="[Vertex{label='B', r=3, m=3}, Vertex{label='D', r=4, m=4}]",
    Vertex{label='D', r=4, m=4}="[]",
    Vertex{label='B', r=3, m=3}="[]",
    Vertex{label='C', r=2, m=3}="[Vertex{label='B', r=3, m=3}]"}
    

    正如预期的那样。它也支持带循环的图。例如输出:

    Graph g = new Graph();
    
    g.addVertex("A", 1, 1);
    g.addVertex("B", 3, 3);
    g.addVertex("C", 2, 2);
    g.addVertex("D", 4, 4);
    g.addVertex("E", 5, 5);
    g.addVertex("F", 6, 6);
    g.addVertex("G", 7, 7);
    
    g.addEdge("A", "B");
    g.addEdge("C", "B");
    g.addEdge("A", "D");
    g.addEdge("A", "E");
    g.addEdge("E", "F");
    g.addEdge("F", "G");
    g.addEdge("G", "A");
    
    g.calculateMostValuableVertex();
    
    System.out.println(g);
    

    是:

    Graph{adjVertices=
    Vertex{label='A', r=1, m=7}="[Vertex{label='B', r=3, m=3}, Vertex{label='D', r=4, m=4}, Vertex{label='E', r=5, m=7}]",
    Vertex{label='B', r=3, m=3}="[]",
    Vertex{label='C', r=2, m=3}="[Vertex{label='B', r=3, m=3}]",
    Vertex{label='D', r=4, m=4}="[]",
    Vertex{label='E', r=5, m=7}="[Vertex{label='F', r=6, m=7}]",
    Vertex{label='F', r=6, m=7}="[Vertex{label='G', r=7, m=7}]",
    Vertex{label='G', r=7, m=7}="[Vertex{label='A', r=1, m=7}]"}
    

    【讨论】:

    • 当图表有循环时这是否有效?
    • @DavidEisenstat 实际上我有一个错误,但我修复了它并添加了示例
    • @DavidEisenstat 您能否也添加一个简单的算法作为答案?我读到你的大部分答案都很简单,但我的问题中的链接答案很复杂
    • @DavidEisenstat 因为这些答案都不足以设置赏金。
    • @fiona2019 你试过我的解决方案了吗?它对你不起作用?什么不起作用?
    【解决方案3】:

    如何解决问题?

    1. 有向图中的可达顶点
    • 给定顶点可以访问哪些顶点?
    • 哪些顶点可以访问给定的顶点?

    我们正在处理有向图。所以,对于这个问题,我们需要找到strongly connected components来高效回答上述问题。

    1. 一旦我们知道了强连接的组件,我们就可以处理最高价值的部分。

    在每个强连接组件中,最高价值是多少?相应地更新。

    这两个步骤都可以使用 O(V + E)。通过适当的思考过程,我相信它应该能够一次性完成这两个步骤。

    如何找到强连通分量?

    1. Kosaraju's algorithm
    2. Tarjan's algorithm
    3. Path-based strong component algorithm
    • 如果您正在寻找简单的东西,请选择 Kosaraju 的算法。对我来说,它是上述三个中最简单的一个。
    • 如果您追求效率,Kosaraju 的算法需要两次深度优先遍历,但其他两种算法在 1 次深度优先遍历中完成相同的操作。
    • A Space-Efficient Algorithm for Finding Strongly Connected Components 提到 Tarjan 的算法最多需要 v(2 + 5w) 位存储空间,其中 w 是机器的字长。论文中提到的改进在最坏的情况下将空间需求减少到 v(1 + 3w) 位。

    实施:

    显然,您正在寻找某种类型的实现。

    【讨论】:

    • 非常好,非常简单。这是完全可以理解的。一部分是需要更多细节。当我找到 SCC 后,我们下一步该怎么做?
    • @fiona2019 假设邻接图是 A: {B}, B: {A}, C: {B, D}, D: {C}。让我们说 A、B、C、D 的价值分别为 1、2、3、4。在给定的图中,有两个强连通分量(A,B)和(C,D)。第一个 SCC 的最大价值为 2。因此将 A、B 的最大价值更新为 2。同样,将 C、D 的价值更新为 4。完成。很简单。
    • 如果你可以很容易地描述我的算法,请接受这就是我的答案并接受它。 1)我们将图转换为SCC。那么在 SCC 图上使用反向拓扑?那么呢?
    • @fiona2019:我们不会将图表转换为 SCC。我们只是弄清楚 SCC 是什么。在我的答案中显示的图像中,带有虚线边框的区域是 SCC。例如a、b、e 是一个 SCC。运行一个简单的 for 循环并了解什么是 a、b、e 的最大价值。假设 a、b、e 的价值分别为 10、20、30。因此,顶点 e 具有最大价值,即 30。因此,将 a 和 b 的顶点的价值更新为 30。对我的答案中显示的图中的其他两个 SCC 执行相同的操作。
    【解决方案4】:

    在实践中,我会使用 Ehsan 的答案中的算法,但不是 O(V+E)。如果你真的需要这种复杂性,那么你可以这样做:

    1. 使用例如Tarjan's algorithm 将图划分为强连接组件,这是 O(V+E)。
    2. 制作 SCC 图表。 SCC 中的每个节点都可以从其他节点访问,因此新图中每个 SCC 的节点在 SCC 中获得最高的 r 值。你也可以在 O(V+E) 中做到这一点。
    3. SCC 的图是非循环的,所以你可以做一个topological sort。所有流行的算法都是 O(V+E)。
    4. 以反向拓扑顺序处理 SCC 节点,计算来自邻居的每个 m。因为所有的边都指向较晚的节点,所以每个节点的输入将在您到达它时完成。这也是 O(V+E)。
    5. 遍历原始图,将每个节点的m 设置为其在 SCC 图中的组件的值。 O(V)

    【讨论】:

    • 它确实适用于 O(V+E) !你说的不是 O(V+E) !我想你说的那个算法是对的吗?
    • 你的意思是你所说的关于 Ehsan 的回答?是的,你是对的。他更正了复杂性声明。
    • 但是你的好算法在 O(V+E) 中有效,对吗?可以举一个小例子还是太长了?我认为这是一个很好的问题。也很好的答案。如果有简单的短图显示每个步骤的输出非常好。
    • 能否请您清除“因为所有的边都指向较晚的节点,所以每个节点的输入将在您到达时完成。”这句话的一些误解。
    • 拓扑排序对顶点进行排序,以便图中的每条边从顺序中较早的顶点指向较晚的顶点。如果您以 reverse 拓扑顺序访问顶点,则当前顶点的所有边都将指向您已已经访问过的顶点。由于您已经访问过它们,它们将具有正确的m 值,因此您只需选择最大值并与当前顶点r 进行比较,即可计算出当前顶点的m。跨度>
    【解决方案5】:

    使用以下O(E+V*log(V)) 算法:

    - Reverse all directions
    - while |V| > 0 do
        find max(v) from remaining nodes in V
        from that node execute DFS and find all reachable nodes and update their m as max(V)
        remove all updated nodes from V
    

    这个算法的时间复杂度是你的要求O(V*log(V)+E)

    【讨论】:

    • 你如何找到 Max (V)?最大时间复杂度?
    • O(n) 其中 n 是 V 中的剩余节点。最后,您将只解析每个节点一次,然后它就是 O(|V|)
    • 假设数组是反向排序的。在第一次迭代中,您先解析 O(n),然后解析 O(n-1),然后解析 O(n-2) ... 以获得最大值!我错了吗?
    • 实际上在每一步中至少一个节点将从V中删除。如果从DFS扩展的子树只包含1个节点。那么是的,在最坏的情况下你有 O(n)+O(n-1)+... 等于 O(n^2) 。您也可以在开始时按 O(n*log(n)) 对元素进行排序以避免最坏的情况
    • 如果你排序,那么你的时间不是 O(V+E) 这正是这里的问题
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2015-07-04
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多