Leetcode——通过删除字母匹配到字典里最长单词（子序列）

Posted 2021-09-25 Yawn,

1. 通过删除字母匹配到字典里最长单词

• 要从字符串数组 d 中，找到一个可以从字符串 s 中，删除某些字符来得到的字符串（本文中把这种符合要求的字符串称为 s 的子序列
• ，这个字符串要长度最长且字典序最小。我们的主要思路就是先找到字符串数组中，所有的字符串 s 的子序列，然后比较其长度和字典序。

（0）首先：判断子序列

• 需要注意的是 “ace” 是 “abcde” 的一个子序列，而 “aec” 不是。

1.双指针

使用两个指针分别指向两个字符串的起始索引，每次循环判断两个指针指向的字符是否相等，相等则两个指针向右移动，不相等则只移动 s 的指针。最后如果 t 指针移动到末尾，则 t 是为 s 的子序列。

class Solution {

    public boolean isSubsequence(String t, String s) {
        int indext = 0, indexs = 0;
        while (indext < t.length() && indexs < s.length()) {
            if (t.charAt(indext) == s.charAt(indexs)) {
                indext++;
            }
            indexs++;
        }
        return indext == t.length();
    }
}

2.使用API

直接使用 indexOf 方法，判断从指定下标起，是否存在字符 c。不存在，则 t 不是为 s 的子序列

class Solution {
    
    public boolean isSubsequence(String t, String s) {
        int index = -1;
        for (int i = 0; i < t.length(); i++) {
        	//从index + 1开始获取字符t.charAt(i)在s中的的位置
            index = s.indexOf(t.charAt(i), index + 1);		
            if (index == -1) {
                return false;
            }
        }
        return true;
    }
}

（1）双指针

class Solution {

    public String findLongestWord(String s, List<String> d) {
        String result = "";
        for (String t : d) {
            if (isSubsequence(t, s)) {
                // 获取长度最长且字典顺序最小的字符串
                if (result.length() < t.length() || (result.length() == t.length() && result.compareTo(t) > 0)) {
                    result = t;
                }
            }
        }
        return result;
    }

    // 判断 t 是否为 s 的子序列
    public boolean isSubsequence(String t, String s) {
        int indext = 0, indexs = 0;
        while (indext < t.length() && indexs < s.length()) {
            if (t.charAt(indext) == s.charAt(indexs)) {
                indext++;
            }
            indexs++;
        }
        return indext == t.length();
    }
}

（2）API

class Solution {
    
    public String findLongestWord(String s, List<String> d) {
        String result = "";
        for (String t : d) {
            if (isSubsequence(t, s)) {
                // 获取长度最长且字典顺序最小的字符串
                if (result.length() < t.length() || (result.length() == t.length() && result.compareTo(t) > 0)) {
                    result = t;
                }
            }
        }
        return result;
    }

    // 判断 t 是否为 s 的子序列
    public boolean isSubsequence(String t, String s) {
        int index = -1;
        for (int i = 0; i < t.length(); i++) {
            index = s.indexOf(t.charAt(i), index + 1);
            if (index == -1) {
                return false;
            }
        }
        return true;
    }
}

（3）DP

class Solution {

    public String findLongestWord(String s, List<String> d) {
        int n = s.length();
        int[][] dp = new int[n + 1][26];
        // 初始化结尾
        for (int i = 0; i < 26; i++) {
            dp[n][i] = n;
        }
        // 初始化 dp 数组
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j < 26; j++) {
                if (s.charAt(i) - 'a' == j) {
                    dp[i][j] = i;
                } else {
                    dp[i][j] = dp[i + 1][j];
                }
            }
        }
        String result = "";
        for (String t : d) {
            // count 记录相等字符的个数
            int count = 0, index = 0;
            for (char c : t.toCharArray()) {
                // 如果下一个字符的下标为 n，则表示该字符不存在
                if (dp[index][c - 'a'] == n) {
                    break;
                }
                count++;
                // 移动到下一个字符的后面
                index = dp[index][c - 'a'] + 1;
            }
            // 判断是否到了最后一个字符
            if (count == t.length()) {
                // 长度最长且字典顺序最小的字符串
                if (t.length() > result.length() || (t.length() == result.length() && result.compareTo(t) > 0)) {
                    result = t;
                }
            }
        }
        return result;
    }
}