add 3;17;32;62;63;64

Author: leopsidom

10.regular-expression-matching.rs

@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=10 lang=rust
+ *
+ * [10] Regular Expression Matching
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn is_match(s: String, p: String) -> bool {
+        
+    }
+}
+// @lc code=end
+

17.letter-combinations-of-a-phone-number.rs

@@ -0,0 +1,43 @@
+/*
+ * @lc app=leetcode id=17 lang=rust
+ *
+ * [17] Letter Combinations of a Phone Number
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn letter_combinations(digits: String) -> Vec<String> {
+        if digits.len() == 0 {
+            return vec![];
+        }
+        let mut ans = vec!["".to_string()];
+        let map: HashMap<char, Vec<char>> = [
+            ('2', vec!['a', 'b', 'c']),
+            ('3', vec!['d', 'e', 'f']),
+            ('4', vec!['g', 'h', 'i']),
+            ('5', vec!['j', 'k', 'l']),
+            ('6', vec!['m', 'n', 'o']),
+            ('7', vec!['p', 'q', 'r', 's']),
+            ('8', vec!['t', 'u', 'v']),
+            ('9', vec!['w', 'x', 'y', 'z'])
+        ].iter().cloned().collect();
+
+        for d in digits.chars() {
+            let mut tmp = vec![];
+            if let Some(v) = map.get(&d) {
+                for s in &ans {
+                    for ch in v {
+                        tmp.push(s.clone() + &ch.to_string());
+                    }
+                }
+            }
+            ans = tmp;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

3.longest-substring-without-repeating-characters.rs

@@ -0,0 +1,30 @@
+/*
+ * @lc app=leetcode id=3 lang=rust
+ *
+ * [3] Longest Substring Without Repeating Characters
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+use std::cmp;
+
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        let mut map = HashMap::new();
+        let chars: Vec<char> = s.chars().collect();
+        let mut start = -1;
+        let mut ans = 0;
+
+        for i in 0..s.len() {
+            if let Some(v) = map.get_mut(&chars[i]) {
+                start = cmp::max(start, *v);
+            }
+            ans = cmp::max(ans, i as i32 - start);
+            map.insert(&chars[i], i as i32);
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

32.longest-valid-parentheses.rs

@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=32 lang=rust
+ *
+ * [32] Longest Valid Parentheses
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn longest_valid_parentheses(s: String) -> i32 {
+        
+    }
+}
+// @lc code=end
+

62.unique-paths.rs

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=62 lang=rust
+ *
+ * [62] Unique Paths
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn unique_paths(m: i32, n: i32) -> i32 {
+        if m <= 0 || n <= 0 {
+            return 0;
+        }
+
+        let mut dp = vec![vec![1; n as usize]; m as usize];
+
+        for i in (0..m as usize).rev() {
+            for j in (0..n as usize).rev() {
+                if i == (m - 1) as usize {
+                    if j < (n - 1) as usize {
+                        dp[i][j] = dp[i][j+1];
+                    }
+                } else {
+                    if j == (n - 1) as usize {
+                        dp[i][j] = dp[i+1][j];
+                    } else {
+                        dp[i][j] = dp[i+1][j] + dp[i][j+1];
+                    }
+                }
+            }
+        }
+
+        dp[0][0]
+    }
+}
+// @lc code=end
+

63.unique-paths-ii.rs

@@ -0,0 +1,57 @@
+/*
+ * @lc app=leetcode id=63 lang=rust
+ *
+ * [63] Unique Paths II
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
+        let R = obstacle_grid.len();
+        if R == 0 { return 0; }
+
+        let C = obstacle_grid[0].len();
+        if C == 0 { return 0; }
+
+
+        let mut dp = vec![vec![1; C as usize]; R as usize];
+
+        for i in (0..R as usize).rev() {
+            for j in (0..C as usize).rev() {
+                if i == (R - 1) as usize {
+                    if j < (C - 1) as usize {
+                        if obstacle_grid[i][j] == 1 {
+                            dp[i][j] = 0;
+                        } else {
+                            dp[i][j] = dp[i][j+1];
+                        }
+                    } else {
+                        if obstacle_grid[i][j] == 1 {
+                            dp[i][j] = 0;
+                        } else {
+                            dp[i][j] = 1;
+                        }
+                    };
+                } else {
+                    if j == (C - 1) as usize {
+                        if obstacle_grid[i][j] == 1 {
+                            dp[i][j] = 0;
+                        } else {
+                            dp[i][j] = dp[i+1][j];
+                        }
+                    } else {
+                        if obstacle_grid[i][j] == 1 {
+                            dp[i][j] = 0;
+                        } else {
+                            dp[i][j] = dp[i+1][j] + dp[i][j+1];
+                        }
+                    }
+                }
+            }
+        }
+
+        dp[0][0]
+    }
+}
+// @lc code=end
+

64.minimum-path-sum.rs

@@ -0,0 +1,43 @@
+/*
+ * @lc app=leetcode id=64 lang=rust
+ *
+ * [64] Minimum Path Sum
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+        let R = grid.len();
+        if R == 0 { return 0; }
+
+        let C = grid[0].len();
+        if C == 0 { return 0; }
+
+
+        let mut dp = vec![vec![1; C as usize]; R as usize];
+
+        for i in (0..R as usize).rev() {
+            for j in (0..C as usize).rev() {
+                if i == (R - 1) as usize {
+                    if j < (C - 1) as usize {
+                        dp[i][j] = dp[i][j+1] + grid[i][j];
+                    } else {
+                        dp[i][j] = grid[i][j];
+                    };
+                } else {
+                    if j == (C - 1) as usize {
+                        dp[i][j] = dp[i+1][j] + grid[i][j];
+                    } else {
+                        dp[i][j] = cmp::min(dp[i+1][j], dp[i][j+1]) + grid[i][j];
+                    }
+                }
+            }
+        }
+
+        dp[0][0]
+    }
+}
+// @lc code=end
+