zoukankan      html  css  js  c++  java
  • 522. Longest Uncommon Subsequence II

    Given a list of strings, you need to find the longest uncommon subsequence among them. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.

    A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.

    The input will be a list of strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.

    Example 1:

    Input: "aba", "cdc", "eae"
    Output: 3

    Note:

    1. All the given strings' lengths will not exceed 10.
    2. The length of the given list will be in the range of [2, 50].

    Approach #1: Simulate. [Java]

    class Solution {
        
        public int findLUSlength(String[] strs) {
            Arrays.sort(strs, new Comparator<String>() {
                public int compare(String o1, String o2) {
                    return o2.length() - o1.length();
                } 
            });
            
            Set<String> duplicates = getDuplicates(strs);
            for (int i = 0; i < strs.length; ++i) {
                if (!duplicates.contains(strs[i])) {
                    if (i == 0) return strs[0].length();
                    for (int j = 0; j < i; ++j) {
                        if (isSubsequence(strs[j], strs[i])) break;
                        if (j == i - 1) return strs[i].length();
                    }
                }
            }
            
            return -1;
        }
        
        boolean isSubsequence(String a, String b) {
            int i = 0, j = 0;
            while (i < a.length() && j < b.length()) {
                if (a.charAt(i) == b.charAt(j)) ++j;
                ++i;
            }
            return j == b.length();
        }
        
        Set<String> getDuplicates(String[] strs) {
            Set<String> set = new HashSet<String>();
            Set<String> duplicates = new HashSet<String>();
            for (String str : strs) {
                if (set.contains(str)) duplicates.add(str);
                set.add(str);
            }
            return duplicates;
        }
    }
    

      

    Analysis:

    Sort the string in the reverse order. If there is not duplicates in the array, then the longest string is the answer.

    But if there are duplicates, and if the longset string is not the answer, then we need to check other strings. But the smaller string can be subsequence of the bigger string. For this reason, we need to check if the string is a subsquence of all the strings bigger than itself. If not, that is the answer.

    Reference:

    https://leetcode.com/problems/longest-uncommon-subsequence-ii/discuss/99443/Java(15ms)-Sort-%2B-check-subsequence

    永远渴望,大智若愚(stay hungry, stay foolish)
  • 相关阅读:
    javascript 文档标题滚动 实例
    Unity3D初学之2D动画制
    Uni2D 入门 -- Skeletal Animation
    Uni2D 入门 -- Asset Table
    Uni2D 入门 -- Atlas转载 http://blog.csdn.net/kakashi8841/article/details/17588095
    Uni2D 入门 -- Animation Clip 和 Animation API
    Uni2D入门
    将博客搬至CSDN
    unity 2048Game
    c#单例模式
  • 原文地址:https://www.cnblogs.com/h-hkai/p/10732789.html
Copyright © 2011-2022 走看看