1140&753

Author: caibirdme

src/lib.rs

@@ -307,6 +307,7 @@ mod prob_732;
 mod prob_735;
 mod prob_739;
 mod prob_751;
+mod prob_753;
 mod prob_756;
 mod prob_765;
 mod prob_785;
@@ -333,6 +334,7 @@ mod prob_1059;
 mod prob_1092;
 mod prob_1109;
 mod prob_1135;
+mod prob_1140;
 mod prob_1157;
 mod prob_1167;
 mod prob_1228;

src/prob_1140.rs

@@ -0,0 +1,47 @@
+impl Solution {
+    pub fn stone_game_ii(piles: Vec<i32>) -> i32 {
+        let n = piles.len();
+        if n <= 2 {
+            return piles.iter().sum();
+        }
+        let mut sum = vec![0; n+1];
+        for i in 0..n {
+            sum[i+1] = sum[i]+piles[i];
+        }
+        let mut f = vec![vec![0; n]; n];
+        Self::dfs(0, 1, &sum, &mut f)
+    }
+    fn dfs(idx: usize, m: usize, sum: &Vec<i32>, f: &mut Vec<Vec<i32>>) -> i32 {
+        let n = f.len();
+        if idx >= n {
+            return 0;
+        }
+        if f[idx][m] > 0 {
+            return f[idx][m];
+        }
+        let mut ans = 0;
+        for i in idx..n.min(idx+2*m) {
+            let v = sum[n]-sum[idx] - Self::dfs(i+1, m.max(i-idx+1), sum, f);
+            ans = ans.max(v);
+        }
+        f[idx][m] = ans;
+        ans
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_stone_game_ii() {
+        let test_cases = vec![
+            (vec![2,7,9,4,4], 10),
+        ];
+        for (piles, expect) in test_cases {
+            assert_eq!(Solution::stone_game_ii(piles.clone()), expect, "piles: {:?}", piles);
+        }
+    }
+}

src/prob_753.rs

@@ -0,0 +1,51 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn crack_safe(n: i32, k: i32) -> String {
+        if n == 1 && k == 1 {
+            return "0".to_string();
+        }
+        let mut ans = vec![];
+        let mut hash = HashSet::new();
+        let mut m = 1;
+        while 2i32.pow(m) < k { m+=1;}
+        let w = 2i32.pow(m)-1;
+        let mut mask = 0;
+        for _ in 0..n-1 {
+            mask = (mask << m) | w;
+        }
+        Self::dfs(0, k, mask, m, &mut hash, &mut ans);
+        for _ in 0..n-1 {
+            ans.push(b'0');
+        }
+        unsafe {std::str::from_utf8_unchecked(&ans).to_string()}
+    }
+    fn dfs(node: i32, k: i32, mask: i32, m: u32, hash: &mut HashSet<i32>, ans: &mut Vec<u8>) {
+        for i in 0..k {
+            let w = (node << m) | i;
+            if !hash.contains(&w) {
+                hash.insert(w);
+                Self::dfs(w & mask, k, mask, m, hash, ans);
+                ans.push(b'0'+i as u8);
+            }
+        }
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_crack_safe() {
+        let test_cases = vec![
+            (1,2,"10"),
+            (2,2,"01100"),
+        ];
+        for (n,k,expect) in test_cases {
+            assert_eq!(Solution::crack_safe(n,k), expect, "n:{},k:{}",n,k);
+        }
+    }
+}