Skip to content
Related Articles

Related Articles

Improve Article
Pair of strings having longest common prefix of maximum length in given array
  • Last Updated : 22 Jun, 2021

Given an array of strings arr[], the task is to find the pair of strings from the given array whose length of the longest common prefix between them is maximum. If multiple solutions exist, then print any one of them.

Examples:

Input: arr[] = {“geeksforgeeks”, “geeks”, “geeksforcse”, } 
Output: (geeksforgeeks, geeksforcse) 
Explanation: 
All possible pairs and their longest common prefix are: 
(“geeksforgeeks”, “geeks”) has the longest common prefix = “geeks” 
(“geeksforgeeks”, “geeksforcse”) has the longest common prefix = “geeksfor” 
(“geeks”, “geeksforcse”) has the longest common prefix = “geeks” 
Therefore, a pair having maximum length of the longest common prefix is (“geeksforgeeks”, “geeksforcse”) 
 

Input: arr[] = {“abbcbgfh”, “bcdee”, “bcde”, “abbcbde”} 
Output: (abbcbgfh, abbcbde) 

Naive Approach: The simplest approach to solve this problem is to generate all possible pairs of the given array and calculate the length of the longest common prefix of each pair. Finally, print the pair having a maximum length of the longest common prefix. 



Time Complexity: O(N2 * M), Where M denotes the length of the longest string 
Auxiliary Space: O(1)

Efficient Approach: The problem can be solved using Trie. The idea is to traverse the given array and for each array element, find the maximum length of the longest prefix present in Trie, and insert the current element into the Trie. Finally, print the pair having a maximum length of the longest common prefix. Follow the steps below to solve the problem:

  • Create a Trie having root node, say root to store each element of the given array.
  • Traverse the given array and for each array element, find the maximum length of the longest prefix present in Trie and insert the current element into Trie.
  • Finally, print the pair having a maximum length of the longest common prefix.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure of Trie
struct TrieNode {
    // Stores characters of
    // each string
    TrieNode* child[256];
 
    TrieNode() { child[0] = child[1] = NULL; }
};
 
// Function to insert a string into Trie
void insertTrie(TrieNode* root, string str)
{
 
    // Stores length of the string
    int M = str.length();
 
    // Traverse the string str
    for (int i = 0; i < M; i++) {
 
        // If str[i] is not present
        // in current path of Trie
        if (!root->child[str[i]]) {
 
            // Create a new node
            // of Trie
            root->child[str[i]] = new TrieNode();
        }
 
        // Update root
        root = root->child[str[i]];
    }
}
 
// Function to find the maximum length of
// longest common prefix in Trie with str
int findStrLen(TrieNode* root, string str)
{
 
    // Stores length of str
    int M = str.length();
 
    // Stores length of longest
    // common prefix in Trie with str
    int len = 0;
 
    // Traverse the string str
    for (int i = 0; i < M; i++) {
 
        // If str[i] is present in
        // the current path of Trie
        if (root->child[str[i]]) {
 
            // Update len
            len++;
 
            // Update root
            root = root->child[str[i]];
        }
        else {
            return len;
        }
    }
    return len;
}
 
// Function to print the pair having maximum
// length of the longest common prefix
void findMaxLenPair(vector<string>& arr, int N)
{
    // Stores index of the string having
    // maximum length of longest common prefix
    int idx = -1;
 
    // Stores maximum length of longest
    // common prefix.
    int len = 0;
 
    // Create root node of Trie
    TrieNode* root = new TrieNode();
 
    // Insert arr[0] into Trie
    insertTrie(root, arr[0]);
 
    // Traverse the array.
    for (int i = 1; i < N; i++) {
 
        // Stores maximum length of longest
        // common prefix in Trie with arr[i]
        int temp = findStrLen(root, arr[i]);
 
        // If temp is greater than len
        if (temp > len) {
 
            // Update len
            len = temp;
 
            // Update idx
            idx = i;
        }
 
        insertTrie(root, arr[i]);
    }
 
    // Traverse array arr[]
    for (int i = 0; i < N; i++) {
 
        // Stores length of arr[i]
        int M = arr[i].length();
 
        // Check if maximum length of
        // longest common prefix > M
        if (i != idx && M >= len) {
            bool found = true;
            // Traverse string arr[i]
            // and arr[j]
            for (int j = 0; j < len; j++) {
 
                // If current character of both
                // string does not match.
                if (arr[i][j] != arr[idx][j]) {
                    found = false;
                    break;
                }
            }
 
            // Print pairs having maximum length
            // of the longest common prefix
            if (found) {
                cout << "(" << arr[i] << ", " << arr[idx]
                     << ")";
                return;
            }
        }
    }
}
 
