Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Check if given Arrays have a Unique Shortest Common Super-sequence

  • Last Updated : 11 Feb, 2022

Given a 2D array arr[][] of size N*M which denotes N arrays, each of size M. The task is to check if all these arrays have a unique common supersequence.

Examples:

Input: N = 2, M = 2, arr[][] = { { 1, 2 }, {1, 3 } }
Output: False
Explanation: There are two possible supersequence: {1, 3, 2 } and {1, 2, 3}.

Input: N = 3, M = 2, arr[][] = { { 1, 2 }, {1, 3}, {2, 3 } }
Output: True
Explanation: { 1, 2, 3 } is the only shortest common supersequence of {1, 2}, {1, 3} and {2, 3}.

 

Approach: The idea is to use topological sorting, Follow the steps mentioned below to solve the problem:

  • Represent the sequences in the ‘arr[][]’ by a directed graph and find its topological sort order.
  • If there is only one topological sort order, then it can be said that there is only one shortest common supersequence.
  • Otherwise, return false.

Below is the implementation of the above approach.

C++




// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check unique
// shortest common supersequence
bool shortestSuperSeq(vector<vector<int> >& arr,
                      int N, int M)
{
    // Initializing map to store
    // edges and indegree of vertices
    unordered_map<int, vector<int> > adj;
    unordered_map<int, int> indegree;
 
    // Initializing all keys of map
    // with values of sequences in arr
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            int node = arr[i][j];
            adj[node] = {};
            indegree[node] = 0;
        }
    }
 
    // For every sequence in arr
    // calculate indegree and edges.
    for (auto seq : arr) {
        for (int i = 1; i < M; i++) {
            adj[seq[i - 1]].push_back(seq[i]);
            indegree[seq[i]]++;
        }
    }
 
    // Vector to store
    // topologically sorted order.
    vector<int> res;
    queue<int> q;
 
    // Push vertices with 0 indegree in queue
    for (auto itr : indegree) {
        if (itr.second == 0) {
            q.push(itr.first);
        }
    }
 
    while (!q.empty()) {
        int size = q.size();
 
        // If size of q > 1, this means
        // more than one choices,
        // so no unique common supersequence
        // can be formed.
        if (size != 1)
            return false;
 
        int node = q.front();
 
        // Add node to topological sort order
        res.push_back(node);
 
        q.pop();
 
        // Decrement indegree of all
        // the vertices connected to node
        for (int i = 0; i < adj[node].size();
             i++) {
            int connected_node = adj[node][i];
 
            // Push vertices with 0 indegree
            // to queue
            if ((--indegree[connected_node])
                == 0) {
                q.push(connected_node);
            }
        }
    }
 
    // If indegree of any vertices is not 0,
    // return false.
    for (auto itr : indegree) {
        if (itr.second != 0)
            return false;
    }
 
    return true;
}
 
// Driver Code
int main()
{
    vector<vector<int> > arr = { { 1, 2 },
                                 { 1, 3 } };
    int N = arr.size(), M = arr[0].size();
    if (shortestSuperSeq(arr, N, M))
        cout << "True\n";
    else
        cout << "False\n";
    return 0;
}


Java




import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to check unique
    // shortest common supersequence
    public static boolean
    shortestSuperSeq(ArrayList<ArrayList<Integer> > arr,
                     int N, int M)
    {
       
        // Initializing map to store
        // edges and indegree of vertices
        HashMap<Integer, ArrayList<Integer> > adj
            = new HashMap<>();
        HashMap<Integer, Integer> indegree
            = new HashMap<>();
 
        // Initializing all keys of map
        // with values of sequences in arr
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                int node = arr.get(i).get(j);
                ArrayList<Integer> temp
                    = new ArrayList<Integer>();
                adj.put(node, temp);
                indegree.put(node, 0);
            }
        }
 
        // For every sequence in arr
        // calculate indegree and edges.
 
        for (ArrayList<Integer> seq : arr) {
            for (int i = 1; i < M; i++) {
                adj.get(seq.get(i - 1)).add(seq.get(i));
                int temp = indegree.get(seq.get(i));
                indegree.put(seq.get(i), temp + 1);
            }
        }
 
        // ArrayList to store
        // topologically sorted order.
        ArrayList<Integer> res = new ArrayList<Integer>();
        ArrayDeque<Integer> q = new ArrayDeque<>();
 
        // Push vertices with 0 indegree in queue
        for (int itr : indegree.keySet()) {
            if (indegree.get(itr) == 0) {
                q.addLast(itr);
            }
        }
 
        while (q.size() > 0) {
            int size = q.size();
 
            // If size of q > 1, this means
            // more than one choices,
            // so no unique common supersequence
            // can be formed.
            if (size != 1)
                return false;
 
            int node = q.getFirst();
 
            // Add node to topological sort order
            res.add(node);
 
            q.removeLast();
 
            // Decrement indegree of all
            // the vertices connected to node
            for (int i = 0; i < adj.get(node).size(); i++) {
                int connected_node = adj.get(node).get(i);
 
                // Push vertices with 0 indegree
                // to queue
 
                int temp = indegree.get(connected_node) - 1;
                indegree.put(connected_node, temp);
                if ((temp == 0)) {
                    q.addLast(connected_node);
                }
            }
        }
 
        // If indegree of any vertices is not 0,
        // return false.
 
        for (int itr : indegree.keySet()) {
            if (indegree.get(itr) != 0)
                return false;
        }
 
        return true;
    }
   
    // Driver Code
    public static void main(String[] args)
    {
        ArrayList<ArrayList<Integer> > arr
            = new ArrayList<ArrayList<Integer> >();
        arr.add(
            new ArrayList<Integer>(Arrays.asList(1, 2)));
        arr.add(
            new ArrayList<Integer>(Arrays.asList(1, 3)));
 
        int N = arr.size(), M = arr.get(0).size();
        if (shortestSuperSeq(arr, N, M))
            System.out.println("True");
        else
            System.out.println("False");
    }
}
 
