Open In App

Check if a graph is Strongly, Unilaterally or Weakly connected

Last Updated : 15 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an unweighted directed graph G as a path matrix, the task is to find out if the graph is Strongly Connected or Unilaterally Connected or Weakly Connected. 

  • Strongly Connected: A graph is said to be strongly connected if every pair of vertices(u, v) in the graph contains a path between each other. In an unweighted directed graph G, every pair of vertices u and v should have a path in each direction between them i.e., bidirectional path. The elements of the path matrix of such a graph will contain all 1's.
  • Unilaterally Connected: A graph is said to be unilaterally connected if it contains a directed path from u to v OR a directed path from v to u for every pair of vertices u, v. Hence, at least for any pair of vertices, one vertex should be reachable form the other. Such a path matrix would rather have upper triangle elements containing 1's OR lower triangle elements containing 1's.
  • Weakly Connected: A directed graph is weakly connected if there is a path between every two vertices in the underlying undirected graph (i.e, the graph formed when the direction of the edges are removed).

Examples: 

Input: Below is the given graph with path matrix: 
 


Output: Strongly Connected Graph 
Input: Below is the given graph with path matrix: 
 


Output: Unilaterally Connected Graph
Input: Below is the given graph with path matrix: 
 


Output: Weakly Connected Graph 
 

Approach: 

  1. For the graph to be Strongly Connected, traverse the given path matrix using the approach discussed in this article check whether all the values in the cell are 1 or not. If yes then print "Strongly Connected Graph" else check for the other two graphs.
  2. For the graph to be Unilaterally Connected, traverse the given path matrix using the approach discussed in this article and check the following: 
    • If all the values above the main diagonal are 1s and all the values other than that are 0s.
    • If all the values below the main diagonal are 1s and all the values other than that are 0s.
  3. If one of the above two conditions satisfies then the given graph is Unilaterally Connected else the graph is Weakly Connected Graph.

Below is the implementation of the above approach:
 

C++ 
// C++ implementation of the approach

#include <bits/stdc++.h>
using namespace std;
#define V 3

// Function to find the characteristic
// of the given graph
int checkConnected(int graph[][V], int n)
{

    // Check whether the graph is
    // strongly connected or not
    bool strongly = true;

    // Traverse the path matrix
    for (int i = 0; i < n; i++) {

        for (int j = 0; j < n; j++) {

            // If all the elements are
            // not equal then the graph
            // is not strongly connected
            if (graph[i][j] != graph[j][i]) {
                strongly = false;
                break;
            }
        }

        // Break out of the loop if false
        if (!strongly) {
            break;
        }
    }
    // If true then print strongly
    // connected and return
    if (strongly) {
        cout << "Strongly Connected";
        return 0;
    }

    // Check whether the graph is
    // Unilaterally connected by
    // checking Upper Triangle element
    bool uppertri = true;

    // Traverse the path matrix
    for (int i = 0; i < n; i++) {

        for (int j = 0; j < n; j++) {

            // If uppertriangle elements
            // are 0 then break out of the
            // loop and check the elements
            // of lowertriangle matrix
            if (i > j && graph[i][j] == 0) {
                uppertri = false;
                break;
            }
        }

        // Break out of the loop if false
        if (!uppertri) {
            break;
        }
    }

    // If true then print unilaterally
    // connected and return
    if (uppertri) {
        cout << "Unilaterally Connected";
        return 0;
    }

    // Check lowertraingle elements
    bool lowertri = true;

    // Traverse the path matrix
    for (int i = 0; i < n; i++) {

        for (int j = 0; j < n; j++) {

            // If lowertraingle elements
            // are 0 then break cause
            // 1's are expected
            if (i < j && graph[i][j] == 0) {
                lowertri = false;
                break;
            }
        }

        // Break out of the loop if false
        if (!lowertri) {
            break;
        }
    }

    // If true then print unilaterally
    // connected and return
    if (lowertri) {
        cout << "Unilaterally Connected";
        return 0;
    }

    // If elements are in random order
    // unsynchronized then print weakly
    // connected and return
    else {
        cout << "Weakly Connected";
    }

    return 0;
}

// Driver Code
int main()
{
    // Number of nodes
    int n = 3;

    // Given Path Matrix
    int graph[V][V] = {
        { 0, 1, 1 },
        { 0, 0, 1 },
        { 0, 0, 0 },
    };

    // Function Call
    checkConnected(graph, n);
    return 0;
}
Java 
// Java implementation of the above approach
import java.util.*;

class GFG {

    static final int V = 3;

