图：找到小于O（| V |）的接收器 - 或者显示无法完成

Question

我有一个图表，其中n节点作为邻接矩阵 。

是否有可能在不到O(n)时间内检测到水槽？

如果有，怎么样？ 如果不是，我们如何证明呢？

接收器顶点是一个顶点，具有来自其他节点的入射边缘，没有出射边缘。

Answer 1

阅读SPWorley提供的链接我被提醒锦标赛树算法找到数字数组中的最小元素。 树顶部的节点是最小元素。 由于链路中的算法也谈到了两个节点之间的竞争（v，w），如果v-> w则由w继承。我们可以使用类似于找到最小元素的算法来找出接收器。 但是，无论是否存在接收器，都返回节点。 但是，如果存在接收器，则总是返回。 因此，我们最终必须检查返回的节点是否为接收器。

//pseudo code
//M -> adjacency matrix
int a=0
for(int i=1;i<vertices;++i)
{
  if(M[a,i]) a=i;
}

//check that a is sink by reading out 2V entries from the matrix
return a; //if a is a sink, otherwise -1

Answer 2

此页面可以回答您的确切问题。 线性时间算法是

   def find-possible-sink(vertices):
     if there's only one vertex, return it
     good-vertices := empty-set
     pair vertices into at most n/2 pairs
     add any left-over vertex to good-vertices
     for each pair (v,w):
       if v -> w:
         add w to good-vertices
       else:
         add v to good-vertices
     return find-possible-sink(good-vertices)

   def find-sink(vertices):
     v := find-possible-sink(vertices)
     if v is actually a sink, return it
     return "there is no spoon^H^H^H^Hink"

Answer 3

相反，假设存在一种查询少于（n-2）/ 2个边缘的算法，并让对手任意回答这些查询。 通过Pigeonhole原理，存在（至少）两个节点v，w，它们不是所查询的任何边的端点。 如果算法输出v，那么对手通过将每个边缘放入具有w的w而使其错误，并且类似地如果算法输出w。

Answer 4

我找到了解决方案。

我假设数组初始化为全0（否则N需要用0填充）并且M是图的邻接矩阵。 我让n为节点数（n = | V |）。

j,i = 1;
N = new int[n]
while (j <= n && i <= n) {
  if (N[i] == 1) {
    i++
  } else if (N[j] == 1) {
    j++;
  } else if (M[i,j] == 1) {
    N[i] = 1
    i++
  } else if (i == j) {
    j++
  } else {
    N[j] = 1
    j++
  }
}
for (z = 1 to n) {
  if (N[z] == 0) {
    return z
  }
}
return NULL

为什么这样做（不是形式证明）：任何带有任何边缘的节点都不是通用接收器。 因此，如果任何j的M [i，j]为1，则我不能成为接收器。

如果对于任何i，M [i，j]为0，则i没有j的边缘，并且j不能是通用接收器。

N [i]处的1表示我知道它不是接收器，并且我知道的任何节点都不是接收器可以在i和j上跳过。 当任何一个进行n时我停止。

这样我就不断检查任何节点，我仍然不知道它是不是一个接收器，直到剩下1或0个可能的接收器。

因此，在循环结束时仍为0的任何节点必须是接收器，并且只有1或0个节点。

为什么是O（n）：这总是增加i或j。 当它们执行n时停止。 因此，环路的最坏情况是2n。 循环中的工作是不变的。 最后一个循环是最坏的情况n。 因此算法是O（3n）= O（n）。

这个解决方案基于名人问题的想法，这是一种考虑同样问题的方法。

Answer 5

有很多算法可以显示如何在O（n）中找到通用接收器，但它们非常复杂且无法轻易理解。 我已经在互联网上找到了它，它展示了如何在O（n）中非常顺利地找到通用接收器。

1) first create a "SINK" set consisting of all vertices of the graph also 
   create an adjacency list of the graph.
2) now choose first 2 elements of the set.
3) if(A(x,y)==1){
       remove x;             // remove x from "SINK" set.
     }else{
       remove y; }           //remove y from "SINK" set.B

通过这个算法，您将在“n-1”时间内在SINK集中结束汇聚节点。 那是O（n）时间。

Answer 6

我一直在研究这个问题，我相信这样做：

int graph::containsUniversalSink() {
/****************************************************************
 Returns: Universal Sink, or -1 if it doesn't exist
 Paramters: Expects an adjacency-matrix to exist called matrix
****************************************************************/

//a universal sink is a Vertex with in-degree |V|-1 and out-degree 0
//a vertex in a graph represented as an adjacency-matrix is a universal sink
//if and only if its row is all 0s and its column is all 1s except the [i,i] entry - path to itself (hence out-degree |V|-1)
//for i=0..|V|-1, j=0..|V|-1
//if m[i][j]==0 then j is not universal sink (unless i==j) - column is not all 1s
//if m[i][j]==1 then i is not universal sink - row is not all 0s
int i=0,j=1;
while (i<numVertices && j<numVertices) {
    if (j>i && matrix[i][j]==true) {
        //we found a 1, disqualifying vertex i, and we're not in the last row (j>i) so we move to that row to see if it's all 0s
        i=j;
        if (j<numVertices-1) {
            //if the row we're moving to is not the last row
            //we want to start checking from one element after the identity element
            //to avoid the possibility of an infinite loop
            j++;
        }
        continue;
    }
    if (j==numVertices-1 && matrix[i][j]==false) {
        //the last element in a row is a 0
        //thus this is the only possible universal sink
        //we have checked the row for 0s from i+1 (or i if we're in the last row) to numVertices-1 (inclusive)
        //we need to check from 0 to i (inclusive)
        for (j=0; j<i+1; j++) {
            if (matrix[i][j]==true || (matrix[j][i]==false && i!=j)) {
                //this row is not all 0s, or this column is not all 1s so return -1 (false)
                return -1;
            }
        }

        //row is all 0s, but we don't know that column is all 1s
        //because we have only checked the column from 0 to i (inclusive), so if i<numVertices-1
        //there could be a 0 in the column
        //so we need to check from i+1 to numVertices-1 (inclusive)
        for (j=i+1; j<numVertices; j++) {
            if (matrix[j][i]==false) {
                return -1;
            }
        }
        //if we get here we have a universal sink, return it
        return i;
    }
    j++;
}

//if we exit the loop there is no universal sink
return -1;

/********************
 Runtime Analysis
 The while loop will execute at most |V| times: j is incremented by 1 on every iteration
 If we reach the end of a row - this can only happen once - then the first for loop will
 execute i times and the second will execute numVertices-i times, for a combined numVertices iterations
 So we have 2|V| loop executions for a run-time bound of O(|V|)
********************/

}

Answer 7

在一般有向图的情况下，不，我不认为它需要一个正式的证据。 最好的情况是，检测接收器需要您识别节点并检查它是否没有传出边缘，或者检查每个其他节点并看到它们都没有来自它的连接。 在实践中，您将两者结合在一个消除算法中，但没有捷径。

顺便说一下，对于接收器的定义存在分歧。 通常不要求所有其他节点连接到接收器，因为您可以有多个接收器。 例如， 此图中的底行是所有接收器，顶行是所有源。 但是，它允许您将复杂性降低到O（n）。 请看这里稍微讨论一下。