leetcode 高效制胜 8 字符串

720. 词典中最长的单词

给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。

若无答案，则返回空字符串。

示例 1：

输入：
words = [“w”,“wo”,“wor”,“worl”, “world”]
输出：“world”
解释：
单词"world"可由"w", “wo”, “wor”, 和 "worl"添加一个字母组成。
示例 2：

输入：
words = [“a”, “banana”, “app”, “appl”, “ap”, “apply”, “apple”]
输出：“apple”
解释：
“apply"和"apple"都能由词典中的单词组成。但是"apple"的字典序小于"apply”。

提示：

所有输入的字符串都只包含小写字母。
words数组长度范围为[1,1000]。
words[i]的长度范围为[1,30]。

class Solution {
public:
    string longestWord(vector<string>& words) {
        string ans="";
        unordered_map<string,bool>myMap;
        sort(words.begin(),words.end());
        for(auto w:words){
            if(w.size()==1){
                myMap[w]=1;
                if(w.size()>ans.size())ans=w;
            }
            
            else{
                //cout<<w<<endl;
                string pre=w.substr(0,w.size()-1);
                if(myMap.count(pre)>0){
                    if(w.size()>ans.size())ans=w;
                    myMap[w]=1;
                }               
                
            }
        }
        return ans;
    }
};

1. 排序+哈希
2. unordered_set mySet; mySet.insert(ans);
3. s.substr(int pos,int len)
4. 还有字典序的写法

3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
示例 4:

输入: s = “”
输出: 0

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size()==0)return 0;
        if(s.size()==1)return 1;
        int l=0,r=1;
        int ans=0;
        while(r<s.size()){
            
            int pos=s.find(s[r],l);
            if(pos<r){
                if(r-l>ans)ans=r-l;
                l=pos+1;
            }
            r++;
        }
        if(r-l>ans)ans=r-l;
        return ans;
    }
};

1. 感觉有点像动态规划
2. 注意一下小细节，边界条件
3. 原来这种解法叫滑动窗口
4. s.find(char b, int index)

97. 交错字符串

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。

两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：

s = s1 + s2 + … + sn
t = t1 + t2 + … + tm
|n - m| <= 1
交错 是 s1 + t1 + s2 + t2 + s3 + t3 + … 或者 t1 + s1 + t2 + s2 + t3 + s3 + …
提示：a + b 意味着字符串 a 和 b 连接。

示例 1：

输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出：true
示例 2：

输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出：false
示例 3：

输入：s1 = “”, s2 = “”, s3 = “”
输出：true

提示：

0 <= s1.length, s2.length <= 100
0 <= s3.length <= 200
s1、s2、和 s3 都由小写英文字母组成

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int l1=s1.size(),l2=s2.size(),l3=s3.size();
        if(l1+l2!=l3)return 0;
        if(l1==0)return s2==s3;
        if(l2==0)return s1==s3;
        vector<vector<int>> dp(l1+1,vector<int>(l2+1,0));
        dp[0][0]=1;
        
        for(int i=0;i<=l1;i++){//l
            for(int j=0;j<=l2;j++){//l
                int k=i+j-1;
                if(i>0&&s1[i-1]==s3[k]){
                    dp[i][j]=dp[i][j]|dp[i-1][j];
                }
                if(j>0&&s2[j-1]==s3[k]){
                    dp[i][j]=dp[i][j]|dp[i][j-1];
                }
            }
        }
        return dp[l1][l2];
    }
};

1. 只想说动态规划真的难整，子结构
2. 而且动归，一般都能写成递归，然后就超时了
3. 空间可以优化
4. dfs关键在于剪枝，就是状态重复就返回