最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。

说明:

所有输入只包含小写字母 a-z

方法一：横向扫描
依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀

public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) {
        return "";
    }
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++) {
        if (strs[i].isEmpty()) {//如果出现空串直接返回
            return "";
        }
        int j;
        for (j = 0; j < Math.min(prefix.length(), strs[i].length()); j++) {
            if (prefix.charAt(j) != strs[i].charAt(j)) {
                break;
            }
        }
        prefix = prefix.substring(0, j);//更新前缀，注意比较的串可能比prefix短
    }
    return prefix;
}

时间复杂度O(s)，s是所有字符串中字符数量的总和
最坏的情况下，n个字符串都是相同的，会进行s次比较

方法二：纵向扫描
依次比较所有字符串第i个位置是否相等

public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) {
        return "";
    }
    for (int i = 0; i < strs[0].length(); i++) {
        char c = strs[0].charAt(i);
        for (int j = 1; j < strs.length; j++) {
            if (i == strs[j].length() || strs[j].charAt(i) != c) {
                return strs[0].substring(0, i);
            }
        }
    }
    return strs[0];
}

时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次

方法三：分治法
将原问题LCP(i,j)分解成两个子问题LCP(i,mid)、LCP(mid+1,j)
利用子问题的解构造原问题的解，依次计算它们的最长公共前缀

public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) {
        return "";
    }
    return longestCommonPrefix(strs, 0, strs.length - 1);
}

public String longestCommonPrefix(String[] strs, int start, int end) {
    if (start >= end) {
        return strs[start];
    }
    int mid = start + (end - start) / 2;
    String s1 = longestCommonPrefix(strs, start, mid);
    String s2 = longestCommonPrefix(strs, mid + 1, end);
    return longestCommonPrefix(s1, s2);
}

public String longestCommonPrefix(String s1, String s2) {
    int i;
    for (i = 0; i < Math.min(s1.length(), s2.length()); i++) {
        if (s1.charAt(i) != s2.charAt(i)) {
            break;
        }
    }
    return s1.substring(0, i);
}

时间复杂度O(S)
最坏情况下，n个长度为m相同的串
T(n)=2T(n/2)+O(m) 化简得O(S)
空间复杂度O(logn*m)

方法四：二分查找
最长公共前缀的长度不会超过字符串数组中的最短字符串的长度。用minLen 表示字符串数组中的最短字符串的长度，则可以在[0,minLen] 的范围内通过二分查找得到最长公共前缀的长度
每次取查找范围的中间值 mid，判断每个字符串的长度为mid 的前缀是否相同，如果相同则最长公共前缀的长度一定大于或等于mid，如果不相同则最长公共前缀的长度一定小于mid，通过上述方式将查找范围缩小一半，直到得到最长公共前缀的长度

public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) {
        return "";
    }
    int minLen = Integer.MAX_VALUE;
    for (String s : strs) {
        minLen = Math.min(minLen, s.length());
    }
    int low = 0;
    int high = minLen;
    while (low < high) {
        int mid = low + (high - low + 1) / 2;
        if (isCommonPrefix(strs, mid)) {
            low = mid;
        } else {
            high = mid - 1;
        }
    }
    return strs[0].substring(0, low);
}

public boolean isCommonPrefix(String[] strs, int len) {
    String prefix = strs[0].substring(0, len);
    for (int i = 1; i < strs.length; i++) {
        for (int j = 0; j < len; j++) {
            if (prefix.charAt(j) != strs[i].charAt(j)) {
                return false;
            }
        }
    }
    return true;
}

时间复杂度：O(mnlogm)，其中 m 是字符串数组中的字符串的最小长度，n 是字符串的数量。二分查找的迭代执行次数是O(logm)，每次迭代最多需要比较 mn个字符，因此总时间复杂度是O(mnlogm)

方法五：前缀树

class Trie {

    class TrieNode {
        Map<Character, TrieNode> map = new HashMap<>();
        int count;
        boolean isEnd;

        TrieNode(int count) {
            this.count = count;
        }
    }

    private TrieNode root = new TrieNode(0);

    boolean add(String word) {
        if (word.isEmpty()) {
            return false;
        }
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
            Character c = word.charAt(i);
            if (node.map.get(c) == null) {
                TrieNode newNode = new TrieNode(1);
                if (i == word.length() - 1) {
                    newNode.isEnd = true;
                }
                node.map.put(c, newNode);
                node = newNode;
            } else {
                node.map.get(c).count++;
                if (i == word.length() - 1) {
                    node.map.get(c).isEnd = true;
                }
                node = node.map.get(c);
            }
        }
        return true;
    }

    String longestPrefix(String s, int count) {
        if (root.map.size() > 1) {
            return "";
        }
        TrieNode node = root;
        int index = 0;
        while (node == root ||
                !node.isEnd && node.map.size() == 1 && node.count == count) {
            node = node.map.get(s.charAt(index));
            index++;
        }
        return s.substring(0, index);
    }
}

class Solution {

    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }
        Trie trie = new Trie();
        for (String s : strs) {
            if (!trie.add(s)) return "";
        }
        return trie.longestPrefix(strs[0], strs.length);
    }
}