[Leetcode] 522. Longest Uncommon Subsequence II 解题报告

寻找最长非公共子序列

最新推荐文章于 2022-08-01 07:03:55 发布

原创最新推荐文章于 2022-08-01 07:03:55 发布 · 377 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode #解题报告 #Hash Table #String #Sort

IT公司面试习题专栏收录该内容

736 篇文章

订阅专栏

本文介绍了一种算法，用于从多个字符串中找出最长的非公共子序列。通过排序和检查每个字符串是否仅出现一次且不是其他字符串的子序列来确定结果。

题目：

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].

思路：

思路还是沿着上一道题目的：我们首先对所有的字符串进行排序，不过让长的字符串排在前面。然后依次扫描这些字符串，如果发现一个字符串只出现了一次，并且不是它前面的所有字符串的子序列，那么该字符串的长度就是所有字符串的最长非公共子序列了。

代码：

class Solution {
public:
    int findLUSlength(vector<string>& strs) {
        unordered_map<string, int> hash;
        for(int i = 0; i < strs.size(); ++i) {
          ++hash[strs[i]];
        }
        vector<pair<string,int>> v;
        for(auto it = hash.begin(); it != hash.end(); ++it) {
            v.push_back(*it);
        }
        sort(v.begin(), v.end(), PairComp); // longer string comes first
        for(int i = 0; i < v.size(); ++i) {
           if(v[i].second == 1) {
               int j = 0;
               for(; j < i; ++j) {
                   if(isS1subsOfS2(v[i].first, v[j].first))
                     break;
               }
               if(j == i) {
                   return v[i].first.size();
               }
           }
        }
        return -1;
    }
private:
    struct PairCompare {
        bool operator() (pair<string,int> &a, pair<string,int> &b) {
            return a.first.size() > b.first.size();
        }
    } PairComp;
    bool isS1subsOfS2(string &s1, string &s2) {
        int j = 0, i = 0;
        for(; i < s1.size(); ++i) {
            while(j < s2.size() && s1[i] != s2[j]) {
                ++j;
            }
            if(j == s2.size()) {
               return false;
            }
            ++j;
        }
        return true;
    }
};