q46

Author: OhBonsai

src/backtrace/mod.rs

@@ -1 +1,2 @@
-mod q22;
+mod q22;
+mod q46;

src/backtrace/q22.rs

@@ -35,26 +35,6 @@ impl Solution {
             ret
         }
 
-
-        fn check_legal(s: &str) -> bool {
-            let mut clause = 0;
-            for v in s.chars() {
-                if v == '(' {
-                    clause += 1;
-                } else {
-                    clause -= 1;
-                }
-
-                if clause < 0 {
-                    return false;
-                }
-            };
-
-            println!("{:?}", clause==0);
-            clause == 0
-        }
-
-
         nest_function("(".to_owned(), 1, 0 ,n)
     }
 

src/backtrace/q46.rs

@@ -0,0 +1,76 @@
+
+
+
+struct Solution ();
+impl Solution {
+    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut ans: Vec<Vec<i32>> = vec![];
+        let mut arr: Vec<i32> = vec![];
+        Solution::backtrace(&nums, &mut arr, &mut ans);
+
+
+        let mut ans = Solution::backtrace2(&nums, vec![]);
+        return ans;
+    }
+
+
+    fn backtrace(nums: &Vec<i32>, arr: &mut Vec<i32>, ans: &mut Vec<Vec<i32>>) {
+
+
+
+
+        if arr.len() == nums.len() {
+            ans.push(arr.clone());
+        } else {
+
+            for i in nums {
+                if !arr.contains(i) {
+                    arr.push(*i);
+                    Solution::backtrace(nums, arr, ans);
+                    arr.pop();
+                }
+            }
+
+
+        }
+    }
+
+    fn backtrace2(nums: &Vec<i32>, arr: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result = vec![];
+
+        if arr.len() == nums.len() {
+            return vec![arr];
+        }
+
+        for x in nums {
+            if !arr.contains(x) {
+
+                let mut new_arr = arr.clone();
+                new_arr.push(*x);
+                result.append(&mut Solution::backtrace2(
+                    nums,
+                    new_arr
+                ));
+            }
+        }
+
+        result
+
+    }
+
+
+}
+
+
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]fn test_ok() {
+
+        println!("{:?}", Solution::permute(vec![1,2,3]))
+
+    }
+}

src/dp/mod.rs

@@ -1,36 +1,2 @@
 mod q121;
 
-
-struct Solution ();
-impl Solution {
-    pub fn max_profit(prices: Vec<i32>) -> i32 {
-
-        let mut max = 0;
-        let mut min_item  =  prices[0];
-
-
-        for x in prices.into_iter().skip(1) {
-            min_item = min_item.min(x);
-            max = max.max(x - min_item);
-
-
-        }
-
-
-        max
-    }
-}
-
-
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test] fn is_ok() {
-
-        assert_eq!(Solution::max_profit(vec![7,1,5,3,6,4]), 5)
-
-
-    }
-}

src/dp/q121.rs

@@ -0,0 +1,34 @@
+
+struct Solution ();
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+
+        let mut max = 0;
+        let mut min_item  =  prices[0];
+
+
+        for x in prices.into_iter().skip(1) {
+            min_item = min_item.min(x);
+            max = max.max(x - min_item);
+
+
+        }
+
+
+        max
+    }
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test] fn is_ok() {
+
+        assert_eq!(Solution::max_profit(vec![7,1,5,3,6,4]), 5)
+
+
+    }
+}

src/linklist/mod.rs

@@ -0,0 +1,42 @@
+
+#[derive(Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>
+}
+
+
+impl ListNode {
+    fn new(val: i32) -> ListNode {
+        ListNode {
+            val,
+            next: None
+        }
+    }
+}
+
+
+
+
+#[macro_export]
+macro_rules! linklist {
+    () => {
+        None
+    };
+    ($($e:expr), *) => {
+        {
+            let mut head = Box::new(ListNode::new(0));
+            let mut ref_head = &mut head;
+
+            $(
+            ref_head.next = Some(Box::new(ListNode::new($e)));
+            ref_head = ref_head.next.as_mut().unwrap();
+            )*
+
+            let _ = ref_head; // 避免 `unused_assignments`
+            head.next
+        }
+    };
+}
+
+mod q203;

src/linklist/q203.rs

@@ -0,0 +1,42 @@
+use super::*;
+
+struct Solution();
+impl Solution {
+    pub fn remove_elements(head: Option<Box<ListNode>>, val: i32) -> Option<Box<ListNode>> {
+        let mut head = Some(Box::new(ListNode{
+            val: val-1,
+            next: head
+        }));
+
+        let mut node = &mut head;
+
+        'outer:
+        while let Some(ptr) = node {
+            while let Some(ptr2) = &mut ptr.next {
+                if ptr2.val == val {
+                    ptr.next = ptr2.next.take();
+                } else {
+                    node = &mut ptr.next;
+                    continue 'outer;
+                }
+            }
+            break;
+        }
+
+        head.unwrap().next
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test] fn common_test() {
+        let mut v = linklist!(1,2,3, 3);
+        println!("{:?}", Solution::remove_elements(v, 3))
+
+    }
+
+
+}