    // Function to find the characteristic
    // of the given graph
    static int checkConnected(int graph[][], int n)
    {

        // Check whether the graph is
        // strongly connected or not
        boolean strongly = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If all the elements are
                // not equal then the graph
                // is not strongly connected
                if (graph[i][j] != graph[j][i]) {
                    strongly = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!strongly) {
                break;
            }
        }

        // If true then print strongly
        // connected and return
        if (strongly) {
            System.out.print("Strongly Connected");
            return 0;
        }

        // Check whether the graph is
        // Unilaterally connected by
        // checking Upper Triangle element
        boolean uppertri = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If uppertriangle elements
                // are 0 then break out of the
                // loop and check the elements
                // of lowertriangle matrix
                if (i > j && graph[i][j] == 0) {
                    uppertri = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!uppertri) {
                break;
            }
        }

        // If true then print unilaterally
        // connected and return
        if (uppertri) {
            System.out.print("Unilaterally Connected");
            return 0;
        }

        // Check lowertraingle elements
        boolean lowertri = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If lowertraingle elements
                // are 0 then break cause
                // 1's are expected
                if (i < j && graph[i][j] == 0) {
                    lowertri = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!lowertri) {
                break;
            }
        }

        // If true then print unilaterally
        // connected and return
        if (lowertri) {
            System.out.print("Unilaterally Connected");
            return 0;
        }

        // If elements are in random order
        // unsynchronized then print weakly
        // connected and return
        else {
            System.out.print("Weakly Connected");
        }
        return 0;
    }

    // Driver Code
    public static void main(String[] args)
    {

        // Number of nodes
        int n = 3;

        // Given Path Matrix
        int graph[][]
            = { { 0, 1, 1 }, { 0, 0, 1 }, { 0, 0, 0 } };

        // Function call
        checkConnected(graph, n);
    }
}

// This code is contributed by 29AjayKumar
Python3 
# Python3 implementation of
# the above approach
V = 3

# Function to find the
# characteristic of the
# given graph


def checkConnected(graph, n):

    # Check whether the graph is
    # strongly connected or not
    strongly = True

    # Traverse the path
    # matrix
    for i in range(n):
        for j in range(n):

            # If all the elements are
            # not equal then the graph
            # is not strongly connected
            if (graph[i][j] != graph[j][i]):
                strongly = False
                break

        # Break out of the
        # loop if false
        if not strongly:
            break

    # If true then print
    # strongly connected and return
    if (strongly):
        print("Strongly Connected")
        exit()

    # Check whether the graph is
    # Unilaterally connected by
    # checking Upper Triangle element
    uppertri = True

    # Traverse the path matrix
    for i in range(n):
        for j in range(n):

            # If uppertriangle elements
            # are 0 then break out of the
            # loop and check the elements
            # of lowertriangle matrix
            if (i > j and graph[i][j] == 0):
                uppertri = False
                break

        # Break out of the
        # loop if false
        if not uppertri:
            break

    # If true then print
    # unilaterally connected
    # and return
    if uppertri:
        print("Unilaterally Connected")
        exit()

    # Check lowertraingle elements
    lowertri = True

    # Traverse the path matrix
    for i in range(n):
        for j in range(n):

            # If lowertraingle elements
            # are 0 then break cause
            # 1's are expected
            if (i < j and graph[i][j] == 0):
                lowertri = False
                break

        # Break out of the
        # loop if false
        if not lowertri:
            break

    # If true then print
    # unilaterally connected
    # and return
    if lowertri:
        print("Unilaterally Connected")
        exit()

    # If elements are in random order
    # unsynchronized then print weakly
    # connected and return
    else:
        print("Weakly Connected")

    exit()


if __name__ == "__main__":

    # Number of nodes
    n = 3

    # Given Path Matrix
    graph = [[0, 1, 1],
             [0, 0, 1],
             [0, 0, 0]]

    # Function Call
    checkConnected(graph, n)

 # This code is contributed by rutvik_56
C# 
// C# implementation of the above approach
using System;

class GFG {

    // static readonly int V = 3;

    // Function to find the characteristic
    // of the given graph
    static int checkConnected(int[, ] graph, int n)
    {

        // Check whether the graph is
        // strongly connected or not
        bool strongly = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If all the elements are
                // not equal then the graph
                // is not strongly connected
                if (graph[i, j] != graph[j, i]) {
                    strongly = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!strongly) {
                break;
            }
        }

        // If true then print strongly
        // connected and return
        if (strongly) {
            Console.Write("Strongly Connected");
            return 0;
        }

