commit by crawler.py @netcan at 2019-03-16 00:33

Author: netcan

README.md

@@ -4,7 +4,7 @@
 
 本项目由`crawler.py`生成，代码自动爬取Leetcode-cn.com网站获取个人提交记录。使用方法：登陆Leetcode后记录cookie，设置环境变量`LEETCODE_COOKIE`，然后执行本脚本就能抓取指定语言的个人提交记录。
 
-目前已解决的题目（56 个，其中简单23 个，中等22 个， 困难11 个）：
+目前已解决的题目（63 个，其中简单24 个，中等25 个， 困难14 个）：
 - [17. Letter Combinations of a Phone Number :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0017.%20Letter%20Combinations%20of%20a%20Phone%20Number)
 - [37. Sudoku Solver :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0037.%20Sudoku%20Solver)
 - [50. Pow(x, n) :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0050.%20Pow(x,%20n))
@@ -31,9 +31,11 @@
 - [223. Rectangle Area :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0223.%20Rectangle%20Area)
 - [257. Binary Tree Paths :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0257.%20Binary%20Tree%20Paths)
 - [295. Find Median from Data Stream :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0295.%20Find%20Median%20from%20Data%20Stream)
+- [312. Burst Balloons :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0312.%20Burst%20Balloons)
 - [343. Integer Break :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0343.%20Integer%20Break)
 - [349. Intersection of Two Arrays :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0349.%20Intersection%20of%20Two%20Arrays)
 - [363. Max Sum of Rectangle No Larger Than K :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0363.%20Max%20Sum%20of%20Rectangle%20No%20Larger%20Than%20K)
+- [392. Is Subsequence :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0392.%20Is%20Subsequence)
 - [405. Convert a Number to Hexadecimal :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0405.%20Convert%20a%20Number%20to%20Hexadecimal)
 - [437. Path Sum III :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0437.%20Path%20Sum%20III)
 - [443. String Compression :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0443.%20String%20Compression)
@@ -44,19 +46,24 @@
 - [563. Binary Tree Tilt :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0563.%20Binary%20Tree%20Tilt)
 - [630. Course Schedule III :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0630.%20Course%20Schedule%20III)
 - [671. Second Minimum Node In a Binary Tree :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0671.%20Second%20Minimum%20Node%20In%20a%20Binary%20Tree)
+- [674. Longest Continuous Increasing Subsequence :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0674.%20Longest%20Continuous%20Increasing%20Subsequence)
 - [679. 24 Game :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0679.%2024%20Game)
 - [687. Longest Univalue Path :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0687.%20Longest%20Univalue%20Path)
 - [695. Max Area of Island :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0695.%20Max%20Area%20of%20Island)
 - [728. Self Dividing Numbers :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0728.%20Self%20Dividing%20Numbers)
 - [745. Find Smallest Letter Greater Than Target :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0745.%20Find%20Smallest%20Letter%20Greater%20Than%20Target)
+- [808. Number of Matching Subsequences :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0808.%20Number%20of%20Matching%20Subsequences)
 - [866. Rectangle Overlap :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0866.%20Rectangle%20Overlap)
 - [891. Score After Flipping Matrix :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0891.%20Score%20After%20Flipping%20Matrix)
 - [908. Middle of the Linked List :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0908.%20Middle%20of%20the%20Linked%20List)
 - [909. Stone Game :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0909.%20Stone%20Game)
 - [958. Sort Array By Parity II :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0958.%20Sort%20Array%20By%20Parity%20II)
 - [972. Knight Dialer :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n0972.%20Knight%20Dialer)
 - [1019. Squares of a Sorted Array :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1019.%20Squares%20of%20a%20Sorted%20Array)
+- [1024. Triples with Bitwise AND Equal To Zero :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1024.%20Triples%20with%20Bitwise%20AND%20Equal%20To%20Zero)
+- [1033. Broken Calculator :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1033.%20Broken%20Calculator)
 - [1037. Minimum Number of K Consecutive Bit Flips :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1037.%20Minimum%20Number%20of%20K%20Consecutive%20Bit%20Flips)
