给定数组中具有最大长度的最长公共前缀的字符串对

给定一个字符串数组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 ² * 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 Classes Live