        // Check whether the graph is
        // Unilaterally connected by
        // checking Upper Triangle element
        bool uppertri = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If uppertriangle elements
                // are 0 then break out of the
                // loop and check the elements
                // of lowertriangle matrix
                if (i > j && graph[i, j] == 0) {
                    uppertri = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!uppertri) {
                break;
            }
        }

        // If true then print unilaterally
        // connected and return
        if (uppertri) {
            Console.Write("Unilaterally Connected");
            return 0;
        }

        // Check lowertraingle elements
        bool lowertri = true;

        // Traverse the path matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {

                // If lowertraingle elements
                // are 0 then break cause
                // 1's are expected
                if (i < j && graph[i, j] == 0) {
                    lowertri = false;
                    break;
                }
            }

            // Break out of the loop if false
            if (!lowertri) {
                break;
            }
        }

        // If true then print unilaterally
        // connected and return
        if (lowertri) {
            Console.Write("Unilaterally Connected");
            return 0;
        }

        // If elements are in random order
        // unsynchronized then print weakly
        // connected and return
        else {
            Console.Write("Weakly Connected");
        }
        return 0;
    }

    // Driver Code
    public static void Main(String[] args)
    {

        // Number of nodes
        int n = 3;

        // Given Path Matrix
        int[, ] graph
            = { { 0, 1, 1 }, { 0, 0, 1 }, { 0, 0, 0 } };

        // Function call
        checkConnected(graph, n);
    }
}

// This code is contributed by 29AjayKumar
JavaScript 
<script>
// Javascript implementation of the above approach

let V = 3; 

// Function to find the characteristic 
// of the given graph 
function checkConnected(graph, n) 
{ 
    
    // Check whether the graph is 
    // strongly connected or not 
    let strongly = true; 

    // Traverse the path matrix 
    for(let i = 0; i < n; i++) 
    { 
        for(let j = 0; j < n; j++) 
        { 
            
            // If all the elements are 
            // not equal then the graph 
            // is not strongly connected 
            if (graph[i][j] != graph[j][i]) 
            { 
                strongly = false; 
                break; 
            } 
        } 
        
        // Break out of the loop if false 
        if (!strongly) 
        { 
            break; 
        } 
    } 
    
    // If true then print strongly 
    // connected and return 
    if (strongly) 
    { 
        document.write("Strongly Connected"); 
        return 0; 
    } 

    // Check whether the graph is 
    // Unilaterally connected by 
    // checking Upper Triangle element 
    let uppertri = true; 

    // Traverse the path matrix 
    for(let i = 0; i < n; i++) 
    { 
        for(let j = 0; j < n; j++) 
        { 
            
            // If uppertriangle elements 
            // are 0 then break out of the 
            // loop and check the elements 
            // of lowertriangle matrix 
            if (i > j && graph[i][j] == 0) 
            { 
                uppertri = false; 
                break; 
            } 
        } 

        // Break out of the loop if false 
        if (!uppertri) 
        { 
            break; 
        } 
    } 

    // If true then print unilaterally 
    // connected and return 
    if (uppertri) 
    { 
        document.write("Unilaterally Connected"); 
        return 0; 
    } 

    // Check lowertraingle elements 
    let lowertri = true; 

    // Traverse the path matrix 
    for(let i = 0; i < n; i++) 
    { 
        for(let j = 0; j < n; j++) 
        { 
            
            // If lowertraingle elements 
            // are 0 then break cause 
            // 1's are expected 
            if (i < j && graph[i][j] == 0) 
            { 
                lowertri = false; 
                break; 
            } 
        } 
        
        // Break out of the loop if false 
        if (!lowertri) 
        { 
            break; 
        } 
    } 

    // If true then print unilaterally 
    // connected and return 
    if (lowertri) 
    { 
        document.write("Unilaterally Connected"); 
        return 0; 
    } 

    // If elements are in random order 
    // unsynchronized then print weakly 
    // connected and return 
    else
    { 
        document.write("Weakly Connected"); 
    } 
    return 0; 
} 


    // Driver Code
    
    // Number of nodes 
    let n = 3; 

    // Given Path Matrix 
    let graph = [[ 0, 1, 1 ], 
                      [ 0, 0, 1 ], 
                      [ 0, 0, 0 ]]; 
                        
    // Function call 
    checkConnected(graph, n); 

// This code is contributed by susmitakundugoaldanga.
</script>

Output
Unilaterally Connected

Time Complexity: O(N2) 
Auxiliary Space: O(1)


Next Article
Analysis of Algorithms

S
shreedhar_bhatt
Improve
Article Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox