当Rust遇上LeetCode #76. 最小覆盖子串 [困难]

2020/3/15

题目描述

给你一个字符串 S、一个字符串 T,请在字符串 S 里面找出:包含 T 所有字母的最小子串。

示例

示例:
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"

说明:
如果 S 中不存这样的子串,则返回空字符串 ""。
如果 S 中存在这样的子串,我们保证它是唯一的答案。

相关标签

哈希表
双指针
字符串
Sliding Window

解题思路

  • 算法:
    滑动窗口算法的思路是这样:
    1、我们在字符串 S 中使用双指针中的左右指针技巧,初始化 left = right = 0,把索引闭区间 [left, right] 称为一个「窗口」。
    2、我们先不断地增加 right 指针扩大窗口 [left, right],直到窗口中的字符串符合要求(包含了 T 中的所有字符)。
    3、此时,我们停止增加 right,转而不断增加 left 指针缩小窗口 [left, right],直到窗口中的字符串不再符合要求(不包含 T 中的所有字符了)。同时,每次增加 left,我们都要更新一轮结果。
    4、重复第 2 和第 3 步,直到 right 到达字符串 S 的尽头。
    这个思路其实也不难,第 2 步相当于在寻找一个「可行解」,然后第 3 步在优化这个「可行解」,最终找到最优解。左右指针轮流前进,窗口大小增增减减,窗口不断向右滑动。
    另外,可以使用一个哈希表map来记录 t 字符串中每一个字母出现的次数,cnt变量来记录还没有include的字符个数。每次找到 map 中存在的一个字母时(并且对应字母剩余的次数不为0),cnt -=1;cnt == 0 时,说明已经找到了一个覆盖 t 中所有字母的子串,之后可以移动 left 指针。

  • 复杂度分析:
    时间复杂度:O(M + N),M 和 N 分别是字符串 S 和 T 的长度。
    空间复杂度:O(N)

源代码

use std::collections::{HashMap, VecDeque};

impl Solution {
    pub fn min_window(s: String, t: String) -> String {
        // store_t
        let (mut map_t, mut deque_s, mut cnt) = (HashMap::new(), VecDeque::new(), 0);
        let (mut res_left, mut res_right, mut res_len) = (0, 0, std::usize::MAX);
        let (mut left, mut right, mut not_init) = (0, 0, true);

        for c in t.chars() {
            map_t.entry(c).or_insert(0);
            *map_t.get_mut(&c).unwrap() += 1;
            cnt += 1;
        }

        for c in s.chars() {
            if map_t.contains_key(&c) {                
                deque_s.push_back(right);
                if not_init {
                    not_init = false;
                    left = deque_s.pop_front().unwrap();   
                }

                let mut map_c = map_t.get_mut(&c).unwrap();
                if *map_c > 0 {
                    cnt -= 1;
                }    
                *map_c -= 1;
              
                if cnt == 0 {
                    if left == right {
                        let mut res = String::new();
                        res.push(c);
                        return res;
                    }
                    while deque_s.front() != None {
                        // let mut left_char = s.chars().nth(left).unwrap(); //Don't do this!!!
                        let mut left_char = s[left..left+1].to_string().chars().next().unwrap();
                        map_c = map_t.get_mut(&left_char).unwrap();
                        *map_c += 1;
                        if *map_c > 0 {                            
                            let sub_len = right - left + 1;
                            if res_len > sub_len { res_left = left; res_right = right; res_len = sub_len; };
                            left = deque_s.pop_front().unwrap();
                            cnt += 1;   
                            break;
                        }
                        left = deque_s.pop_front().unwrap();
                    }
                }
            }
            right += 1;
        }

        if res_left != res_right {
            s[res_left..res_right+1].to_string()
        }
        else {
            String::new()
        }
    }
}

执行用时 : 8 ms, 在所有 Rust 提交中击败了80.00%的用户
内存消耗 : 2.2 MB, 在所有 Rust 提交中击败了25.00%的用户

总结

使用 s.chars().nth(left).unwrap() 方法来获取索引字符串会相当耗时,如果字符串中字符占用空间大小确定已知,可以使用 s[left..left+1].to_string().chars().next().unwrap() 来获取。另外本题中使用了一个VecDeque来加速 left 指针的遍历速度。

你可能感兴趣的:(当Rust遇上LeetCode #76. 最小覆盖子串 [困难])