524. Longest Word in Dictionary through Deleting

最新推荐文章于 2022-05-20 12:38:25 发布

原创最新推荐文章于 2022-05-20 12:38:25 发布 · 123 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

548 篇文章

订阅专栏

本文介绍了一种算法，用于从给定字符串和字典中找到可通过删除原字符串部分字符而形成的最长字典项。该算法考虑了多个可能的结果，并返回最长且字典序最小的单词。

Given a string and a string dictionary, find the longest string in the dictionary that can be formed by deleting some characters of the given string. If there are more than one possible results, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.

Example 1:

Input:
s = "abpcplea", d = ["ale","apple","monkey","plea"]

Output: 
"apple"

Example 2:

Input:
s = "abpcplea", d = ["a","b","c"]

Output: 
"a"

Note:

All the strings in the input will only contain lower-case letters.
The size of the dictionary won't exceed 1,000.
The length of all the strings in the input won't exceed 1,000

思路：

1、首先判断d[i]是否是s的子串，如果不是，则d[i]不是所求

2、对满足条件的d[i]进行规则匹配

程序如下所示：

class Solution {
    public boolean subStr(String s0, String s1){
        int res = 0, len0 = s0.length(), len1 = s1.length();
        int[][] matrix = new int[len1+1][len0+1];
        for (int i = 1; i <= len1; ++ i){
            for (int j = 1; j <= len0; ++ j){
                if (s1.charAt(i-1) == s0.charAt(j-1)){
                    matrix[i][j] = matrix[i-1][j-1] + 1;
                }
                else {
                    matrix[i][j] = Math.max(matrix[i-1][j], matrix[i][j-1]);
                }
            }
            if (matrix[i][len0] != i){
                return false;
            }
        }
        return matrix[len1][len0] == s1.length();
    }
    
    public String findLongestWord(String s, List<String> d) {
        int len = s.length();
        String res = "";
        for (String val : d){
            if (subStr(s, val)){
                int len0 = res.length(), len1 = val.length();
                if (len1 > len0){
                    res = val;
                }
                else if (len1 == len0){
                    res = res.compareTo(val) > 0?val:res;
                }
            }
        }
        return res;
    }
}

上述解法中，判断d[i]能否通过s删除一些字符得到的方法，可以通过O（n）时间复杂得到，因此可以优化上述过程。