Skip to content
Related Articles

Related Articles

Print the lexicographically smallest DFS of the graph starting from 1

Improve Article
Save Article
Like Article
  • Last Updated : 13 Jul, 2021

Given a connected graph with N vertices and M edges. The task is to print the lexicographically smallest DFS traversal of the graph starting from 1. Note that the vertices are numbered from 1 to N.
Examples: 
 

Input: N = 5, M = 5, edges[] = {{1, 4}, {3, 4}, {5, 4}, {3, 2}, {1, 5}} 
Output: 1 4 3 2 5
Input: N = 5, M = 8, edges[] = {{1, 4}, {3, 4}, {5, 4}, {3, 2}, {1, 5}, {1, 2}, {1, 3}, {3, 5}} 
Output: 1 2 3 4 5 
 

 

Approach: Instead of doing a normal DFS, first we have to sort the edges of each vertex, so that in each turn only the smallest edge is picked first. After sorting, just perform a normal DFS which will give the lexicographically smallest DFS traversal.
Below is the implementation of the above approach: 
 

C++




// C++ program to find the lexicographically
// smallest traversal of a graph
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to add an
// edge to the graph
void insertEdges(int u, int v, vector<int>* adj)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Function to perform DFS traversal
void dfs(vector<int>* adj, int src, int n,
         bool* visited)
{
    // Print current vertex
    cout << src << " ";
 
    // Mark it as visited
    visited[src] = true;
 
    // Iterate over all the edges connected
    // to this vertex
    for (int i = 0; i < adj[src].size(); i++) {
        // If this vertex is not visited,
        /// call dfs from this node
        if (!visited[adj[src][i]])
            dfs(adj, adj[src][i], n, visited);
    }
}
 
// Function to print the lexicographically
// smallest DFS
void printLexoSmall(vector<int>* adj, int n)
{
    // A boolean array to keep track of
    // nodes visited
    bool visited[n + 1] = { 0 };
 
    // Sort the edges of each vertex in
    // ascending order
    for (int i = 0; i < n; i++)
        sort(adj[i].begin(), adj[i].end());
 
    // Call DFS
    for (int i = 1; i < n; i++) {
        if (!visited[i])
            dfs(adj, i, n, visited);
    }
}
 
// Driver code
int main()
{
    int n = 5, m = 5;
    vector<int> adj[n + 1];
 
    insertEdges(1, 4, adj);
    insertEdges(3, 4, adj);
    insertEdges(5, 4, adj);
    insertEdges(3, 2, adj);
    insertEdges(1, 5, adj);
    insertEdges(1, 2, adj);
    insertEdges(3, 5, adj);
    insertEdges(1, 3, adj);
 
    printLexoSmall(adj, n);
 
    return 0;
}

Java




// Java program to find the lexicographically
// smallest traversal of a graph
import java.util.*;
 
class GFG
{
 
