522. 最长特殊序列 II

给定字符串列表，你需要从它们中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。

子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。

输入将是一个字符串列表，输出是最长特殊序列的长度。如果最长特殊序列不存在，返回 -1 。

 

示例：

输入: "aba", "cdc", "eae"
输出: 3
 

提示：

所有给定的字符串长度不会超过 10 。
给定字符串列表的长度将在 [2, 50 ] 之间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-uncommon-subsequence-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int findLUSlength(String[] strs) {
        boolean[] flags = new boolean[strs.length];
        // 暴力，外层为父字符串
        for (int i = 0; i < strs.length; i++) {
            // 内层为子字符串
            for (int j = 0; j < strs.length; j++) {
                // 一旦子字符串是父子字符串的子序列，那么将子字符串标记扔掉。
                if (i != j && contains(strs[i], strs[j])) {
                    flags[j] = true;
                }
            }
        }
        int maxLen = -1;
        for (int i = 0; i < strs.length; i++) {
                // 找到一个不是子字符串的字符串
            if (!flags[i]) {
                // 判断长度.
                maxLen = maxLen > strs[i].length() ? maxLen : strs[i].length();
            }
        }
        return maxLen;
    }

    /**
     * 如果str1 是str 的子序列
     */
    private boolean contains(String str, String str1) {
        int i2 = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == str1.charAt(i2)) {
                i2++;
                if (i2 == str1.length()) {
                    return true;
                }
            }
        }
        return false;
    }
}

思路：先去除重复的，再用一个数组存储不重复的，判断每一个是否是原字符串数组中的任意一项的子数组，这里要注意，判断的时候要找比自己长度长的，因为不可能是短的子序列，和自己一样的也不行，因为自己就是自己的子序列。

作者：xin-de-bu-fa
链接：https://leetcode-cn.com/problems/longest-uncommon-subsequence-ii/solution/qu-zhong-cun-chu-bian-li-shu-chu-by-xin-de-bu-fa/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public static int findLUSlength(String[] strs) {
        HashMap<String, Integer> map = new HashMap<>();
        //用map存储相同的，直接把相同的除去
        for (int i = 0; i < strs.length; i++) {
            if(map.containsKey(strs[i])){
                map.put(strs[i],map.get(strs[i])+1);
            }else{
                map.put(strs[i], 1);
            }
        }
        //存储不重复的
        String string[] = new String[50];
        //计数不重复的
        int count = 0;
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            //去除重复的
            if(entry.getValue()<2){
                string[count++] = entry.getKey();
            }
        }
        //长度
        int len = 0;
        //表示全部重复
        if(count == 0){
            return -1;
        }else{
            //超过一个元素的，一个个判断，
            for (int i = 0; i < count; i++) {
                //是子集，直接跳过
                if(isSub(strs,string[i])){
                    continue;
                }else{
                    //不是子集，选择最大的长度
                    len = Math.max(len,string[i].length());
                }
            }
        }
        return len == 0 ? -1 : len;
    }
    /*
        判断是否包含子集，因为涉及到元素的删除之后只要相对顺序
        保持不变还是会算过子集，所以需要一位位判断
     */
    private static boolean containsSub(String s,String p){
        int i,j;
        for(i=0,j=0;i<p.length()&&j<s.length();j++) {
            if (s.charAt(j) == p.charAt(i)) {
                i++;
            }
        }
        if (i >= p.length()) return true;
        return false;
    }
    private static boolean isSub(String[] strs, String s){
        for (int i = 0; i < strs.length; i++) {
            //如果字符串数组中子元素长度小于需要比较的直接跳过
            if(s.length() < strs[i].length() && containsSub(strs[i],s)){
                return true;
            }
        }
       return false;
    }
}