// Driver Code
int main()
{
    vector<string> arr
        = { "geeksforgeeks", "geeks", "geeksforcse" };
 
    int N = arr.size();
    findMaxLenPair(arr, N);
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
 
// class of Trie
class TrieNode {
    TrieNode[] child = new TrieNode[256];
    TrieNode() {}
}
 
class GFG {
 
    // Function to insert a string into Trie
    private static void insertTrie(TrieNode root,
                                   String str)
    {
 
        // Stores length of the string
        int M = str.length();
 
        // Traverse the string str
        for (int i = 0; i < M; i++) {
 
            // If str[i] is not present
            // in current path of Trie
            if (root.child[str.charAt(i)] == null) {
 
                // Create a new node
                // of Trie
                root.child[str.charAt(i)] = new TrieNode();
            }
 
            // Update root
            root = root.child[str.charAt(i)];
        }
    }
 
    // Function to find the maximum length of
    // longest common prefix in Trie with str
    private static int findStrLen(TrieNode root, String str)
    {
 
        // Stores length of str
        int M = str.length();
 
        // Stores length of longest
        // common prefix in Trie with str
        int len = 0;
 
        // Traverse the string str
        for (int i = 0; i < M; i++) {
 
            // If str[i] is present in
            // the current path of Trie
            if (root.child[str.charAt(i)] != null) {
 
                // Update len
                len++;
 
                // Update root
                root = root.child[str.charAt(i)];
            }
            else {
                return len;
            }
        }
        return len;
    }
 
    // Function to print the pair having maximum
    // length of the longest common prefix
    private static void findMaxLenPair(List<String> arr,
                                       int N)
    {
        // Stores index of the string having
        // maximum length of longest common prefix
        int idx = -1;
 
        // Stores maximum length of longest
        // common prefix.
        int len = 0;
 
        // Create root node of Trie
        TrieNode root = new TrieNode();
 
        // Insert arr[0] into Trie
        insertTrie(root, arr.get(0));
 
        // Traverse the array.
        for (int i = 1; i < N; i++) {
 
            // Stores maximum length of longest
            // common prefix in Trie with arr[i]
            int temp = findStrLen(root, arr.get(i));
 
            // If temp is greater than len
            if (temp > len) {
 
                // Update len
                len = temp;
 
                // Update idx
                idx = i;
            }
 
            insertTrie(root, arr.get(i));
        }
 
        // Traverse array arr[]
        for (int i = 0; i < N; i++) {
 
            // Stores length of arr[i]
            int M = arr.get(i).length();
 
            // Check if maximum length of
            // longest common prefix > M
            if (i != idx && M >= len) {
                boolean found = true;
                // Traverse string arr[i]
                // and arr[j]
                for (int j = 0; j < len; j++) {
 
                    // If current character of both
                    // string does not match.
                    if (arr.get(i).charAt(j)
                        != arr.get(idx).charAt(j)) {
                        found = false;
                        break;
                    }
                }
 
                // Print pairs having maximum length
                // of the longest common prefix
                if (found) {
                    System.out.println("(" + arr.get(i)
                                       + ", " + arr.get(idx)
                                       + ")");
                    return;
                }
            }
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        List<String> arr = Arrays.asList(new String[] {
            "geeksforgeeks", "geeks", "geeksforcse" });
        int N = arr.size();
        findMaxLenPair(arr, N);
    }
}

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
// class of Trie
public class GFG
{
 
  public class TrieNode
  {
    public TrieNode[] child = new TrieNode[256];
    public TrieNode() {}
  };
 
  // Function to insert a string into Trie
  public static void insertTrie(TrieNode root,
                                String str)
  {
 
    // Stores length of the string
    int M = str.Length;
 
    // Traverse the string str
    for (int i = 0; i < M; i++) {
 
      // If str[i] is not present
      // in current path of Trie
      if (root.child[str[i]] == null) {
 
        // Create a new node
        // of Trie
        root.child[str[i]] = new TrieNode();
      }
 
      // Update root
      root = root.child[str[i]];
    }
  }
 
  // Function to find the maximum length of
  // longest common prefix in Trie with str
  public static int findStrLen(TrieNode root, String str)
  {
 
    // Stores length of str
    int M = str.Length;
 
    // Stores length of longest
    // common prefix in Trie with str
    int len = 0;
 
    // Traverse the string str
    for (int i = 0; i < M; i++) {
 
      // If str[i] is present in
      // the current path of Trie
      if (root.child[str[i]] != null) {
 
        // Update len
        len++;
 
        // Update root
        root = root.child[str[i]];
      }
      else {
        return len;
      }
    }
    return len;
  }
 
  // Function to print the pair having maximum
  // length of the longest common prefix
  public static void findMaxLenPair(List<string> arr,
                                    int N)
  {
    // Stores index of the string having
    // maximum length of longest common prefix
    int idx = -1;
 
    // Stores maximum length of longest
    // common prefix.
    int len = 0;
 
    // Create root node of Trie
    TrieNode root = new TrieNode();
 
    // Insert arr[0] into Trie
    insertTrie(root, arr[0]);
 
    // Traverse the array.
    for (int i = 1; i < N; i++) {
 
      // Stores maximum length of longest
      // common prefix in Trie with arr[i]
      int temp = findStrLen(root, arr[i]);
 
      // If temp is greater than len
      if (temp > len) {
 
        // Update len
        len = temp;
 
        // Update idx
        idx = i;
      }
 
      insertTrie(root, arr[i]);
    }
 
    // Traverse array arr[]
    for (int i = 0; i < N; i++) {
 
      // Stores length of arr[i]
      int M = arr[i].Length;
 
      // Check if maximum length of
      // longest common prefix > M
      if (i != idx && M >= len) {
        bool found = true;
        // Traverse string arr[i]
        // and arr[j]
        for (int j = 0; j < len; j++) {
 
          // If current character of both
          // string does not match.
          if (arr[i][j] != arr[idx][j]) {
            found = false;
            break;
          }
        }
 
        // Print pairs having maximum length
        // of the longest common prefix
        if (found) {
          Console.WriteLine("(" + arr[i]+ ", " + arr[idx]+ ")");
          return;
        }
      }
    }
  }
 
  // Driver Code
  public static void Main()
  {
    List<string> arr = new List<string>() {"geeksforgeeks", "geeks", "geeksforcse" };
    int N = arr.Count;
    findMaxLenPair(arr, N);
  }
}
 
// THIS CODE IS CONTRIBUTED BY SURENDRA_GANGWAR.

Javascript




<script>
 
// Javascript program to implement
// the above approach
 
// Class of Trie
class TrieNode
{
    constructor()
    {
        this.child = Array(256);
    }
};
 
// Function to insert a string into Trie
function insertTrie(root, str)
{
     
    // Stores length of the string
    var M = str.length;
     
    // Traverse the string str
    for(var i = 0; i < M; i++)
    {
         
        // If str[i] is not present
        // in current path of Trie
        if (root.child[str[i]] == null)
        {
             
            // Create a new node
            // of Trie
            root.child[str[i]] = new TrieNode();
        }
         
        // Update root
        root = root.child[str[i]];
    }
}
 
// Function to find the maximum length of
// longest common prefix in Trie with str
function findStrLen(root, str)
{
     
    // Stores length of str
    var M = str.length;
     
    // Stores length of longest
    // common prefix in Trie with str
    var len = 0;
     
    // Traverse the string str
    for(var i = 0; i < M; i++)
    {
         
        // If str[i] is present in
        // the current path of Trie
        if (root.child[str[i]] != null)
        {
             
            // Update len
            len++;
             
            // Update root
            root = root.child[str[i]];
        }
        else
        {
            return len;
        }
    }
    return len;
}
 
// Function to print the pair having maximum
// length of the longest common prefix
function findMaxLenPair(arr, N)
{
     
    // Stores index of the string having
    // maximum length of longest common prefix
    var idx = -1;
     
    // Stores maximum length of longest
    // common prefix.
    var len = 0;
     
    // Create root node of Trie
    var root = new TrieNode();
     
    // Insert arr[0] into Trie
    insertTrie(root, arr[0]);
     
    // Traverse the array.
    for(var i = 1; i < N; i++)
    {
         
        // Stores maximum length of longest
        // common prefix in Trie with arr[i]
        var temp = findStrLen(root, arr[i]);
         
        // If temp is greater than len
        if (temp > len)
        {
             
            // Update len
            len = temp;
             
            // Update idx
            idx = i;
        }
        insertTrie(root, arr[i]);
    }
     
    // Traverse array arr[]
    for(var i = 0; i < N; i++)
    {
         
        // Stores length of arr[i]
        var M = arr[i].length;
         
        // Check if maximum length of
        // longest common prefix > M
        if (i != idx && M >= len)
        {
            var found = true;
             
            // Traverse string arr[i]
            // and arr[j]
            for(var j = 0; j < len; j++)
            {
                 
                // If current character of both
                // string does not match.
                if (arr[i][j] != arr[idx][j])
                {
                    found = false;
                    break;
                }
            }
             
            // Print pairs having maximum length
            // of the longest common prefix
            if (found)
            {
                document.write("(" + arr[i] +
                               ", " + arr[idx] + ")");
                return;
            }
        }
    }
}
 
// Driver Code
var arr = [ "geeksforgeeks", "geeks",
            "geeksforcse" ];
var N = arr.length;
 
findMaxLenPair(arr, N);
 
// This code is contributed by rrrtnx
 
</script>
Output: 
(geeksforgeeks, geeksforcse)

 

Time Complexity: O(N * M), where M denotes the length of the longest string
Auxiliary Space: 0(N * 256)

Attention reader! Don’t stop learning now. Get hold of all the important Comcompetitivepetitve Programming concepts with the Competitive Programming Live  course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :