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.
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate length of longest common prefix int longestCommonPrefix(string str1, string str2) {
int i = 0, j = 0, count = 0;
while (i < str1.length() && j < str2.length()) {
// If characters do not match, break the loop
if (str1[i] != str2[j]) {
break ;
}
// Keep incrementing the count for each matching character
count++;
i++;
j++;
}
return count;
} // Function to print the pair having maximum // length of the longest common prefix void findMaxLenPair(vector<string>& arr, int N)
{ int maxLen = -1;
string first, second;
for ( int i = 0; i < N; i++) {
for ( int j = i + 1; j < N; j++) {
// Get the length of the longest common prefix of the current pair
int len = longestCommonPrefix(arr[i], arr[j]);
// If the length of the current longest common prefix is
// greater than the maximum length seen so far then
// update the maximum length and the pair
if (len > maxLen) {
maxLen = len;
first = arr[i];
second = arr[j];
}
}
}
// Print pairs having maximum length
// of the longest common prefix
cout << "(" << first << " " << second << ")" ;
} // Driver Code int main()
{ vector<string> arr
= { "geeksforgeeks" , "geeks" , "geeksforcse" };
int N = arr.size();
findMaxLenPair(arr, N);
return 0;
} // This code is contributed by Vaibhav. |
import java.util.*;
public class Main {
// Function to calculate length of longest common prefix
public static int longestCommonPrefix(String str1, String str2)
{
int i = 0 , j = 0 , count = 0 ;
while (i < str1.length() && j < str2.length())
{
// If characters do not match, break the loop
if (str1.charAt(i) != str2.charAt(j)) {
break ;
}
// Keep incrementing the count for each matching character
count++;
i++;
j++;
}
return count;
}
// Function to print the pair having maximum
// length of the longest common prefix
public static void findMaxLenPair(List<String> arr, int N)
{
int maxLen = - 1 ;
String first = "" , second = "" ;
for ( int i = 0 ; i < N; i++) {
for ( int j = i + 1 ; j < N; j++) {
// Get the length of the longest common prefix of the current pair
int len = longestCommonPrefix(arr.get(i), arr.get(j));
// If the length of the current longest common prefix is
// greater than the maximum length seen so far then
// update the maximum length and the pair
if (len > maxLen) {
maxLen = len;
first = arr.get(i);
second = arr.get(j);
}
}
}
// Print pairs having maximum length
// of the longest common prefix
System.out.println( "(" + first + " " + second + ")" );
}
// Driver Code
public static void main(String[] args) {
List<String> arr = new ArrayList<String>(
Arrays.asList( "geeksforgeeks" , "geeks" , "geeksforcse" )
);
int N = arr.size();
findMaxLenPair(arr, N);
}
} |
# Python Program to implement the above approach # Function to calculate length of longest common prefix def longestCommonPrefix(str1, str2):
i, j, count = 0 , 0 , 0
while (i < len (str1) and j < len (str2)):
# If characters do not match, break the loop
if (str1[i] ! = str2[j]):
break
# Keep incrementing the count for each matching character
count + = 1
i + = 1
j + = 1
return count
# Function to print the pair having maximum # length of the longest common prefix def findMaxLenPair(arr, N):
maxLen = - 1
first, second = " ", " "
for i in range (N):
for j in range (i + 1 , N):
# Get the length of the longest common prefix of the current pair
len = longestCommonPrefix(arr[i], arr[j])
# If the length of the current longest common prefix is
# greater than the maximum length seen so far then
# update the maximum length and the pair
if len > maxLen:
maxLen = len
first = arr[i]
second = arr[j]
# Print pairs having maximum length
# of the longest common prefix
print ( "(" , first, " " , second, ")" )
# Driver Code if __name__ = = '__main__' :
arr = [ "geeksforgeeks" , "geeks" , "geeksforcse" ]
N = len (arr)
findMaxLenPair(arr, N)
|
// JS Program to implement the above approach // Function to calculate length of longest common prefix function longestCommonPrefix(str1, str2) {
let i = 0, j = 0, count = 0;
while (i < str1.length && j < str2.length) {
// If characters do not match, break the loop
if (str1[i] !== str2[j]) {
break ;
}
// Keep incrementing the count for each matching character
count++;
i++;
j++;
}
return count;
} // Function to print the pair having maximum // length of the longest common prefix function findMaxLenPair(arr, N) {
let maxLen = -1;
let first = "" , second = "" ;
for (let i = 0; i < N; i++) {
for (let j = i + 1; j < N; j++) {
// Get the length of the longest common prefix of the current pair
let len = longestCommonPrefix(arr[i], arr[j]);
// If the length of the current longest common prefix is
// greater than the maximum length seen so far then
// update the maximum length and the pair
if (len > maxLen) {
maxLen = len;
first = arr[i];
second = arr[j];
}
}
}
// Print pairs having maximum length
// of the longest common prefix
console.log( "(" , first, " " , second, ")" );
} // Driver Code function main() {
let arr = [ "geeksforgeeks" , "geeks" , "geeksforcse" ];
let N = arr.length;
findMaxLenPair(arr, N);
} main(); |
using System;
using System.Collections.Generic;
public class GFG {
// Function to calculate length of longest common prefix
static int longestCommonPrefix( string str1, string str2) {
int i = 0, j = 0, count = 0;
while (i < str1.Length && j < str2.Length) {
// If characters do not match, break the loop
if (str1[i] != str2[j]) {
break ;
}
// Keep incrementing the count for each matching character
count++;
i++;
j++;
}
return count;
}
// Function to print the pair having maximum
// length of the longest common prefix
static void findMaxLenPair(List< string > arr, int N) {
int maxLen = -1;
string first = "" , second = "" ;
for ( int i = 0; i < N; i++) {
for ( int j = i + 1; j < N; j++) {
// Get the length of the longest common prefix of the current pair
int len = longestCommonPrefix(arr[i], arr[j]);
// If the length of the current longest common prefix is
// greater than the maximum length seen so far then
// update the maximum length and the pair
if (len > maxLen) {
maxLen = len;
first = arr[i];
second = arr[j];
}
}
}
// Print pairs having maximum length
// of the longest common prefix
Console.WriteLine( "(" + first + " " + second + ")" );
}
// Driver Code
static void Main( string [] args) {
List< string > arr = new List< string > { "geeksforgeeks" , "geeks" , "geeksforcse" };
int N = arr.Count;
findMaxLenPair(arr, N);
}
} |
(geeksforgeeks geeksforcse)
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++ 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 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);
}
} |
# Python3 program to implement # the above approach # class of Trie class TrieNode:
def __init__( self ):
self .child = dict ()
# function to insert a string into trie def insertTrie(root, string):
M = len (string) # stores string length
length = 0
for i in range (M): # traversing string
if string[i] not in root.child:
root.child[string[i]] = TrieNode()
root = root.child[string[i]]
def findStrLen(root, string):
M = len (string)
length = 0
for i in range (M):
if string[i] not in root.child:
length + = 1
root = root.child[string[i]]
else :
return length
return length
def findMaxLenPair(arr, N):
idx = - 1
length = 0
root = TrieNode()
insertTrie(root, arr[ 0 ])
for i in range ( 1 , N):
temp = findStrLen(root, arr[i])
if temp > length:
length = temp
idx = i
insertTrie(root, arr[i])
for i in range (N):
M = len (arr[i])
if (i ! = idx and M > = length):
found = True
for j in range (length):
if arr[i][j] ! = arr[idx][j]:
found = False
break
if (found):
print ( "(" + arr[i] + ", " + arr[idx] + ")" )
return
# Driver Code arr = [ "geeksforgeeks" , "geeks" , "geeksforcse" ]
N = len (arr)
findMaxLenPair(arr, N) # This code is contributed by phasing17 |
// 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. |
<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> |
(geeksforgeeks, geeksforcse)
Time Complexity: O(N * M), where M denotes the length of the longest string
Auxiliary Space: 0(N * 256)