力扣：524. 通过删除字母匹配到字典里最长单词

题目：494. 目标和

难度： 中等

题目：

给你一个字符串 s 和一个字符串数组 dictionary 作为字典，找出并返回字典中最长的字符串，该字符串可以通过删除 s 中的某些字符得到。

如果答案不止一个，返回长度最长且字典序最小的字符串。如果答案不存在，则返回空字符串。

示例1

输入：s = “abpcplea”, dictionary = [“ale”,“apple”,“monkey”,“plea”]
输出：“apple”

示例2

输入：s = “abpcplea”, dictionary = [“a”,“b”,“c”]
输出：“a”

提示：

• 1 <= s.length <= 1000
• 1 <= dictionary.length <= 1000
• 1 <= dictionary[i].length <= 1000
• s 和 dictionary[i] 仅由小写英文字母组成

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

解题思路

题意，字符串数组 dictionary 在字符串s中匹配从前往后匹配字符，能完全匹配的最长且字典序最小的字符串即为所求。

坑点，注意不能单纯使用哈希表匹配，因为字符串匹配是有顺序的，其实本质上是求子序列的问题。

（1）双指针

双指针很好理解，一个指针i表示s的位置，一个指针j表示str的位置，j在遍历时一直往后移动，如果s[i] == str[j]，i才往后移动。匹配时若i到了尽头，则表示匹配成功。

class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        //处理
        string ans;
        int n = s.size();
        for (auto& str : dictionary)
        {
            int m = str.size();
            int i = 0, j = 0;
            while (i < m && j < n)
            {
                if (str[i] == s[j]) i++;
                j++;
            }
            //处理
            if (i == m)
            {
                if (str.size() > ans.size())
                {
                    ans = str;
                }
                else if (str.size() == ans.size() && str < ans)
                {
                    ans = str;
                }
            }
        }
        return ans;
    }
};

（2）排序+双指针

题意，需要我们找到长度最大且字典序最小的字符串，那么我们可以在之前先将字符串数组 dictionary 按长度、字典序排序，那么双指针匹配的第一个元素即为所求。

实际上思路和双指针一直。

class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        //处理
        string ans;
        int n = s.size();
        sort(dictionary.begin(), dictionary.end(), [&](string& op1, string& op2) {
            return op1.size() != op2.size() ? op1.size() > op2.size() : op1 < op2;
        });
        for (auto& str : dictionary)
        {
            int m = str.size();
            int i = 0, j = 0;
            while (i < m && j < n)
            {
                if (str[i] == s[j]) i++;
                j++;
            }
            //处理
            if (i == m)
            {
                ans = str;
                break;
            }
        }
        return ans;
    }
};

（3）动态规划

详细思路见：官方题解
关键：

• 数组，dp[n + 1][26]，n为s的大小，第一维标记在s中的位置，第二维表示26个字母。
• dp[i][j]表示，在字符串s的第i个位置的字符等于字符j，在字符串s中第一个出现的位置。

class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        //动态规划
        int n = s.size();
        vector<vector<int>> dp(n + 1, vector<int>(26));
        fill(dp[n].begin(), dp[n].end(), n);//处理末尾的数据
        //动态规划预处理
        for (int i = n - 1; i >= 0; i--)
        {
            for (int j = 0; j < 26; j++)
            {
                if (s[i] == 'a' + j)
                {
                    dp[i][j] = i;
                }
                else
                {
                    dp[i][j] = dp[i + 1][j];
                }
            }
        }
        //求解
        string ans;
        for (auto& str : dictionary)
        {
            int i = 0;
            bool flag = true;
            for (auto& ch : str)
            {
                if (dp[i][ch - 'a'] == n)
                {
                    flag = false;
                    break;
                }
                i = dp[i][ch - 'a'] + 1;//s中第一个ch元素的下一个位置
            }
            if (flag)
            {
                if (str.size() > ans.size() || (str.size() == ans.size() && str < ans))
                {
                    ans = str;
                }
            }
        }
        return ans;
    }
};