Solve #216

Author: aylei

src/lib.rs

@@ -183,3 +183,4 @@ mod n0212_word_search_ii;
 mod n0213_house_robber_ii;
 mod n0214_shortest_palindrome;
 mod n0215_kth_largest_element_in_an_array;
+mod n0216_combination_sum_iii;

src/n0040_combination_sum_ii.rs

@@ -2,19 +2,19 @@
  * [40] Combination Sum II
  *
  * Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.
- * 
+ *
  * Each number in candidates may only be used once in the combination.
- * 
+ *
  * Note:
- * 
- * 
+ *
+ *
  * 	All numbers (including target) will be positive integers.
  * 	The solution set must not contain duplicate combinations.
- * 
- * 
+ *
+ *
  * Example 1:
- * 
- * 
+ *
+ *
  * Input: candidates = [10,1,2,7,6,1,5], target = 8,
  * A solution set is:
  * [
@@ -23,19 +23,19 @@
  *   [2, 6],
  *   [1, 1, 6]
  * ]
- * 
- * 
+ *
+ *
  * Example 2:
- * 
- * 
+ *
+ *
  * Input: candidates = [2,5,2,1,2], target = 5,
  * A solution set is:
  * [
  *   [1,2,2],
  *   [5]
  * ]
- * 
- * 
+ *
+ *
  */
 pub struct Solution {}
 
@@ -45,25 +45,31 @@ impl Solution {
     pub fn combination_sum2(candidates: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
         let mut seq = candidates;
         let mut res = Vec::new();
-        seq.sort_unstable_by(|a, b| { b.cmp(a) });
+        seq.sort_unstable_by(|a, b| b.cmp(a));
         let mut vec = Vec::new();
         Solution::backtrack(&seq, target, vec, &mut res, 0);
         res
     }
 
-    fn backtrack(seq: &Vec<i32>, target: i32, mut curr: Vec<i32>, result: &mut Vec<Vec<i32>>, start_idx: usize) {
+    fn backtrack(
+        seq: &Vec<i32>,
+        target: i32,
+        mut curr: Vec<i32>,
+        result: &mut Vec<Vec<i32>>,
+        start_idx: usize,
+    ) {
         let mut i = start_idx;
         while i < seq.len() {
             let item = seq[i];
             if target - item < 0 {
                 i += 1;
-                continue
+                continue;
             }
             let mut new_vec = curr.clone();
             new_vec.push(item);
             if target == item {
                 result.push(new_vec);
-            }  else {
+            } else {
                 Solution::backtrack(seq, target - item, new_vec, result, i + 1);
             }
             // skip duplicate result
@@ -82,19 +88,17 @@ mod tests {
 
     #[test]
     fn test_40() {
-        assert_eq!(Solution::combination_sum2(vec![1,1,1,1,1,1,1], 7), vec![vec![1,1,1,1,1,1,1]]);
-        assert_eq!(Solution::combination_sum2(vec![10,1,2,7,6,1,5], 8),
-                   vec![
-                       vec![7,1],
-                       vec![6,2],
-                       vec![6,1,1],
-                       vec![5,2,1],
-                   ]);
-        assert_eq!(Solution::combination_sum2(vec![2,5,2,1,2], 5),
-                   vec![
-                       vec![5],
-                       vec![2,2,1],
-                   ]);
-
+        assert_eq!(
+            Solution::combination_sum2(vec![1, 1, 1, 1, 1, 1, 1], 7),
+            vec![vec![1, 1, 1, 1, 1, 1, 1]]
+        );
+        assert_eq!(
+            Solution::combination_sum2(vec![10, 1, 2, 7, 6, 1, 5], 8),
+            vec![vec![7, 1], vec![6, 2], vec![6, 1, 1], vec![5, 2, 1],]
+        );
+        assert_eq!(
+            Solution::combination_sum2(vec![2, 5, 2, 1, 2], 5),
+            vec![vec![5], vec![2, 2, 1],]
+        );
     }
 }

src/n0216_combination_sum_iii.rs

@@ -0,0 +1,77 @@
+/**
+ * [216] Combination Sum III
+ *
+ * <div>
+ * Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
+ *
+ * Note:
+ *
+ *
+ * 	All numbers will be positive integers.
+ * 	The solution set must not contain duplicate combinations.
+ *
+ *
+ * Example 1:
+ *
+ *
+ * Input: k = 3, n = 7
+ * Output: [[1,2,4]]
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: k = 3, n = 9
+ * Output: [[1,2,6], [1,3,5], [2,3,4]]
+ *
+ * </div>
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn combination_sum3(k: i32, n: i32) -> Vec<Vec<i32>> {
+        if k > 9 || k < 1 {
+            return vec![]
+        }
+        let max = (0..k).fold(0, |acc, t| { acc + 9 - t });
+        let min = (0..k).fold(0, |acc, t| { acc + t });
+        if n < min || n > max {
+            return vec![]
+        }
+        let mut res = Vec::new();
+        let mut seed = Vec::new();
+        Solution::helper(n, 0, k, seed, &mut res);
+        res
+    }
+
+    fn helper(distance: i32, prev: i32, remain: i32, mut curr: Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if remain == 0 {
+            if distance == 0 {
+                res.push(curr);
+            }
+            return
+        }
+        for i in (prev+1..=9) {
+            if distance - i < 0 {
+                break;
+            }
+            let mut new_vec = curr.clone();
+            new_vec.push(i);
+            Solution::helper(distance - i, i, remain - 1, new_vec, res);
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_216() {
+        assert_eq!(Solution::combination_sum3(3, 9), vec![vec![1,2,6],vec![1,3,5], vec![2,3,4]]);
+    }
+}