Find the Longest Common Prefix Using Binary Search in Java

The Longest Common Prefix (LCP) problem stands for finding the longest string, which is a prefix of all strings in a given list; this is a classical problem for computer science that has many applications, for example, in DNA sequence analysis, auto-completion, data compression, and other fields.

Problem Statement

The problem is simple to understand: given a set of strings, find out which string of the longest common prefixes can combinedly be linked with all the strings of the given set.

For instance, for the set of strings: ["flower," "flow," "flight"], the longest common prefix is "fl."

But when it comes to solution strategies, the number can be counted on one's fingers: simple, optimized, and using binary search - and the latter is one of the most effective.

Binary search is generally used for finding elements of sorted arrays; however, the same technique can be used creatively to search the given prefixes and decide the length up to which the prefixes are common.

Solution to the Problem

Determine the Shortest String: A longest common prefix can not be longer than the shortest string in an array, so the first should find how long it is. To break it down, this length gives us the maximum number of iterations that are possible with the binary search.

Binary Search on Prefix Length: In particular, we utilize binary search to quickly come up with the maximum possible value which can be assigned to the common prefix.

Binary search range lies between 0 and the length of the shortest string because every string of the list must have at least one common prefix and the maximum is when the string itself is the prefix.

Then for every midpoint (mid) in this range one checks if all the strings have a common prefix of size mid. If they do, we attempt to get a longer prefix; if they do not, the prefix is made shorter.

Prefix Validation: After each length found out by the binary search, there is the question of as to whether all the strings really do have the same prefix of that length. This comprises a comparison of the first part of the first string with other strings' segments of equal or greater length.

File Name: LongestCommonPrefixBinarySearch.java

 
public class LongestCommonPrefixBinarySearch {
    // Method to find the longest common prefix using binary search
    public static String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int minLength = findMinLength(strs);  // Find the length of the shortest string
        int left = 0, right = minLength;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (isCommonPrefix(strs, mid)) {
                left = mid + 1;  // Try for a longer common prefix
            } else {
                right = mid - 1;  // Try for a shorter common prefix
            }
        }
        // The longest common prefix length is the right value
        return strs[0].substring(0, right);
    }
    private static int findMinLength(String[] strs) {
        int minLength = Integer.MAX_VALUE;
        for (String str : strs) {
            minLength = Math.min(minLength, str.length());
        }
        return minLength;
    }
    private static boolean isCommonPrefix(String[] strs, int len) {
        String prefix = strs[0].substring(0, len);
        for (int i = 1; i < strs.length; i++) {
            if (!strs[i].startsWith(prefix)) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String[] strs = {"flower", "flow", "flight"};
        System.out.println("Longest Common Prefix: " + longestCommonPrefix(strs));  // Expected output: "fl"
        strs = new String[]{"dog", "racecar", "car"};
        System.out.println("Longest Common Prefix: " + longestCommonPrefix(strs));  // Expected output: ""
    }
}   

Output:

 
Longest Common Prefix: fl
Longest Common Prefix:

Time Complexity: This is because the construction of an RSA encryption key requires the generation of two large prime numbers, which is O(log M), and the strings will be on the whole on the whole of order N, thus making the time complexity O(N * log M). The binary search in O(log M), and each time, the check for whether that string is a prefix in the other string takes O(N).

Space Complexity: The space complexity of this algorithm is O(1), because auxiliary space needed is only a few end indices and lengths.

Conclusion

Binary search for finding out the LCP is quite efficient as well as elegant to compute the answer when other solutions take even more time to compute the solution for larger sets of strings. Indeed, the binary search significantly helps to reduce the possible number of the prefix length to find the best way with less calculation. It must be said that the provided Java implementation is both concise and effective enough to be employed in actual projects and rated among competitive programming tendencies.

Next TopicFind-the-longest-sequence-of-zeros-in-the-binary-representation-of-an-integer

← prev next →