// This code is contributed by Palak Gupta


Python3




# Python code for the above approach
 
# Function to check unique
# shortest common supersequence
def shortestSuperSeq(arr, N, M):
 
    # Initializing map to store
    # edges and indegree of vertices
    adj = {}
    indegree = {}
     
    # Initializing all keys of map
    # with values of sequences in arr
    for i in range(N):
        for j in range(M):
            node = arr[i][j];
            adj[node] =  []
            indegree[node] = 0
         
    # For every sequence in arr
    # calculate indegree and edges.
    for seq in arr:
        for i in range(1, M):
            adj[seq[i - 1]].append(seq[i]);
            indegree[seq[i]] += 1
         
    # Vector to store
    # topologically sorted order.
    res = [];
    q = [];
 
    # Push vertices with 0 indegree in queue
    for k in indegree.keys():
        if (indegree[k] == 0):
            q.append(k);
         
 
    while (len(q) != 0):
        size = len(q)
 
        # If size of q > 1, this means
        # more than one choices,
        # so no unique common supersequence
        # can be formed.
        if (size != 1):
            return False;
 
        node = q.pop(0);
 
        # Add node to topological sort order
        res.append(node);
 
        # Decrement indegree of all
        # the vertices connected to node
        for i in range(len(adj[node])):
            connected_node = adj[node][i];
 
            # Push vertices with 0 indegree
            # to queue
            indegree[connected_node] -= 1
            if (indegree[connected_node] == 0):
                q.append(connected_node);
             
    # If indegree of any vertices is not 0,
    # return false.
    for itr in indegree.keys():
        if (itr != 0):
            return False;
     
    return True;
 
# Driver Code
arr = [[1, 2], [1, 3]];
N = len(arr)
M = len(arr[0])
if (shortestSuperSeq(arr, N, M)):
    print("True");
else:
    print("False")
 
# This code is contributed by Saurabh Jaiswal


Javascript




<script>
       // JavaScript code for the above approach
 
       // Function to check unique
       // shortest common supersequence
       function shortestSuperSeq(arr,
           N, M)
       {
        
           // Initializing map to store
           // edges and indegree of vertices
 
           let adj = new Map();
           let indegree = new Map();
            
           // Initializing all keys of map
           // with values of sequences in arr
           for (let i = 0; i < N; i++) {
               for (let j = 0; j < M; j++) {
                   let node = arr[i][j];
 
                   adj.set(node, [])
 
                   indegree.set(node, 0);
               }
           }
 
           // For every sequence in arr
           // calculate indegree and edges.
           for (let seq of arr) {
               for (let i = 1; i < M; i++) {
                   adj.get(seq[i - 1]).push(seq[i]);
                   indegree.set(seq[i], indegree.get(seq[i]) + 1);
               }
           }
 
           // Vector to store
           // topologically sorted order.
           let res = [];
           let q = [];
 
           // Push vertices with 0 indegree in queue
           for (let [key, val] of indegree) {
               if (val == 0) {
                   q.push(key);
               }
           }
 
           while (q.length != 0) {
               let size = q.length;
 
               // If size of q > 1, this means
               // more than one choices,
               // so no unique common supersequence
               // can be formed.
               if (size != 1)
                   return false;
 
               let node = q.shift();
 
               // Add node to topological sort order
               res.push(node);
 
               // Decrement indegree of all
               // the vertices connected to node
               for (let i = 0; i < adj.get(node).length;
                   i++) {
                   let connected_node = adj.get(node)[i];
 
                   // Push vertices with 0 indegree
                   // to queue
                   indegree.set(connected_node, indegree.get(connected_node) - 1);
                   if ((indegree.get(connected_node))
                       == 0) {
                       q.push(connected_node);
                   }
               }
           }
 
           // If indegree of any vertices is not 0,
           // return false.
           for (let itr of indegree.keys()) {
               if (itr != 0)
                   return false;
           }
 
           return true;
       }
 
       // Driver Code
       let arr = [[1, 2],
       [1, 3]];
       let N = arr.length, M = arr[0].length;
       if (shortestSuperSeq(arr, N, M))
           document.write("True");
       else
           document.write("False")
 
      // This code is contributed by Potta Lokesh
   </script>


 
 

Output

False

 

Time Complexity: O(N * M)
Auxiliary Space: O(N * M)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!