Leetcode算法入门 - 滑动窗口

• 用Rust写滑动窗口目前对自己来说实在是一件难事.... 于是乎参考了很多的Rust高人们的编写思路，虽说用C写感觉也挺有挑战性；
• 今日无事，便来用滑动窗口来折磨下自己，从明日起就开始更加磨人的图论...；

目录

Leetcode算法入门 - 滑动窗口

一、3 - 无重复字符的最长子串

二、567 - 字符串的排列

---

Leetcode算法入门 - 滑动窗口

一、3 - 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
 

提示：

s 由英文字母、数字、符号和空格组成

链接：力扣https://leetcode.cn/problems/longest-substring-without-repeating-characters/

• C

int lengthOfLongestSubstring(char * s) {
    int left = 0, right = 0;
    int max = 0, i, j;
    int len = strlen(s);
    int haveSameChar = 0;
    for(i = 0; i < len ; i++) {
        if(left <= right) {
            haveSameChar = 0;
            for(j = left; j < right ; j++) {
                if(s[j] == s[right]) {
                    haveSameChar = 1;
                    break;
                }
            }
            if(haveSameChar) {
                left = j + 1;
            }
        }
        max = max < (right - left + 1) ? (right - left + 1): max;
        right++;
    }
    return max;
}

• Rust

impl Solution {
    pub fn length_of_longest_substring(s: String) -> i32 {
        let mut ans = 0;
        let mut l = 0;
        let mut cache = vec![0; 128];
        s.chars().enumerate().for_each(|(i, ch)| {  // i as usize by default
            l = l.max(cache[ch as usize]);
            ans = ans.max(i as i32 - l + 1);
            cache[ch as usize] = i as i32 + 1;
        });
        ans
    }
}

 

二、567 - 字符串的排列

给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。

换句话说，s1 的排列之一是 s2 的 子串 。

示例 1：

输入：s1 = "ab" s2 = "eidbaooo"
输出：true
解释：s2 包含 s1 的排列之一 ("ba").
示例 2：

输入：s1= "ab" s2 = "eidboaoo"
输出：false
 

提示：

s1 和 s2 仅包含小写字母

链接：力扣https://leetcode.cn/problems/permutation-in-string/

• C

bool checkInclusion(char* s1, char* s2) {
    int n = strlen(s1), m = strlen(s2);
    if (n > m) {
        return false;
    }
    int cnt[26];
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; ++i) {
        --cnt[s1[i] - 'a'];
        ++cnt[s2[i] - 'a'];
    }
    int diff = 0;
    for (int i = 0; i < 26; ++i) {
        if (cnt[i] != 0) {
            ++diff;
        }
    }
    if (diff == 0) {
        return true;
    }
    for (int i = n; i < m; ++i) {
        int x = s2[i] - 'a', y = s2[i - n] - 'a';
        if (x == y) {
            continue;
        }
        if (cnt[x] == 0) {
            ++diff;
        }
        ++cnt[x];
        if (cnt[x] == 0) {
            --diff;
        }
        if (cnt[y] == 0) {
            ++diff;
        }
        --cnt[y];
        if (cnt[y] == 0) {
            --diff;
        }
        if (diff == 0) {
            return true;
        }
    }
    return false;
}

• Rust

impl Solution {
    pub fn check_inclusion(s1: String, s2: String) -> bool {
        if s1.len() > s2.len() { 
            return false; 
        }
        let mut freq = vec![0; 26];
        for ch in s1.bytes() { 
            freq[ch as usize - 97] += 1; 
        }
        let s2 = s2.into_bytes();
        let mut window_freq = vec![0; 26];
        let k = s1.len();
        for i in 0..k {
            window_freq[s2[i] as usize - 97] += 1;
        }
        if window_freq == freq { 
            return true; 
        }
        for i in k..s2.len() {
            window_freq[s2[i - k] as usize - 97] -= 1;
            window_freq[s2[i] as usize - 97] += 1;
            if window_freq == freq { 
                return true; 
            }
        }
        false
    }
}

 

每一个不曾起舞的日子，都是对生命的辜负。