Related Articles
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 ``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& 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 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 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 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

 ``
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