Rust踩雷笔记(2)——一道hard带来的思考[哈希表、字符串、滑动窗口]

今天被一道hard恶心坏了,算法不难,用C++几分钟的事。用rust主要还是缺乏对语言的熟练度,记录一下,主要的坑在下面这个操作:

对String取其中某个位置的char。

可能你会有疑问:这不是直接nth()取就行了么。没错,我看有些题解也是这样做的,但是那样会在某些字符长度很长的样例中OOT。

本文就从代码角度讲下这个问题。此外还有对哈希表更新操作中,不同语句的效率对比。当然我还对一些语法加了详细注释,因为我是初学者,上周六接触到rust,感觉到很有意思,但rust在一些地方的画风的确是不太一样,所以在语法上我需要多花功夫,也希望能帮到有需要的人。

题目简介

https://leetcode.cn/problems/minimum-window-substring/submissions/
链接我复制下来了,题目可以自行去leetcode 76看,我也不讲详细解法,蛮简单的。主要讲讲实现的注意事项。

不得不说注释还是很有用的,一开始的方法我怎么也没找到问题所在,所以索性对所有代码写了注释,最后定位到了罪魁祸首:nth()

代码迭代

这部分就给出几个版本的代码,详细的内容都在注释里,我这里主要写一下注意事项:
给定String s,让你取出里面第i个char,你会怎么做?

// 取s中下标为i的字符,nth()返回的是Option<char>
let c = s.chars().nth(i).unwrap();

相信这种写法你一定能想到,但是它会有什么问题吗?
当然!害我找了一上午bug:如果要遍历其中的char,i的范围是0~s.len() - 1,这种情况下,s如果很长很长,可能会造成OOT。

那你可能会问了:你为啥不用for c in s.chars()
那是因为我要用下标啦;
那你又会问了:用for (idx, c) in s.chars().enumerate()不也可以吗?
的确是可以,但我想了解所有的修改方式,除了上面这两种常见的,就没有别的办法了吗?初学者(出血者)的探索精神是不可阻挡的。

当然有!可以把nth的方式改为as_bytes()[](注意添加as char):

// 重要操作:当只有英文字母的时候,用下面的方式访问
let c = s.as_bytes()[right] as char;
版本一——注意看我把nth改成了什么 & 代码末尾有一些注释记录unwrap、unwrap_or、unwrap_or_else的用法

注意看我把nth修改成什么了

use std::collections::HashMap;

impl Solution {
    pub fn min_window(s: String, t: String) -> String {
        // 定义滑动窗口[left,right)
        let mut left = 0;
        let mut right = 0;

        // ht存储t所有字符的个数,hs存储s[left..right]的所有字符的个数
        // 可以省略掉类型的声明,这里为了好理解所以我写上
        let mut ht: HashMap<char, usize> = HashMap::new();
        let mut hs: HashMap<char, usize> = HashMap::new();

        // 遍历t的所有字符,将它们加入ht中。
        // 遍历字符串的方式是ch in string.chars(),ch就是char型
        for ch in t.chars() {
            // 重要知识:如何改变hashmap中value的值
            // 方式一:entry入参是key,or_insert/or_insert_with/or_default返回的是对value的可变引用
            // let v = ht.entry(ch).or_insert(0);
            // *v += 1;

            // 方式二:直接insert覆盖掉旧值。这里的解引用*不加也不会报错,暂不详原理
            ht.insert(ch, *(ht.get(&ch).unwrap_or(&0)) + 1);
        }

        // 给最小窗口赋予初始值。usize::MAX的方式可以赋一个很大的值
        let mut res = 0..usize::MAX;
        // 表示滑动窗口内,有多少字符是t中的
        let mut cnt = 0;

        // 遍历s中的字符,滑动窗口右端点向右移动
        while right < s.len() {
            // 重要操作:取s中下标为right的字符,nth()返回的是Option<char>
            // 最新:严禁采用这种方式,根据实践这种方式速度有问题,当s.len()范围可以特别大的时候会对某些样例超时
            // let c = s.chars().nth(right).unwrap();
            // 重要操作:当只有英文字母的时候,用下面的方式访问
            let c = s.as_bytes()[right] as char;

            right += 1; // 先将right移动,是因为滑动窗口是左闭右开区间[left, right)

            // 将c加入hs中。v绑定的是c这个key对应的value的可变引用。如果不存在c这个key,就插入并将对应的值设为0
            let v = hs.entry(c).or_insert(0);
            *v += 1;

            // 看一下插入的是否为有效字符
            // 下面*在!=那行省略会报错;在<=那行省略不会报错
            if *(hs.get(&c).unwrap_or(&0)) != 0 &&
               *(hs.get(&c).unwrap_or(&0)) <= *(ht.get(&c).unwrap_or(&0)) {
               cnt += 1; 
            }

            // 最容易写错的地方,如果滑动窗口左端点是重复的,就从hs中去除,并移动左端点
            // 严禁采用这种方式
            // let mut left_char = s.chars().nth(left).unwrap();
            let mut left_char = s.as_bytes()[left] as char;

            // 这里只用unwrap会报错,编译器会认为有对None进行unwrap的风险
            // 查的到就返回&value,查不到就返回&0
            while *(hs.get(&left_char).unwrap_or(&0)) > *(ht.get(&left_char).unwrap_or(&0)) {
                // 这可以是一个万能的更新hashmap中value的方法,用覆盖的方式更新值
                // 不用担心unwrap_or(&0) - 1会不会导致扔个-1进去,能进while循环,就说明值是1起步,减一肯定不为负
                hs.insert(left_char, hs.get(&left_char).unwrap_or(&0) - 1);
                left += 1;
                // 这里对left范围检查,前文也用unwrap_or('0')检查过
                if left >= right {
                    break;
                }
                // left_char = s.chars().nth(left).unwrap();
                left_char = s.as_bytes()[left] as char;
            }

            // res是a..b类型,可以用start和end来访问a和b
            if cnt == t.len() && res.end - res.start > right - left {
                // 更新一波结果
                res = left..right;
            }
        }

        // 如果没找到结果,那么res就还是初始值0..usize::MAX
        if res.end - res.start > s.len() {
            "".to_string()
        } else {
            s[res].to_string()
        }
    }
}