    static boolean visited[];
    static Vector<Vector<Integer>> adj = new Vector<Vector<Integer>>();
     
// Utility function to add an
// edge to the graph
static void insertEdges(int u, int v)
{
    adj.get(u).add(v);
    adj.get(v).add(u);
}
 
// Function to perform DFS traversal
static void dfs( int src, int n)
{
    // Print current vertex
    System.out.print( src + " ");
 
    // Mark it as visited
    visited[src] = true;
 
    // Iterate over all the edges connected
    // to this vertex
    for (int i = 0; i < adj.get(src).size(); i++)
    {
        // If this vertex is not visited,
        /// call dfs from this node
        if (!visited[adj.get(src).get(i)])
            dfs( adj.get(src).get(i), n);
    }
}
 
// Function to print the lexicographically
// smallest DFS
static void printLexoSmall( int n)
{
    // A boolean array to keep track of
    // nodes visited
    visited= new boolean[n + 1];
     
    // Sort the edges of each vertex in
    // ascending order
    for (int i = 0; i < n; i++)
        Collections.sort(adj.get(i));
 
    // Call DFS
    for (int i = 1; i < n; i++)
    {
        if (!visited[i])
            dfs( i, n);
    }
}
 
// Driver code
public static void main(String args[])
{
    int n = 5, m = 5;
     
    for(int i = 0; i < n + 1; i++)
    adj.add(new Vector<Integer>());
     
    insertEdges(1, 4);
    insertEdges(3, 4);
    insertEdges(5, 4);
    insertEdges(3, 2);
    insertEdges(1, 5);
    insertEdges(1, 2);
    insertEdges(3, 5);
    insertEdges(1, 3);
 
    printLexoSmall( n);
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 program to find the lexicographically
# smallest traversal of a graph
 
# Utility function to add an edge
# to the graph
def insertEdges(u, v, adj):
 
    adj[u].append(v)
    adj[v].append(u)
 
# Function to perform DFS traversal
def dfs(adj, src, n, visited):
 
    # Print current vertex
    print(src, end = " ")
 
    # Mark it as visited
    visited[src] = True
 
    # Iterate over all the edges
    # connected to this vertex
    for i in range(0, len(adj[src])):
         
        # If this vertex is not visited,
        # call dfs from this node
        if not visited[adj[src][i]]:
            dfs(adj, adj[src][i], n, visited)
 
# Function to print the lexicographically
# smallest DFS
def printLexoSmall(adj, n):
 
    # A boolean array to keep track
    # of nodes visited
    visited = [0] * (n + 1)
 
    # Sort the edges of each vertex 
    # in ascending order
    for i in range(0, n):
        adj[i].sort()
 
    # Call DFS
    for i in range(1, n):
        if not visited[i]:
            dfs(adj, i, n, visited)
 
# Driver code
if __name__ == "__main__":
 
    n, m = 5, 5
    adj = [[] for i in range(n + 1)]
 
    insertEdges(1, 4, adj)
    insertEdges(3, 4, adj)
    insertEdges(5, 4, adj)
    insertEdges(3, 2, adj)
    insertEdges(1, 5, adj)
    insertEdges(1, 2, adj)
    insertEdges(3, 5, adj)
    insertEdges(1, 3, adj)
 
    printLexoSmall(adj, n)
 
# This code is contributed by Rituraj Jain

C#




// C# program to find the lexicographically
// smallest traversal of a graph
using System;
using System.Collections.Generic;
 
class GFG
{
 
    public static bool[] visited;
    public static List<List<int>> adj = new List<List<int>>();
 
// Utility function to add an
// edge to the graph
public static void insertEdges(int u, int v)
{
    adj[u].Add(v);
    adj[v].Add(u);
}
 
// Function to perform DFS traversal
public static void dfs(int src, int n)
{
    // Print current vertex
    Console.Write(src + " ");
 
    // Mark it as visited
    visited[src] = true;
 
    // Iterate over all the edges connected
    // to this vertex
    for (int i = 0; i < adj[src].Count; i++)
    {
        // If this vertex is not visited,
        /// call dfs from this node
        if (!visited[adj[src][i]])
        {
            dfs(adj[src][i], n);
        }
    }
}
 
// Function to print the lexicographically
// smallest DFS
public static void printLexoSmall(int n)
{
    // A boolean array to keep track of
    // nodes visited
    visited = new bool[n + 1];
 
    // Sort the edges of each vertex in
    // ascending order
    for (int i = 0; i < n; i++)
    {
        adj[i].Sort();
    }
 
    // Call DFS
    for (int i = 1; i < n; i++)
    {
        if (!visited[i])
        {
            dfs(i, n);
        }
    }
}
 
// Driver code
public static void Main(string[] args)
{
    int n = 5, m = 5;
 
    for (int i = 0; i < n + 1; i++)
    {
        adj.Add(new List<int>());
    }
 
    insertEdges(1, 4);
    insertEdges(3, 4);
    insertEdges(5, 4);
    insertEdges(3, 2);
    insertEdges(1, 5);
    insertEdges(1, 2);
    insertEdges(3, 5);
    insertEdges(1, 3);
 
    printLexoSmall(n);
}
}
 
// This code is contributed by shrikanth13

Javascript




<script>
// Javascript program to find the lexicographically
// smallest traversal of a graph
 
let visited;
let adj =[] ;
 
// Utility function to add an
// edge to the graph
function insertEdges(u,v)
{
    adj[u].push(v);
    adj[v].push(u);
}
 
// Function to perform DFS traversal
function dfs(src,n)
{
    // Print current vertex
    document.write( src + " ");
   
    // Mark it as visited
    visited[src] = true;
   
    // Iterate over all the edges connected
    // to this vertex
    for (let i = 0; i < adj[src].length; i++)
    {
        // If this vertex is not visited,
        /// call dfs from this node
        if (!visited[adj[src][i]])
            dfs( adj[src][i], n);
    }
}
 
// Function to print the lexicographically
// smallest DFS
function printLexoSmall(n)
{
    // A boolean array to keep track of
    // nodes visited
    visited= new Array(n + 1);
       
    // Sort the edges of each vertex in
    // ascending order
    for (let i = 0; i < n; i++)
        adj[i].sort(function(a,b){return a-b;});
   
    // Call DFS
    for (let i = 1; i < n; i++)
    {
        if (!visited[i])
            dfs( i, n);
    }
}
 
// Driver code
let n = 5, m = 5;
       
for(let i = 0; i < n + 1; i++)
    adj.push([]);
 
insertEdges(1, 4);
insertEdges(3, 4);
insertEdges(5, 4);
insertEdges(3, 2);
insertEdges(1, 5);
insertEdges(1, 2);
insertEdges(3, 5);
insertEdges(1, 3);
 
printLexoSmall( n);
 
// This code is contributed by avanitrachhadiya2155
</script>
Output: 
1 2 3 4 5

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!