给定一个字符串数组arr [] ，任务是从给定的数组中找到一对字符串，它们之间最长的公共前缀长度最大。如果存在多个解决方案，则打印其中任何一种。
例子：
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)
天真的方法：解决此问题的最简单方法是生成给定数组的所有可能对，并计算每对最长公共前缀的长度。最后，打印具有最长公共前缀的最大长度的线对。
时间复杂度： O(N 2 * M)，其中M表示最长字符串的长度
辅助空间： O(1)
高效的方法：使用Trie可以解决问题。想法是遍历给定的数组并针对每个数组元素，找到Trie中存在的最长前缀的最大长度，然后将当前元素插入Trie。最后，打印具有最长公共前缀的最大长度的线对。请按照以下步骤解决问题：
- 创建一个具有根节点的Trie，例如说root以存储给定数组的每个元素。
- 遍历给定的数组，对于每个数组元素，找到Trie中存在的最长前缀的最大长度，然后将当前元素插入Trie。
- 最后，打印具有最长公共前缀的最大长度的线对。
下面是上述方法的实现：
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 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 arr = new List() {"geeksforgeeks", "geeks", "geeksforcse" };
int N = arr.Count;
findMaxLenPair(arr, N);
}
}
// THIS CODE IS CONTRIBUTED BY SURENDRA_GANGWAR. 输出：
(geeksforgeeks, geeksforcse)时间复杂度： O(N * M)，其中M表示最长字符串的长度
辅助空间： 0(N * 256)
如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。