/*
unwrap()有什么风险?
如果是对None调用unwrap是错误的。
如果我确保x不会是None,并对x调用unwrap,看上去就符合逻辑。
但是编译器可能认为这有风险,从而直接报错!
所以要用unwrap_or()或者unwrap_or_else()来代替它。

unwrap_or()怎么用?
assert_eq!(Some("car").unwrap_or("bike"), "car");
assert_eq!(None.unwrap_or("bike"), "bike");
简记:如果是Some()就unwrap,如果是None就是unwrap_or()括号中的值
注意:unwrap_or()的入参类型是T,和Some(T)中的T保持一致,
所以如果是哈希表的get,查出来的是Option<&value>,那么unwrap_or()入参应该是&value

unwrap_or_else()怎么用?
let k = 10;
assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);
assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
简记:和unwrap_or类似,但如果括号内要设定一个表达式,建议用unwrap_or_else,因为它是lazily evaluated
*/
版本二——修改哈希表的不同方式

你可能注意到了,上面的代码片段中,我在注释里写了两种对hashmap的修改方式:entry和insert覆盖,它们两哪种快呢?上面代码是insert覆盖的方式,下面我用entry的方式(代码和版本一变不了多少,再看一次就当巩固了)。

实测这个稍微快一点点。也就是我们修改hashmap的时候可以主要考虑用entry的方式(保留此话修改可能)。

use std::collections::HashMap;

impl Solution {
    pub fn min_window(s: String, t: String) -> String {
        // 定义滑动窗口[left,right)
        let mut left = 0;
        let mut right = 0;

        // ht存储t所有字符的个数,hs存储s[left..right]的所有字符的个数
        // 可以省略掉类型的声明,这里为了好理解所以我写上
        let mut ht: HashMap<char, usize> = HashMap::new();
        let mut hs: HashMap<char, usize> = HashMap::new();

        // 遍历t的所有字符,将它们加入ht中。
        // 遍历字符串的方式是ch in string.chars(),ch就是char型
        for ch in t.chars() {
            // 重要知识:如何改变hashmap中value的值
            // 方式一:entry入参是key,or_insert/or_insert_with/or_default返回的是对value的可变引用
            *ht.entry(ch).or_insert(0) += 1;

            // 方式二:直接insert覆盖掉旧值。这里的解引用*不加也不会报错,暂不详原理
            // ht.insert(ch, *(ht.get(&ch).unwrap_or(&0)) + 1);
        }

        // 给最小窗口赋予初始值。usize::MAX的方式可以赋一个很大的值
        let mut res = 0..usize::MAX;

        // 表示滑动窗口内,已经有valid个字符,数量等于t中该字符数量
        let mut valid = 0;

        // 遍历s中的字符,滑动窗口右端点向右移动
        while right < s.len() {
            // 重要操作:取s中下标为right的字符,nth()返回的是Option<char>
            // 严禁采用这种方式
            // let c = s.chars().nth(right).unwrap();
            let c = s.as_bytes()[right] as char;
            right += 1; // 先将right移动,是因为滑动窗口是左闭右开区间[left, right)

            // 判断字符是否在t中,只有在ht中,才能插入到hs中
            // contains_key的入参是&char
            if ht.contains_key(&c) {
                // 方式一:entry,在leetcode上测的时间方式一似乎比方式二快一些
                *hs.entry(c).or_insert(0) += 1;

                // 方式二:插入覆盖(这里不加*也可以,暂时不知道为什么)
                // hs.insert(c, hs.get(&c).unwrap_or(&0) + 1);
                if hs.get(&c) == ht.get(&c) {
                    valid += 1;
                }
            }

            while valid == ht.len() {
                if right - left < res.end - res.start {
                    res = left..right;
                }

                // 在while中不断将滑动窗口左端点移出,直到跳出这个while,那么再进入外层while
                // 严禁用这种方式
                // let mut left_char = s.chars().nth(left).unwrap();
                let mut left_char = s.as_bytes()[left] as char;
                left += 1;
                if ht.contains_key(&left_char) {
                    // ht中有的才会加入hs,所以要先判断才将left_char从hs中移出
                    // 如果移出之前窗口内left_char的数量等于t中left_char数量,那么valid要减少
                    if hs.get(&left_char) == ht.get(&left_char) {
                        valid -= 1;
                    }
                    // hs.insert(left_char, hs.get(&left_char).unwrap_or(&0) - 1);
                    *hs.entry(left_char).or_insert(0) -= 1;
                }
            }
        }

        // 如果没找到结果,那么res就还是初始值0..usize::MAX
        if res.end - res.start > s.len() {
            "".to_string()
        } else {
            s[res].to_string()
        }
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值