1

Author: Ainevsia

notes/src/day7/lc15.md

@@ -49,4 +49,43 @@ impl Solution {
 
 双指针做法还是想不到
 
-## 学习感想
+## 学习感想
+
+
+
+想不到用双指针
+
+```rust
+
+struct Solution {}
+
+impl Solution {
+    pub fn three_sum(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+        nums.sort();
+        let mut res: Vec<Vec<i32>> = Vec::new();
+        for i in 0..nums.len() - 2usize {
+            if i > 0 && nums[i] == nums[i-1usize] { continue }
+            let mut left: usize = i + 1usize;
+            let mut right: usize = nums.len() - 1usize;
+            use std::cmp::Ordering;
+            while left < right {
+                let s: i32 = nums[i] + nums[left] + nums[right];
+                match s.cmp(&0i32) {
+                    Ordering::Less => left += 1usize,
+                    Ordering::Greater => right -= 1usize,
+                    _ => {
+                        let to_push: Vec<i32> = vec![nums[i], nums[left], nums[right]];
+                        if res.is_empty() || Some(&to_push) != res.last() {
+                            res.push(to_push);
+                        }
+                        left += 1usize;
+                        right -= 1usize;
+                    }
+                }
+            }
+        }
+        res
+    }
+}
+
+```

notes/src/day7/lc454.md

@@ -79,7 +79,7 @@ impl Solution {
 
 
 
-
+地一下子还是没有想到要用hashmap做，感觉可能是双指针
 
 ```rust
 struct Solution {}

notes/src/day8/lc151.md

@@ -53,4 +53,17 @@ impl Solution {
 }
 ```
 
-## 学习感想
+## 学习感想
+
+
+```rust
+
+struct Solution {}
+impl Solution {
+    pub fn reverse_words(s: String) -> String {
+        s.split_ascii_whitespace().rev().collect::<Vec<&str>>().join(" ")
+        //  ^ String -> &str
+        //                   ^ iter  Target=&str           ^ Vec<&str>
+    }
+}
+```

notes/src/day8/lc541.md

@@ -36,4 +36,23 @@ slice是实现`std::iter::DoubleEndedIterator`的，所以可以reverse，iter
 
 Vec是实现`Extend` trait的，所以可以用slice的`copy_from_slice`实现extend
 
-## 学习感想
+## 学习感想
+
+```rust
+
+struct Solution {}
+impl Solution {
+    pub fn reverse_str(s: String, k: i32) -> String {
+        let mut s: Vec<u8> = s.bytes().collect();
+        let mut i: usize = 0usize;
+        loop {
+            let start: usize = i * k as usize * 2usize;
+            if start >= s.len() { break }
+            i += 1usize;
+            let end: usize = std::cmp::min(start + k as usize, s.len());
+            s[start .. end].reverse()
+        }
+        String::from_utf8(s).unwrap()
+    }
+}
+```

notes/src/day9/lc28.md

@@ -90,4 +90,20 @@ impl Solution {
 ```
 ## 学习感想
 
-还得学习复习
+还得学习复习
+
+
+
+```rust
+struct Solution {}
+impl Solution {
+    pub fn str_str(haystack: String, needle: String) -> i32 {
+        if let Some(x) = haystack.find(&needle) {
+            x as i32
+        } else {
+            -1i32
+        }
+    }
+}
+
+```

notes/src/day9/lc459.md

@@ -20,6 +20,9 @@ abacabacabac
 
 abac
 0010
+
+abcabc
+000123
 ```
 
 ```rust
@@ -53,4 +56,44 @@ impl Solution {
 
 ## 学习感想
 
-什么时候该用KMP很懵
+什么时候该用KMP很懵
+
+next 数组 -- 前缀表 内容是什么？？next[i] 记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀
+
+前缀表是用来回退的，它记录了模式串P与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。
+
+记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
+
+
+记住例子
+
+```
+abcdabcd
+00001234
+```
+
+
+```rust
+impl Solution {
+    pub fn repeated_substring_pattern(s: String) -> bool {
+        let s: Vec<u8> = s.bytes().collect();
+        // next[i] -> max length of common prefix & suffix of string s[0..=i]
+        let mut next: Vec<usize> = vec![0usize; s.len()];
+        let mut left: usize = 0usize;   // the current max length of common pre/suf-fix
+        for right in 1usize .. next.len() { // calculate each next[right]
+            while left > 1usize && s[right] != s[left] {
+                left = next[left - 1usize];
+            }
+            if s[right] == s[left] {
+                left += 1usize;
+            }
+            next[right] = left;
+        }
+        let x: usize = s.len() - *next.last().unwrap();
+        match s.len() % x {
+            0 => true,
+            _ => false,
+        }
+    }
+}
+```