LeetCode双指针+排序解决序列包含问题

LeetCode双指针+排序解决序列包含问题

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

题目描述

今天的不会做哇！！！

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

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

示例 1：

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

示例 2：

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

解题思路1

用两个指针pt和ps指向两个字符串的开始位置，进行以下操作，直到其中一个指针越界。

1. 比较 pt 和 ps 指向的字符
2. 如果相等： 两个指针同时向后移动
3. 如果不等： 移动源指针，试图从源序列的下一个位置匹配。因为目标序列的每个字符都需要出现在s中才能算序列包含。
   这样，越界的时候如果pt已经指向目标序列的最后一个位置+1，说明目标序列已经完全包含于源序列了。

来自作者：微扰理论

Code

class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        string ans = "";
        int ps = 0;
        int pw = 0;

        for (auto w: dictionary) {
            ps = 0;
            pw = 0;
            if (w.size() < ans.size()) continue;
            // 双指针 - 序列包含问题
            while (pw < w.size() && ps < s.size()) {
                if (s[ps] == w[pw]) {
                    // 两个指针所指字符相等 同时后移
                    ps++;
                    pw++;
                } else {
                    // 不等 后移源指针
                    ps++;
                }
            }
            // 如果pw没有到达最后的位置 说明不够称包含关系
            if (pw < w.size()) continue;
            if (w.size() > ans.size()) {
                ans = w;
                continue;
            }
            if (w.size() == ans.size() && w < ans) {
                ans = w;
            }
        }

        return ans;
    }
};

解题思路2

Code2

public class Solution1 {
    public static String findLongestWord(String s, List<String> dictionary) {
        //将s转化为数组
        char[]arr=s.toCharArray();
//        对字典进行排序，第一优先级长度，越长的越靠前；第二优先级字典序，越小的越靠前
        dictionary.sort((a,b)->{
            if (a.length()!=b.length()){
                return Integer.compare(b.length(),a.length());
            }
            return a.compareTo(b);
        });
//        遍历字典
        for (String a:dictionary) {
            if (isLong(arr,a.toCharArray()))return a;
        }
        return "";
    }
    public static Boolean isLong(char[] s, char[] dic){

        int n=s.length;
        int m=dic.length;
//        如果要子串大于母串一定不匹配
        if (m>n)return false;
        int i=0;
        for (char ch:dic) {
//            按顺序进行匹配的，i 的更新应该是 i 的新值为找到的字符 'a' 的位置 + 1
            while (i<n&&ch!=s[i])i++;
            if (i>=n)return false;
            i++;
        }
        return true;
    }

    public static void main(String[] args) {
//        solution te=new solution();
        List<String> dictionary = Arrays.asList("ale", "apple", "monkey", "plea");
        String result = findLongestWord("abpcplea", dictionary);
        System.out.println(result);
    }
}

);
String result = findLongestWord(“abpcplea”, dictionary);
System.out.println(result);
}
}