Determine whether a universal sink exists in a directed graph
Last Updated :
23 Jul, 2025
Determine whether a universal sink exists in a directed graph. A universal sink is a vertex which has no edge emanating from it, and all other vertices have an edge towards the sink.
Input :
v1 -> v2 (implies vertex 1 is connected to vertex 2)
v3 -> v2
v4 -> v2
v5 -> v2
v6 -> v2
Output :
Sink found at vertex 2
Input :
v1 -> v6
v2 -> v3
v2 -> v4
v4 -> v3
v5 -> v3
Output :
No Sink
We try to eliminate n - 1 non-sink vertices in O(n) time and check the remaining vertex for the sink property.
To eliminate vertices, we check whether a particular index (A[i][j]) in the adjacency matrix is a 1 or a 0. If it is a 0, it means that the vertex corresponding to index j cannot be a sink. If the index is a 1, it means the vertex corresponding to i cannot be a sink. We keep increasing i and j in this fashion until either i or j exceeds the number of vertices.
Using this method allows us to carry out the universal sink test for only one vertex instead of all n vertices. Suppose we are left with only vertex i.
We now check for whether row i has only 0s and whether row j as only 1s except for A[i][i], which will be 0.
Illustration :
v1 -> v2
v3 -> v2
v4 -> v2
v5 -> v2
v6 -> v2
We can visualize the adjacency matrix for
the above as follows:
0 1 0 0 0 0
0 0 0 0 0 0
0 1 0 0 0 0
0 1 0 0 0 0
0 1 0 0 0 0
We observe that vertex 2 does not have any emanating edge, and that every other vertex has an edge in vertex 2. At A[0][0] (A[i][j]), we encounter a 0, so we increment j and next look at A[0][1]. Here we encounter a 1. So we have to increment i by 1. A[1][1] is 0, so we keep increasing j.
We notice that A[1][2], A[1][3].. etc are all 0, so j will exceed the number of vertices (6 in this example). We now check row i and column i for the sink property. Row i must be completely 0, and column i must be completely 1 except for the index A[i][i]
Adjacency Matrix
Second Example:
v1 -> v6
v2 -> v3
v2 -> v4
v4 -> v3
v5 -> v3
We can visualize the adjacency matrix
for the above as follows:
0 0 0 0 0 1
0 0 1 1 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
In this example, we observer that in row 1, every element is 0 except for the last column. So we will increment j until we reach the 1. When we reach 1, we increment i as long as the value of A[i][j] is 0. If i exceeds the number of vertices, it is not possible to have a sink, and in this case, i will exceed the number of vertices.
Adjacency Matrix
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
class Graph {
int vertices;
int adjacency_matrix[MAX][MAX];
public:
Graph(int vertices)
{
this->vertices = vertices;
memset(adjacency_matrix, 0,
sizeof(adjacency_matrix));
}
void insert(int source, int destination)
{
adjacency_matrix[source - 1][destination - 1] = 1;
}
bool is_sink(int i)
{
for (int j = 0; j < vertices; j++) {
if (adjacency_matrix[i][j] == 1)
return false;
if (adjacency_matrix[j][i] == 0 && j != i)
return false;
}
return true;
}
int eliminate()
{
int i = 0, j = 0;
while (i < vertices && j < vertices) {
if (adjacency_matrix[i][j] == 1)
i = i + 1;
else
j = j + 1;
}
if (i > vertices)
return -1;
else if (!is_sink(i))
return -1;
else
return i;
}
};
int main()
{
int number_of_vertices = 6, number_of_edges = 5;
Graph g(number_of_vertices);
g.insert(1, 6);
g.insert(2, 3);
g.insert(2, 4);
g.insert(4, 3);
g.insert(5, 3);
int vertex = g.eliminate();
if (vertex >= 0)
cout << "Sink found at vertex " << (vertex + 1)
<< endl;
else
cout << "No Sink" << endl;
return 0;
}
//This Code is Contributed by chinmaya121221
// Java program to find whether a universal sink
// exists in a directed graph
import java.io.*;
import java.util.*;
class graph
{
int vertices;
int[][] adjacency_matrix;
// constructor to initialize number of vertices and
// size of adjacency matrix
public graph(int vertices)
{
this.vertices = vertices;
adjacency_matrix = new int[vertices][vertices];
}
public void insert(int source, int destination)
{
// make adjacency_matrix[i][j] = 1 if there is
// an edge from i to j
adjacency_matrix[source - 1][destination-1] = 1;
}
public boolean issink(int i)
{
for (int j = 0 ; j < vertices ; j++)
{
// if any element in the row i is 1, it means
// that there is an edge emanating from the
// vertex, which means it cannot be a sink
if (adjacency_matrix[i][j] == 1)
return false;
// if any element other than i in the column
// i is 0, it means that there is no edge from
// that vertex to the vertex we are testing
// and hence it cannot be a sink
if (adjacency_matrix[j][i] == 0 && j != i)
return false;
}
//if none of the checks fails, return true
return true;
}
// we will eliminate n-1 non sink vertices so that
// we have to check for only one vertex instead of
// all n vertices
public int eliminate()
{
int i = 0, j = 0;
while (i < vertices && j < vertices)
{
// If the index is 1, increment the row we are
// checking by 1
// else increment the column
if (adjacency_matrix[i][j] == 1)
i = i + 1;
else
j = j + 1;
}
// If i exceeds the number of vertices, it
// means that there is no valid vertex in
// the given vertices that can be a sink
if (i > vertices)
return -1;
else if (!issink(i))
return -1;
else return i;
}
}
public class Sink
{
public static void main(String[] args)throws IOException
{
int number_of_vertices = 6;
int number_of_edges = 5;
graph g = new graph(number_of_vertices);
/*
//input set 1
g.insert(1, 6);
g.insert(2, 6);
g.insert(3, 6);
g.insert(4, 6);
g.insert(5, 6);
*/
//input set 2
g.insert(1, 6);
g.insert(2, 3);
g.insert(2, 4);
g.insert(4, 3);
g.insert(5, 3);
int vertex = g.eliminate();
// returns 0 based indexing of vertex. returns
// -1 if no sink exits.
// returns the vertex number-1 if sink is found
if (vertex >= 0)
System.out.println("Sink found at vertex "
+ (vertex + 1));
else
System.out.println("No Sink");
}
}
# Python3 program to find whether a
# universal sink exists in a directed graph
class Graph:
# constructor to initialize number of
# vertices and size of adjacency matrix
def __init__(self, vertices):
self.vertices = vertices
self.adjacency_matrix = [[0 for i in range(vertices)]
for j in range(vertices)]
def insert(self, s, destination):
# make adjacency_matrix[i][j] = 1
# if there is an edge from i to j
self.adjacency_matrix[s - 1][destination - 1] = 1
def issink(self, i):
for j in range(self.vertices):
# if any element in the row i is 1, it means
# that there is an edge emanating from the
# vertex, which means it cannot be a sink
if self.adjacency_matrix[i][j] == 1:
return False
# if any element other than i in the column
# i is 0, it means that there is no edge from
# that vertex to the vertex we are testing
# and hence it cannot be a sink
if self.adjacency_matrix[j][i] == 0 and j != i:
return False
# if none of the checks fails, return true
return True
# we will eliminate n-1 non sink vertices so that
# we have to check for only one vertex instead of
# all n vertices
def eliminate(self):
i = 0
j = 0
while i < self.vertices and j < self.vertices:
# If the index is 1, increment the row
# we are checking by 1
# else increment the column
if self.adjacency_matrix[i][j] == 1:
i += 1
else:
j += 1
# If i exceeds the number of vertices, it
# means that there is no valid vertex in
# the given vertices that can be a sink
if i > self.vertices:
return -1
elif self.issink(i) is False:
return -1
else:
return i
# Driver Code
if __name__ == "__main__":
number_of_vertices = 6
number_of_edges = 5
g = Graph(number_of_vertices)
# input set 1
# g.insert(1, 6)
# g.insert(2, 6)
# g.insert(3, 6)
# g.insert(4, 6)
# g.insert(5, 6)
# input set 2
g.insert(1, 6)
g.insert(2, 3)
g.insert(2, 4)
g.insert(4, 3)
g.insert(5, 3)
vertex = g.eliminate()
# returns 0 based indexing of vertex.
# returns -1 if no sink exits.
# returns the vertex number-1 if sink is found
if vertex >= 0:
print("Sink found at vertex %d" % (vertex + 1))
else:
print("No Sink")
# This code is contributed by
# sanjeev2552
// C# program to find whether a universal sink
// exists in a directed graph
using System;
using System.Collections.Generic;
class graph
{
int vertices, itr;
int[,] adjacency_matrix;
// constructor to initialize number of vertices and
// size of adjacency matrix
public graph(int vertices)
{
this.vertices = vertices;
adjacency_matrix = new int[vertices, vertices];
}
public void insert(int source, int destination)
{
// make adjacency_matrix[i,j] = 1 if there is
// an edge from i to j
adjacency_matrix[source - 1, destination - 1] = 1;
}
public bool issink(int i)
{
for (int j = 0 ; j < vertices ; j++)
{
// if any element in the row i is 1, it means
// that there is an edge emanating from the
// vertex, which means it cannot be a sink
if (adjacency_matrix[i, j] == 1)
return false;
// if any element other than i in the column
// i is 0, it means that there is no edge from
// that vertex to the vertex we are testing
// and hence it cannot be a sink
if (adjacency_matrix[j, i] == 0 && j != i)
return false;
}
//if none of the checks fails, return true
return true;
}
// we will eliminate n-1 non sink vertices so that
// we have to check for only one vertex instead of
// all n vertices
public int eliminate()
{
int i = 0, j = 0;
while (i < vertices && j < vertices)
{
// If the index is 1, increment the row we are
// checking by 1
// else increment the column
if (adjacency_matrix[i, j] == 1)
i = i + 1;
else
j = j + 1;
}
// If i exceeds the number of vertices, it
// means that there is no valid vertex in
// the given vertices that can be a sink
if (i > vertices)
return -1;
else if (!issink(i))
return -1;
else return i;
}
}
public class Sink
{
public static void Main(String[] args)
{
int number_of_vertices = 6;
graph g = new graph(number_of_vertices);
/*
//input set 1
g.insert(1, 6);
g.insert(2, 6);
g.insert(3, 6);
g.insert(4, 6);
g.insert(5, 6);
*/
//input set 2
g.insert(1, 6);
g.insert(2, 3);
g.insert(2, 4);
g.insert(4, 3);
g.insert(5, 3);
int vertex = g.eliminate();
// returns 0 based indexing of vertex. returns
// -1 if no sink exits.
// returns the vertex number-1 if sink is found
if (vertex >= 0)
Console.WriteLine("Sink found at vertex "
+ (vertex + 1));
else
Console.WriteLine("No Sink");
}
}
// This code is contributed by Rajput-Ji
<script>
// JavaScript program to find whether a
// universal sink exists in a directed graph
class Graph{
// constructor to initialize number of
// vertices and size of adjacency matrix
constructor(vertices){
this.vertices = vertices
this.adjacency_matrix = new Array(this.vertices).fill(0).map(()=>new Array(this.vertices).fill(0))
}
insert(s, destination){
// make adjacency_matrix[i][j] = 1
// if there is an edge from i to j
this.adjacency_matrix[s - 1][destination - 1] = 1
}
issink(i){
for(let j=0;j<this.vertices;j++){
// if any element in the row i is 1, it means
// that there is an edge emanating from the
// vertex, which means it cannot be a sink
if(this.adjacency_matrix[i][j] == 1)
return false
// if any element other than i in the column
// i is 0, it means that there is no edge from
// that vertex to the vertex we are testing
// and hence it cannot be a sink
if(this.adjacency_matrix[j][i] == 0 && j != i)
return false
}
// if none of the checks fails, return true
return true
}
// we will eliminate n-1 non sink vertices so that
// we have to check for only one vertex instead of
// all n vertices
eliminate(){
let i = 0
let j = 0
while(i < this.vertices && j < this.vertices){
// If the index is 1, increment the row
// we are checking by 1
// else increment the column
if(this.adjacency_matrix[i][j] == 1)
i += 1
else
j += 1
}
// If i exceeds the number of vertices, it
// means that there is no valid vertex in
// the given vertices that can be a sink
if(i > this.vertices)
return -1
else if(this.issink(i) == false)
return -1
else
return i
}
}
// Driver Code
let number_of_vertices = 6
let number_of_edges = 5
let g = new Graph(number_of_vertices)
// input set 1
// g.insert(1, 6)
// g.insert(2, 6)
// g.insert(3, 6)
// g.insert(4, 6)
// g.insert(5, 6)
// input set 2
g.insert(1, 6)
g.insert(2, 3)
g.insert(2, 4)
g.insert(4, 3)
g.insert(5, 3)
let vertex = g.eliminate()
// returns 0 based indexing of vertex.
// returns -1 if no sink exits.
// returns the vertex number-1 if sink is found
if(vertex >= 0)
document.write(`Sink found at vertex ${(vertex + 1)}`,"</br>")
else
document.write("No Sink","</br>")
// This code is contributed by shinjanpatra
</script>
This program eliminates non-sink vertices in O(n) complexity and checks for the sink property in O(n) complexity.
Time complexity: O(V^2)
We have used a 2-D array of size V x V to store the adjacency matrix of the given graph. The time complexity of the algorithm is O(V^2) as we need to traverse the complete adjacency matrix to find the sink vertex.
Time complexity: O(V^2)
The space complexity of the algorithm is also O(V^2) since we need to store the adjacency matrix.
You may also try The Celebrity Problem, which is an application of this concept
Similar Reads
Graph Algorithms Graph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Introduction to Graph Data Structure Graph Data Structure is a non-linear data structure consisting of vertices and edges. It is useful in fields such as social network analysis, recommendation systems, and computer networks. In the field of sports data science, graph data structure can be used to analyze and understand the dynamics of
15+ min read
Graph and its representations A Graph is a non-linear data structure consisting of vertices and edges. The vertices are sometimes also referred to as nodes and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph is composed of a set of vertices( V ) and a set of edges( E ). The graph is den
12 min read
Types of Graphs with Examples A graph is a mathematical structure that represents relationships between objects by connecting a set of points. It is used to establish a pairwise relationship between elements in a given set. graphs are widely used in discrete mathematics, computer science, and network theory to represent relation
9 min read
Basic Properties of a Graph A Graph is a non-linear data structure consisting of nodes and edges. The nodes are sometimes also referred to as vertices and the edges are lines or arcs that connect any two nodes in the graph. The basic properties of a graph include: Vertices (nodes): The points where edges meet in a graph are kn
4 min read
Applications, Advantages and Disadvantages of Graph Graph is a non-linear data structure that contains nodes (vertices) and edges. A graph is a collection of set of vertices and edges (formed by connecting two vertices). A graph is defined as G = {V, E} where V is the set of vertices and E is the set of edges. Graphs can be used to model a wide varie
7 min read
Transpose graph Transpose of a directed graph G is another directed graph on the same set of vertices with all of the edges reversed compared to the orientation of the corresponding edges in G. That is, if G contains an edge (u, v) then the converse/transpose/reverse of G contains an edge (v, u) and vice versa. Giv
9 min read
Difference Between Graph and Tree Graphs and trees are two fundamental data structures used in computer science to represent relationships between objects. While they share some similarities, they also have distinct differences that make them suitable for different applications. Difference Between Graph and Tree What is Graph?A grap
2 min read
BFS and DFS on Graph
Breadth First Search or BFS for a GraphGiven a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Depth First Search or DFS for a GraphIn Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and
13 min read
Applications, Advantages and Disadvantages of Depth First Search (DFS)Depth First Search is a widely used algorithm for traversing a graph. Here we have discussed some applications, advantages, and disadvantages of the algorithm. Applications of Depth First Search:1. Detecting cycle in a graph: A graph has a cycle if and only if we see a back edge during DFS. So we ca
4 min read
Applications, Advantages and Disadvantages of Breadth First Search (BFS)We have earlier discussed Breadth First Traversal Algorithm for Graphs. Here in this article, we will see the applications, advantages, and disadvantages of the Breadth First Search. Applications of Breadth First Search: 1. Shortest Path and Minimum Spanning Tree for unweighted graph: In an unweight
4 min read
Iterative Depth First Traversal of GraphGiven a directed Graph, the task is to perform Depth First Search of the given graph.Note: Start DFS from node 0, and traverse the nodes in the same order as adjacency list.Note : There can be multiple DFS traversals of a graph according to the order in which we pick adjacent vertices. Here we pick
10 min read
BFS for Disconnected GraphIn the previous post, BFS only with a particular vertex is performed i.e. it is assumed that all vertices are reachable from the starting vertex. But in the case of a disconnected graph or any vertex that is unreachable from all vertex, the previous implementation will not give the desired output, s
14 min read
Transitive Closure of a Graph using DFSGiven a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u, v) in the given graph. Here reachable means that there is a path from vertex u to v. The reach-ability matrix is called transitive closure of a graph. For example, consider below graph: GraphTr
8 min read
Difference between BFS and DFSBreadth-First Search (BFS) and Depth-First Search (DFS) are two fundamental algorithms used for traversing or searching graphs and trees. This article covers the basic difference between Breadth-First Search and Depth-First Search.Difference between BFS and DFSParametersBFSDFSStands forBFS stands fo
2 min read
Cycle in a Graph
Detect Cycle in a Directed GraphGiven the number of vertices V and a list of directed edges, determine whether the graph contains a cycle or not.Examples: Input: V = 4, edges[][] = [[0, 1], [0, 2], [1, 2], [2, 0], [2, 3]]Cycle: 0 → 2 → 0 Output: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 0 Input: V = 4, edges[][] =
15+ min read
Detect cycle in an undirected graphGiven an undirected graph, the task is to check if there is a cycle in the given graph.Examples:Input: V = 4, edges[][]= [[0, 1], [0, 2], [1, 2], [2, 3]]Undirected Graph with 4 vertices and 4 edgesOutput: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 1 → 0Input: V = 4, edges[][] = [[0,
8 min read
Detect Cycle in a directed graph using colorsGiven a directed graph represented by the number of vertices V and a list of directed edges, determine whether the graph contains a cycle.Your task is to implement a function that accepts V (number of vertices) and edges (an array of directed edges where each edge is a pair [u, v]), and returns true
9 min read
Detect a negative cycle in a Graph | (Bellman Ford)Given a directed weighted graph, your task is to find whether the given graph contains any negative cycles that are reachable from the source vertex (e.g., node 0).Note: A negative-weight cycle is a cycle in a graph whose edges sum to a negative value.Example:Input: V = 4, edges[][] = [[0, 3, 6], [1
15+ min read
Cycles of length n in an undirected and connected graphGiven an undirected and connected graph and a number n, count the total number of simple cycles of length n in the graph. A simple cycle of length n is defined as a cycle that contains exactly n vertices and n edges. Note that for an undirected graph, each cycle should only be counted once, regardle
10 min read
Detecting negative cycle using Floyd WarshallWe are given a directed graph. We need compute whether the graph has negative cycle or not. A negative cycle is one in which the overall sum of the cycle comes negative. Negative weights are found in various applications of graphs. For example, instead of paying cost for a path, we may get some adva
12 min read
Clone a Directed Acyclic GraphA directed acyclic graph (DAG) is a graph which doesn't contain a cycle and has directed edges. We are given a DAG, we need to clone it, i.e., create another graph that has copy of its vertices and edges connecting them. Examples: Input : 0 - - - > 1 - - - -> 4 | / \ ^ | / \ | | / \ | | / \ |
12 min read