Pair of strings having longest common prefix of maximum length in given array

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);
  }
}

// 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);
    }
}