Skip to content
Related Articles

Related Articles

Improve Article
Check if the given permutation is a valid DFS of graph
  • Difficulty Level : Hard
  • Last Updated : 17 Mar, 2021

Given a graph with N nodes numbered from 1 to N and M edges and an array of numbers from 1 to N. Check if it is possible to obtain any permutation of array by applying DFS (Depth First Traversal) on given graph.
Prerequisites: DFS | Map in CPP

Examples:  

Input: N = 3, M = 2
        Edges are:
        1) 1-2
        2) 2-3
        P = {1, 2, 3}
Output: YES
Explanation: 
Since there are edges between 
1-2 and 2-3, therefore we can 
have DFS in the order 1-2-3

Input: N = 3, M = 2
        Edges are:
        1) 1-2
        2) 2-3
        P = {1, 3, 2}
Output: NO
Explanation: 
Since there is no edge between 1 and 3,
the DFS traversal is not possible 
in the order of given permutation.

Approach: We assume that the input graph is represented as adjacency list. The idea is to first sort all adjacency lists according to input order, then traverse the given graph starting from the first node in the given permutation. If we visit all vertices in the same order, then given permutation is a valid DFS

  1. Store the indexes of each number in the given permutation in a Hash map.
  2. Sort every adjacency list according to the indexes of permutation since there is a need to maintain the order.
  3. Perform the Depth First Traversal Search with source node as 1st number of given permutation.
  4. Keep a counter variable and at every recursive call, check if the counter has reached the number of nodes, i.e. N and set the flag as 1. If the flag is 0 after complete DFS, answer is ‘NO’ otherwise ‘YES’

Below is the implementation of above approach: 

C++




// C++ program to check if given
// permutation can be obtained
// upon DFS traversal on given graph
#include <bits/stdc++.h>
using namespace std;
 
// To track of DFS is valid or not.
bool flag = false;
 
// HashMap to store the indexes
// of given permutation
map<int, int> mp;
 
// Comparator function for sort
bool cmp(int a, int b)
{
    // Sort according ascending
    // order of indexes
    return mp[a] < mp[b];
}
 
// Graph class represents an undirected
// using adjacency list representation
class Graph {
    int V; // No. of vertices
    int counter; // Counter variable
 
public:
    // Pointer to an array containing
    // adjacency lists
    list<int>* adj;
 
    Graph(int V); // Constructor
 
    // function to add an edge to graph
    void addEdge(int u, int v);
 
    // DFS traversal of the vertices
    // reachable from v
    void DFS(int v, int Perm[]);
};
 
Graph::Graph(int V)
{
    this->V = V;
    this->counter = 0;
    adj = new list<int>[V + 1];
}
 
void Graph::addEdge(int u, int v)
{
 
    // Add v to u’s list.
    adj[u].push_back(v);
 
    // Add u to v's list
    adj[v].push_back(u);
}
 
// DFS traversal of the
// vertices reachable from v.
void Graph::DFS(int v, int Perm[])
{
    // Increment counter for
    // every node being traversed
    counter++;
 
    // Check if counter has
    // reached number of vertices
    if (counter == V) {
 
        // Set flag to 1
        flag = 1;
        return;
    }
 
    // Recur for all vertices adjacent
    // to this vertices only if it
    // lies in the given permutation
    list<int>::iterator i;
    for (i = adj[v].begin();
         i != adj[v].end(); i++) {
 
        // if the current node equals to
        // current element of permutation
        if (*i == Perm[counter])
            DFS(*i, Perm);
    }
}
 
// Returns true if P[] is a valid DFS of given
// graph. In other words P[] can be obtained by
// doing a DFS of the graph.
bool checkPermutation(
    int N, int M,
    vector<pair<int, int> > V,
    int P[])
{
 
    // Create the required graph with
    // N vertices and M edges
    Graph G(N);
 
    // Add Edges to Graph G
    for (int i = 0; i < M; i++)
        G.addEdge(V[i].first,
                  V[i].second);
 
    for (int i = 0; i < N; i++)
        mp[P[i]] = i;
 
    // Sort every adjacency
    // list according to HashMap
    for (int i = 1; i <= N; i++)
        G.adj[i].sort(cmp);
 
    // Call DFS with source node as P[0]
    G.DFS(P[0], P);
 
    // If Flag has been set to 1, means
    // given permutation is obtained
    // by DFS on given graph
    return flag;
}
 
// Driver code
int main()
{
    // Number of vertices
    // and number of edges
    int N = 3, M = 2;
 
    // Vector of pair to store edges
    vector<pair<int, int> > V;
 
    V.push_back(make_pair(1, 2));
    V.push_back(make_pair(2, 3));
 
    int P[] = { 1, 2, 3 };
 
    // Return the answer
    if (checkPermutation(N, M, V, P))
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
 
    return 0;
}

Python3




# Python3 program to check if given
# permutation can be obtained
# upon DFS traversal on given graph
flag = True
 
def addEdge(adj, u, v):
     
    # Add v to u’s list.
    adj[u].append(v)
     
    # Add u to v's list
    adj[v].append(u)
 
    return adj
 
# DFS traversal of the
# vertices reachable from v.
def DFS(adj, v, Perm):
     
    global mp,counter, flag
     
    # Increment counter for
    # every node being traversed
    counter += 1
 
    # Check if counter has
    # reached number of vertices
    if (counter == V):
         
        # Set flag to 1
        flag = 1
        return
 
    # Recur for all vertices adjacent
    # to this vertices only if it
    # lies in the given permutation
    for i in adj[v]:
         
        # If the current node equals to
        # current element of permutation
        if (counter<len(Perm) and i == Perm[counter]):
            DFS(adj, i, Perm)
 
# Returns true if P[] is a valid DFS of given
# graph. In other words P[] can be obtained by
# doing a DFS of the graph.
def checkPermutation(N, M, V, P):
     
    global mp
 
    # Create the required graph with
    # N vertices and M edges
    G = [[] for i in range(N + 1)]
 
    # Add Edges to Graph G
    for i in range(M):
        G = addEdge(G, V[i][0], V[i][1])
 
    for i in range(N):
        mp[P[i]] = i
 
    # Sort every adjacency
    # list according to HashMap
    for i in range(1, N + 1):
        G[i] = sorted(G[i])
 
    # Call DFS with source node as P[0]
    DFS(G, P[0], P)
 
    # If Flag has been set to 1, means
    # given permutation is obtained
    # by DFS on given graph
    return flag
 
# Driver code
if __name__ == '__main__':
     
    mp = {}
     
    # Number of vertices
    # and number of edges
    N, M, counter = 3, 2, 0
 
    # Vector of pair to store edges
    V = []
 
    V.append([1, 2])
    V.append([2, 3])
 
    P = [1, 2, 3]
 
    # Return the answer
    if (checkPermutation(N, M, V, P)):
        print("YES")
    else:
        print("NO")
 
# This code is contributed by mohit kumar 29
Output: 
YES

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :