https://leetcode.com/problems/longest-uncommon-subsequence-ii
http://code.bitjoy.net/2017/06/12/leetcode-longest-uncommon-subsequence-ii/
首先我们给字符串按长度来排序，将长度大的放到前面，这样我们如果找到了非共同子序列，那么直接返回其长度即可，因为当前找到的肯定是最长的。然后我们用一个集合来记录已经遍历过的字符串，利用集合的去重复特性，这样在有大量的重复字符串的时候可以提高效率，然后我们开始遍历字符串，对于当前遍历到的字符串，我们和集合中的所有字符串相比，看其是否是某个的子序列，如果都不是，说明当前的就是最长的非共同子序列。注意如果当前的字符串是集合中某个字符串的子序列，那么直接break出来，不用再和其他的比较了，这样在集合中有大量的字符串时可以提高效率，最后别忘了将遍历过的字符串加入集合中
http://www.cnblogs.com/grandyang/p/6680548.html
连暴力搜索的解法也让过，那么还等什么，无脑暴力破解吧。遍历所有的字符串，对于每个遍历到的字符串，再和所有的其他的字符串比较，看是不是某一个字符串的子序列，如果都不是的话，那么当前字符串就是一个非共同子序列，用其长度来更新结果res
X.
https://discuss.leetcode.com/topic/85027/java-hashing-solution
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:
- All the given strings' lengths will not exceed 10.
- The length of the given list will be in the range of [2, 50].
http://code.bitjoy.net/2017/06/12/leetcode-longest-uncommon-subsequence-ii/
首先非公共子序列不可能来自那些出现过多次的字符串，比如数组中有两个字符串都是"abcd"，那么其中一个"abcd"的任意一个子序列，必定是另一个"abcd"的子序列，不满足非公共子序列的定义。所以我们首先对所有字符串及其出现频率hash一下，只考察那些出现一次的字符串的子序列。
另一个观察是，如果存在非公共子序列，则最长的非公共子序列肯定是某个完整的字符串，这一点从LeetCode Longest Uncommon Subsequence I可知。
所以，我们首先把字符串按长度从大到小排序，排序完之后，遍历每个字符串s，如果s出现的频率大于1，直接不考虑；否则，采用贪心策略，我们在比s更长的那些字符串中判断s是否是他们的子序列，如果是，s不是非公共子序列；否则s是非公共子序列，因为后面都是比s更短的字符串，s肯定也不是他们的子序列，又我们根据字符串长度排序了。所以s的长度就是非公共子序列的最大长度。
// 判断child是否是par的子序列 bool isSubSeq(const string& par, const string& child) { int i = 0, j = 0, m = par.size(), n = child.size(); while (i < m&&j < n) { if (par[i] == child[j])++j; ++i; } return j == n; }public: int findLUSlength(vector<string>& strs) { unordered_map<string, int> hash; for (const auto& s : strs)++hash[s]; sort(strs.begin(), strs.end(), [](const string& s1, const string& s2) {return s1.size() > s2.size(); }); for (int i = 0; i < strs.size(); ++i) { if (hash[strs[i]] > 1)continue; bool isSub = false; for (int j = i - 1; j >= 0; --j) { if (isSubSeq(strs[j], strs[i])) { isSub = true; break; } } if (!isSub)return strs[i].size(); } return -1; }};首先我们给字符串按长度来排序，将长度大的放到前面，这样我们如果找到了非共同子序列，那么直接返回其长度即可，因为当前找到的肯定是最长的。然后我们用一个集合来记录已经遍历过的字符串，利用集合的去重复特性，这样在有大量的重复字符串的时候可以提高效率，然后我们开始遍历字符串，对于当前遍历到的字符串，我们和集合中的所有字符串相比，看其是否是某个的子序列，如果都不是，说明当前的就是最长的非共同子序列。注意如果当前的字符串是集合中某个字符串的子序列，那么直接break出来，不用再和其他的比较了，这样在集合中有大量的字符串时可以提高效率，最后别忘了将遍历过的字符串加入集合中
int findLUSlength(vector<string>& strs) { int n = strs.size(); unordered_set<string> s; sort(strs.begin(), strs.end(), [](string a, string b){ if (a.size() == b.size()) return a > b; return a.size() > b.size(); }); for (int i = 0; i < n; ++i) { if (i == n - 1 || strs[i] != strs[i + 1]) { bool found = true; for (auto a : s) { int j = 0; for (char c : a) { if (c == strs[i][j]) ++j; if (j == strs[i].size()) break; } if (j == strs[i].size()) { found = false; break; } } if (found) return strs[i].size(); } s.insert(strs[i]); } return -1; }https://discuss.leetcode.com/topic/85044/python-simple-explanation
When we add a letter Y to our candidate longest uncommon subsequence answer of X, it only makes it strictly harder to find a common subsequence. Thus our candidate longest uncommon subsequences will be chosen from the group of words itself.
Suppose we have some candidate X. We only need to check whether X is not a subsequence of any of the other words Y. To save some time, we could have quickly ruled out Y when len(Y) < len(X), either by adding "if len(w1) > len(w2): return False" or enumerating over A[:i] (and checking neighbors for equality.) However, the problem has such small input constraints that this is not required.
We want the max length of all candidates with the desired property, so we check candidates in descending order of length. When we find a suitable one, we know it must be the best global answer.
def subseq(w1, w2):
#True iff word1 is a subsequence of word2.
i = 0
for c in w2:
if i < len(w1) and w1[i] == c:
i += 1
return i == len(w1)
A.sort(key = len, reverse = True)
for i, word1 in enumerate(A):
if all(not subseq(word1, word2)
for j, word2 in enumerate(A) if i != j):
return len(word1)
return -1public int findLUSlength(String[] strs) {
int len = strs.length;
// reverse sorting array with length
Arrays.sort(strs, new Comparator<String>() {
public int compare(String s1, String s2) {
return s2.length() - s1.length();
}
});
for(int i=0; i<len; i++){
int missMatchCount = strs.length - 1;
for(int j=0; j<len; j++){
if(i != j && !isSubSequence(strs[i], strs[j])){
missMatchCount --;
}
}
// strs[i] is not a sub sequence of any other entry
if(missMatchCount == 0){
return strs[i].length();
}
}
return -1;
}
private boolean isSubSequence(String s1, String s2){
int idx = 0;
for(char ch : s2.toCharArray()){
if(idx < s1.length() && ch == s1.charAt(idx)){
idx++;
}
}
return idx == s1.length();
}http://www.cnblogs.com/grandyang/p/6680548.html
连暴力搜索的解法也让过，那么还等什么，无脑暴力破解吧。遍历所有的字符串，对于每个遍历到的字符串，再和所有的其他的字符串比较，看是不是某一个字符串的子序列，如果都不是的话，那么当前字符串就是一个非共同子序列，用其长度来更新结果res
int findLUSlength(vector<string>& strs) { int res = -1, j = 0, n = strs.size(); for (int i = 0; i < n; ++i) { for (j = 0; j < n; ++j) { if (i == j) continue; if (checkSubs(strs[i], strs[j])) break; } if (j == n) res = max(res, (int)strs[i].size()); } return res; } int checkSubs(string subs, string str) { int i = 0; for (char c : str) { if (c == subs[i]) ++i; if (i == subs.size()) break; } return i == subs.size(); }
X.
https://discuss.leetcode.com/topic/85027/java-hashing-solution
We simply maintain a map of all subsequence frequencies and get the subsequence with frequency 1 that has longest length.
NOTE: This solution does not take advantage of the fact that the optimal length subsequence (if it exists) is always going to be the length of some string in the array. Thus, the time complexity of this solution is non-optimal. See https://discuss.leetcode.com/topic/85044/python-simple-explanation for optimal solution.
public int findLUSlength(String[] strs) {
Map<String, Integer> subseqFreq = new HashMap<>();
for (String s : strs)
for (String subSeq : getSubseqs(s))
subseqFreq.put(subSeq, subseqFreq.getOrDefault(subSeq, 0) + 1);
int longest = -1;
for (Map.Entry<String, Integer> entry : subseqFreq.entrySet())
if (entry.getValue() == 1) longest = Math.max(longest, entry.getKey().length());
return longest;
}
public static Set<String> getSubseqs(String s) {
Set<String> res = new HashSet<>();
if (s.length() == 0) {
res.add("");
return res;
}
Set<String> subRes = getSubseqs(s.substring(1));
res.addAll(subRes);
for (String seq : subRes) res.add(s.charAt(0) + seq);
return res;
}