+- [1042. Minimum Cost to Merge Stones :star::star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1042.%20Minimum%20Cost%20to%20Merge%20Stones)
 - [1047. Maximize Sum Of Array After K Negations :star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1047.%20Maximize%20Sum%20Of%20Array%20After%20K%20Negations)
 - [1048. Clumsy Factorial :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1048.%20Clumsy%20Factorial)
 - [1049. Minimum Domino Rotations For Equal Row :star::star:](https://github.com/netcan/Leetcode-Rust/tree/master/n1049.%20Minimum%20Domino%20Rotations%20For%20Equal%20Row)

n0312. Burst Balloons/README.md

@@ -0,0 +1,42 @@
+
+### Burst Balloons :star::star::star:
+- 题目地址/Problem Url: [https://leetcode-cn.com/problems/burst-balloons](https://leetcode-cn.com/problems/burst-balloons)
+- 执行时间/Runtime: 4 ms 
+- 内存消耗/Mem Usage: 2.6 MB
+- 通过日期/Accept Datetime: 2019-03-16 00:31
+
+```rust
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::iter;
+impl Solution {
+    pub fn max_coins(mut nums: Vec<i32>) -> i32 {
+        // dp[i][j]: 从i到j获得的最大硬币数量
+        // coin[k]: 戳爆第k个气球得分
+        // dp[i][j] = max(dp[i][j], dp[i][k - 1] + coin[i-1]*coin[k]*coin[j+1] + dp[k+1][j])
+        let n = nums.len();
+        if n == 0 { return 0; }
+        else if n == 1 { return nums[0]; }
+
+        let mut coin = vec![1]; coin.append(&mut nums); coin.push(1);
+
+        let mut dp:Vec<Vec<i32>> =
+            iter::repeat(vec![0; n + 1]).take(n + 1).collect();
+        for i in 1..=n { dp[i][i] = coin[i-1] * coin[i] * coin[i+1]; }
+
+        for step in 1..n {
+            for i in 1..=n-step {
+                let j = i + step;
+                for k in i..=j {
+                    let left = if k - 1 < i { 0 } else { dp[i][k - 1] };
+                    let right = if k + 1 > j { 0 } else { dp[k + 1][j] };
+                    dp[i][j] = dp[i][j].max(left + right + coin[i-1] * coin[k] * coin[j+1]);
+                }
+            }
+        }
+        dp[1][n]
+    }
+}
+
+```

n0312. Burst Balloons/main.rs

@@ -0,0 +1,32 @@
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::iter;
+impl Solution {
+    pub fn max_coins(mut nums: Vec<i32>) -> i32 {
+        // dp[i][j]: 从i到j获得的最大硬币数量
+        // coin[k]: 戳爆第k个气球得分
+        // dp[i][j] = max(dp[i][j], dp[i][k - 1] + coin[i-1]*coin[k]*coin[j+1] + dp[k+1][j])
+        let n = nums.len();
+        if n == 0 { return 0; }
+        else if n == 1 { return nums[0]; }
+
+        let mut coin = vec![1]; coin.append(&mut nums); coin.push(1);
+
+        let mut dp:Vec<Vec<i32>> =
+            iter::repeat(vec![0; n + 1]).take(n + 1).collect();
+        for i in 1..=n { dp[i][i] = coin[i-1] * coin[i] * coin[i+1]; }
+
+        for step in 1..n {
+            for i in 1..=n-step {
+                let j = i + step;
+                for k in i..=j {
+                    let left = if k - 1 < i { 0 } else { dp[i][k - 1] };
+                    let right = if k + 1 > j { 0 } else { dp[k + 1][j] };
+                    dp[i][j] = dp[i][j].max(left + right + coin[i-1] * coin[k] * coin[j+1]);
+                }
+            }
+        }
+        dp[1][n]
+    }
+}

n0392. Is Subsequence/README.md

@@ -0,0 +1,29 @@
+
+### Is Subsequence :star::star:
+- 题目地址/Problem Url: [https://leetcode-cn.com/problems/is-subsequence](https://leetcode-cn.com/problems/is-subsequence)
+- 执行时间/Runtime: 4 ms 
+- 内存消耗/Mem Usage: 4.6 MB
+- 通过日期/Accept Datetime: 2019-03-15 10:02
+
+```rust
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+impl Solution {
+    pub fn is_subsequence(s: String, t: String) -> bool {
+        if s.len() == 0 { return true; }
+        let (s, t) = (s.into_bytes(), t.into_bytes());
+        let (mut i, mut j) = (0, 0);
+        while i < s.len() && j < t.len() {
+            if s[i] == t[j] {
+                i += 1;
+                if i == s.len() { return true; }
+            }
+            j += 1;
+        }
+        false
+    }
+}
+
+
+```

n0392. Is Subsequence/main.rs

@@ -0,0 +1,19 @@
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+impl Solution {
+    pub fn is_subsequence(s: String, t: String) -> bool {
+        if s.len() == 0 { return true; }
+        let (s, t) = (s.into_bytes(), t.into_bytes());
+        let (mut i, mut j) = (0, 0);
+        while i < s.len() && j < t.len() {
+            if s[i] == t[j] {
+                i += 1;
+                if i == s.len() { return true; }
+            }
+            j += 1;
+        }
+        false
+    }
+}
+

n0674. Longest Continuous Increasing Subsequence/README.md

@@ -0,0 +1,27 @@
+
+### Longest Continuous Increasing Subsequence :star:
+- 题目地址/Problem Url: [https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence](https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence)
+- 执行时间/Runtime: 0 ms 
+- 内存消耗/Mem Usage: 2.7 MB
+- 通过日期/Accept Datetime: 2019-03-15 12:09
+
+```rust
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::cmp::max;
+impl Solution {
+    pub fn find_length_of_lcis(nums: Vec<i32>) -> i32 {
+        if nums.len() == 0 { return 0; }
+        let (mut length, mut max_length) = (1, 1);
+        nums.iter().skip(1).fold(nums[0], |a, b| {
+            if a < *b { length += 1; max_length = max(max_length, length) }
+            else { length = 1; }
+            *b
+        });
+        max_length
+    }
+}
+
+
+```

n0674. Longest Continuous Increasing Subsequence/main.rs

@@ -0,0 +1,17 @@
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::cmp::max;
+impl Solution {
+    pub fn find_length_of_lcis(nums: Vec<i32>) -> i32 {
+        if nums.len() == 0 { return 0; }
+        let (mut length, mut max_length) = (1, 1);
+        nums.iter().skip(1).fold(nums[0], |a, b| {
+            if a < *b { length += 1; max_length = max(max_length, length) }
+            else { length = 1; }
+            *b
+        });
+        max_length
+    }
+}
+

n0808. Number of Matching Subsequences/README.md

@@ -0,0 +1,50 @@
+
+### Number of Matching Subsequences :star::star:
+- 题目地址/Problem Url: [https://leetcode-cn.com/problems/number-of-matching-subsequences](https://leetcode-cn.com/problems/number-of-matching-subsequences)
+- 执行时间/Runtime: 164 ms 
+- 内存消耗/Mem Usage: 4.7 MB
+- 通过日期/Accept Datetime: 2019-03-15 11:17
+
+```rust
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn num_matching_subseq(s: String, words: Vec<String>) -> i32 {
+        let s = s.into_bytes();
+        let words: Vec<Vec<u8>> = words.into_iter().map(|w| { w.into_bytes() }).collect();
+
+        // 预处理s
+        let mut s_char_pos = HashMap::new();
+        for (pos, c) in s.iter().enumerate() {
+            let c_pos_list = s_char_pos.entry(c).or_insert(Vec::new());
+            c_pos_list.push(pos);
+        }
+
+        let mut cnt = 0;
+        for word in &words {
+            let mut w_pos = 0;
+            let mut is_seq = true;
+            for w in word {
+                if !s_char_pos.contains_key(&w) {
+                    is_seq = false; break;
+                }
+                let pos_list = s_char_pos.get(&w).unwrap();
+                match pos_list.binary_search(&w_pos) {
+                    Ok(idx) => { w_pos = pos_list[idx] + 1; },
+                    Err(idx) => {
+                        if(idx >= 0 && idx < pos_list.len()) { w_pos = pos_list[idx] + 1; }
+                        else { is_seq = false; break; }
+                    }
+                }
+            }
+            if is_seq { cnt += 1; }
+        }
+
+        cnt
+    }
+}
+
+
+```

n0808. Number of Matching Subsequences/main.rs

@@ -0,0 +1,40 @@
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn num_matching_subseq(s: String, words: Vec<String>) -> i32 {
+        let s = s.into_bytes();
+        let words: Vec<Vec<u8>> = words.into_iter().map(|w| { w.into_bytes() }).collect();
+
+        // 预处理s
+        let mut s_char_pos = HashMap::new();
+        for (pos, c) in s.iter().enumerate() {
+            let c_pos_list = s_char_pos.entry(c).or_insert(Vec::new());
+            c_pos_list.push(pos);
+        }
+
+        let mut cnt = 0;
+        for word in &words {
+            let mut w_pos = 0;
+            let mut is_seq = true;
+            for w in word {
+                if !s_char_pos.contains_key(&w) {
+                    is_seq = false; break;
+                }
+                let pos_list = s_char_pos.get(&w).unwrap();
+                match pos_list.binary_search(&w_pos) {
+                    Ok(idx) => { w_pos = pos_list[idx] + 1; },
+                    Err(idx) => {
+                        if(idx >= 0 && idx < pos_list.len()) { w_pos = pos_list[idx] + 1; }
+                        else { is_seq = false; break; }
+                    }
+                }
+            }
+            if is_seq { cnt += 1; }
+        }
+
+        cnt
+    }
+}
+

n1024. Triples with Bitwise AND Equal To Zero/README.md

@@ -0,0 +1,35 @@
+
+### Triples with Bitwise AND Equal To Zero :star::star::star:
+- 题目地址/Problem Url: [https://leetcode-cn.com/problems/triples-with-bitwise-and-equal-to-zero](https://leetcode-cn.com/problems/triples-with-bitwise-and-equal-to-zero)
+- 执行时间/Runtime: 144 ms 
+- 内存消耗/Mem Usage: 3 MB
+- 通过日期/Accept Datetime: 2019-03-15 17:52
+
+```rust
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+impl Solution {
+    pub fn count_triplets(nums: Vec<i32>) -> i32 {
+        let max_num = nums.iter().skip(1).fold(nums[0], |a, b| { a.max(*b) } ) as usize;
+        // dp[n] 为A[i] & A[j] = n的个数
+        let mut dp = vec![0; max_num + 1];
+        for ai in &nums {
+            for aj in &nums { dp[(ai & aj) as usize] += 1; }
+        }
+
+        let mut ans = 0;
+        for a in &nums {
+            for b in (0..=max_num as i32) {
+                if a & b == 0 {
+                    ans += dp[b as usize];
+                }
+            }
+        }
+
+        ans
+    }
+}
+
+
+```

n1024. Triples with Bitwise AND Equal To Zero/main.rs

@@ -0,0 +1,25 @@
+// Author: Netcan @ https://github.com/netcan/Leetcode-Rust
+// Zhihu: https://www.zhihu.com/people/netcan
+
+impl Solution {
+    pub fn count_triplets(nums: Vec<i32>) -> i32 {
+        let max_num = nums.iter().skip(1).fold(nums[0], |a, b| { a.max(*b) } ) as usize;
+        // dp[n] 为A[i] & A[j] = n的个数
+        let mut dp = vec![0; max_num + 1];
+        for ai in &nums {
+            for aj in &nums { dp[(ai & aj) as usize] += 1; }
+        }
+
+        let mut ans = 0;
+        for a in &nums {
+            for b in (0..=max_num as i32) {
+                if a & b == 0 {
+                    ans += dp[b as usize];
+                }
+            }
+        }
+
+        ans
+    }
+}
+