2019-11-25

Author: leopsidom

10.regular-expression-matching.rs

@@ -7,7 +7,15 @@
 // @lc code=start
 impl Solution {
     pub fn is_match(s: String, p: String) -> bool {
+        let sn = s.len();
+        let pn = p.len();
+
 
+        for i in 0..pn {
+            if i < pn - 1 {
+
+            }
+        }
     }
 }
 // @lc code=end

162.find-peak-element.rs

@@ -7,7 +7,13 @@
 // @lc code=start
 impl Solution {
     pub fn find_peak_element(nums: Vec<i32>) -> i32 {
-        
+        let mut lo = 0;
+        let mut hi = nums.len() - 1;
+
+        while lo < hi {
+            let mut mid = (lo + hi) / 2;
+            
+        }
     }
 }
 // @lc code=end

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

@@ -12,6 +12,7 @@ impl Solution {
         if digits.len() == 0 {
             return vec![];
         }
+        
         let mut ans = vec!["".to_string()];
         let map: HashMap<char, Vec<char>> = [
             ('2', vec!['a', 'b', 'c']),

190.reverse-bits.rs

@@ -5,9 +5,28 @@
  */
 
 // @lc code=start
+use std::cmp;
+
 impl Solution {
     pub fn rob(nums: Vec<i32>) -> i32 {
-        
+
+        let mut rob0_robi = nums[0];
+        let mut rob0_norobi = 0;
+        let mut norob0_robi = 0;
+        let mut norob0_norobi = 0;
+
+        let mut rob = nums[0];
+        let mut norob = 0;
+
+        let mut money = (nums[0], 0, 0, 0);
+
+        let N = nums.len();
+
+        for i in 1..N-1 {
+            let tmp = rob;
+            rob = norob + nums[i];
+            norob = cmp::max(rob, norob);
+        }
     }
 }
 // @lc code=end

213.house-robber-ii.rs

@@ -22,8 +22,53 @@
 //   }
 // }
 impl Solution {
-    pub fn is_palindrome(head: Option<Box<ListNode>>) -> bool {
+    pub fn is_palindrome(mut head: Option<Box<ListNode>>) -> bool {
+        if head.is_none() { return true; }
 
+        let mut N = 0;
+        let mut href = head.as_ref();
+
+        while let Some(node) = href {
+            href = node.next.as_ref();
+            N += 1;
+        }
+
+        let mut hmut = head.as_mut();
+        let mut mid = N / 2 - 1;
+
+        while mid > 0 {
+            hmut = hmut.unwrap().next.as_mut();
+            mid -= 1;
+        }
+
+        let mut prev = None;
+        let mut next = hmut.unwrap().next.take();
+
+        while let Some(mut next_inner) = next {
+            next = next_inner.next.take();
+            next_inner.next = prev.take();
+            prev = Some(next_inner);
+        }
+
+        let mut h1 = &head;
+        let mut h2 = &prev;
+
+        loop {
+            let (not_equal, should_break) = match (h1.as_ref(), h2.as_ref()) {
+                (Some(h1_inner), Some(h2_inner)) => {
+                    h1 = &h1_inner.next;
+                    h2 = &h2_inner.next;
+                    (h1_inner.val != h2_inner.val, false)
+                },
+                _ => (false, true)
+            };
+
+            if should_break { break; }
+            if not_equal { return false; }
+        }
+
+        return true;
+
     }
 }
 // @lc code=end

234.palindrome-linked-list.rs

@@ -0,0 +1,41 @@
+/*
+ * @lc app=leetcode id=290 lang=rust
+ *
+ * [290] Word Pattern
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_pattern(pattern: String, str: String) -> bool {
+        let mut forward = HashMap::new();
+        let mut backward = HashMap::new();
+
+        let words: Vec<&str> = str.split(' ').collect();
+        if pattern.len() != words.len() {
+            return false;
+        }
+        for (i, ch) in pattern.chars().enumerate() {
+            if forward.contains_key(&ch) {
+                if forward.get(&ch).unwrap() != words[i] {
+                    return false;
+                }
+            } else {
+                forward.insert(ch, words[i].to_owned());
+            }
+
+            if backward.contains_key(words[i]) {
+                if backward.get(words[i]).unwrap() != &ch {
+                    return false;
+                }
+            } else {
+                backward.insert(words[i].to_owned(), ch);
+            }
+        }
+
+        return true;
+    }
+}
+// @lc code=end
+

290.word-pattern.rs

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=31 lang=rust
+ *
+ * [31] Next Permutation
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn next_permutation(nums: &mut Vec<i32>) {
+        let N = nums.len();
+
+        let mut i = N - 1;
+        while i > 0 && nums[i] <= nums[i-1] {
+            i -= 1;
+        }
+        
+        if i == 0 { 
+            nums.sort();
+            return;
+        }
+
+        let left = i - 1;
+
+        let mut right = left + 1;
+
+        while right < N && nums[left] < nums[right] {
+            right += 1;
+        }
+
+        nums.swap(left, right - 1);
+
+        nums[left+1..].sort()
+    }
+}
+// @lc code=end
+

31.next-permutation.rs

@@ -5,9 +5,36 @@
  */
 
 // @lc code=start
+use std::collections::HashMap;
+
 impl Solution {
     pub fn palindrome_pairs(words: Vec<String>) -> Vec<Vec<i32>> {
-        
+        words.sort_by_key(|s| s.len());
+
+        let mut prefix = HashMap::new();
+        let mut suffix = HashMap::new();
+
+        for i in 0..words.len() {
+
+            for 
+            if suffix.contains_key(k: &Q)
+
+            let mut pindices = prefix.get_mut(&words[i]);
+            if let Some(pind) = pindices {
+                (*pind).push(i);
+            } else {
+                *pind = vec![];
+            }
+
+            let mut sindices = suffix.get_mut(&words[i].chars().rev().collect()::<String>);
+            if let Some(sind) = sindices {
+                (*sind).push(i);
+            } else {
+                *pind = vec![i];
+            }
+
+
+        }
     }
 }
 // @lc code=end

336.palindrome-pairs.rs

@@ -0,0 +1,78 @@
+/*
+ * @lc app=leetcode id=37 lang=rust
+ *
+ * [37] Sudoku Solver
+ */
+
+// @lc code=start
+use std::collections::HashSet;
+use std::char;
+
+impl Solution {
+    pub fn solve_sudoku(board: &mut Vec<Vec<char>>) {
+        let s: HashSet<char> = (1..10).map(|x| char::from_digit(x, 10).unwrap()).collect();
+
+        let mut row_choices = vec![s.clone(); 9];
+        let mut col_choices = vec![s.clone(); 9];
+        let mut sqr_choices = vec![s.clone(); 9];
+
+        for i in 0..9 {
+            for j in 0..9 {
+                if board[i][j] != '.' {
+                    row_choices[i].remove(&board[i][j]);
+                    col_choices[j].remove(&board[i][j]);
+                    sqr_choices[3 * (i / 3) + (j / 3)].remove(&board[i][j]);
+                }
+            }
+        }
+
+        // println!("row: {:?}", row_choices);
+        // println!("col: {:?}", col_choices);
+        // println!("sqr: {:?}", sqr_choices);
+
+        fn back_track(i: usize, j: usize, board: &mut Vec<Vec<char>>,
+            row_choices: &mut Vec<HashSet<char>>, 
+            col_choices: &mut Vec<HashSet<char>>, 
+            sqr_choices: &mut Vec<HashSet<char>>
+        ) -> bool {
+            if i == 9 { return true; }
+            else if board[i][j] == '.' {
+
+                for &ch in row_choices[i].clone().intersection(&col_choices[j].clone()) {
+                    let sqr_idx = 3 * (i / 3) + (j / 3);
+                    if sqr_choices[sqr_idx].clone().contains(&ch) {
+                        board[i][j] = ch;
+                        row_choices[i].remove(&ch);
+                        col_choices[j].remove(&ch);
+                        sqr_choices[sqr_idx].remove(&ch);
+                        let res = if j < 8 {
+                            back_track(i, j+1, board, row_choices, col_choices, sqr_choices)
+                        } else {
+                            back_track(i+1, 0, board, row_choices, col_choices, sqr_choices)
+                        };
+                        if res { return true; }
+                        else {
+                            board[i][j] = '.';
+                            row_choices[i].insert(ch);
+                            col_choices[j].insert(ch);
+                            sqr_choices[sqr_idx].insert(ch);
+                        }
+                    }
+                }
+                return false;
+            } else {
+                let res = if j < 8 {
+                    back_track(i, j+1, board, row_choices, col_choices, sqr_choices)
+                } else {
+                    back_track(i+1, 0, board, row_choices, col_choices, sqr_choices)
+                };
+
+                return res;
+            }
+        }
+
+        back_track(0, 0, board, &mut row_choices, &mut col_choices, &mut sqr_choices);
+    }
+}
+// @lc code=end
+

37.sudoku-solver.rs

@@ -0,0 +1,16 @@
+/*
+ * @lc app=leetcode id=39 lang=rust
+ *
+ * [39] Combination Sum
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn combination_sum(candidates: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
+        fn helper(candidates: &[i32], target: i32) -> Vec<Vec<i32>> {
+            
+        }
+    }
+}
+// @lc code=end
+