1406. 石子游戏 III

src/main.rs

@@ -1,33 +1,130 @@
-use std::collections::HashSet;
-
 mod arr;
 struct Solution {}
 impl Solution {
-    pub fn stone_game(piles: Vec<i32>) -> bool {
-        return true;
-        let mut mem = vec![vec![vec![]; piles.len()]; piles.len()];
-        // a do alice bob; b do alice bob
-        for j in 0..(piles.len() - 1) {
-            mem[j][j + 1] = if piles[j] > piles[j + 1] {
-                vec![piles[j], piles[j + 1]]
-            } else {
-                vec![piles[j + 1], piles[j]]
-            };
+    pub fn stone_game_iii(stone_value: Vec<i32>) -> String {
+        if stone_value.len() == 1 {
+            return get_ans(stone_value[0], 0);
         }
-        for i in 2..piles.len() {
-            for j in 0..(piles.len() - i) {
-                mem[j][j+i] = if mem[j][j + i - 1][1] - mem[j][j + i - 1][0] + piles[j + i]
-                    > mem[j + 1][j + i][1] - mem[j + 1][j + i][0] + piles[j]
+        if stone_value.len() == 2 {
+            if stone_value[0] + stone_value[1] > stone_value[0] {
+                return get_ans(stone_value[0] + stone_value[1], 0);
+            }
+            return get_ans(stone_value[0], stone_value[1]);
+        }
+        if stone_value.len() == 3 {
+            if stone_value[0] + stone_value[1] + stone_value[2] > 0
+                || stone_value[0] + stone_value[1] > stone_value[2]
             {
-                    vec![mem[j][j + i - 1][1] + piles[j + i], mem[j][j + i - 1][0]]
+                return get_ans(1, 0);
+            }
+            if stone_value[0] + stone_value[1] + stone_value[2] == 0
+                || stone_value[0] + stone_value[1] == stone_value[2]
+            {
+                return get_ans(0, 0);
+            }
+            if stone_value[2] > 0 {
+                return get_ans(stone_value[0], stone_value[1] + stone_value[2]);
+            }
+            return get_ans(stone_value[0] + stone_value[2], stone_value[1]);
+        }
+        fn get_ans(a: i32, b: i32) -> String {
+            if a == b {
+                "Tie".to_string()
+            } else if a > b {
+                "Alice".to_string()
             } else {
-                    vec![mem[j + 1][j + i][1] + piles[j], mem[j + 1][j + i][0]]
-                };
+                "Bob".to_string()
             }
         }
-        mem[0][piles.len() - 1][0] >mem[0][piles.len() - 1][1]
+
+        let mut dp = vec![vec![0; 3]; stone_value.len()];
+        for i in 0..3 {
+            if stone_value.len() > i {
+                dp[stone_value.len() - i - 1][0] = stone_value[stone_value.len() - i - 1];
+            }
+            if i >= 1 && stone_value.len() > i {
+                dp[stone_value.len() - i - 1][1] =
+                    stone_value[stone_value.len() - i - 1] + dp[stone_value.len() - i][0];
+            }
+            if i >= 2 && stone_value.len() > i {
+                dp[stone_value.len() - i - 1][2] =
+                    stone_value[stone_value.len() - i - 1] + dp[stone_value.len() - i][1];
+            }
+        }
+        dp[stone_value.len() - 1][1] = -100000000;
+        dp[stone_value.len() - 1][2] = -100000000;
+        dp[stone_value.len() - 2][2] = -100000000;
+        fn get_max(i: usize, dp: &Vec<Vec<i32>>) -> (usize, i32) {
+            if i >= dp.len() {
+                return (i, 0);
+            }
+            let (mut index, mut ans) = (i, -100000000);
+            for k in 0..3 {
+                if dp[i][k] > ans {
+                    ans = dp[i][k];
+                    index = i + k + 1;
+                }
+            }
+            (index, ans)
+        }
+        let (mut next_index, mut local_max) = get_max(stone_value.len() - 2, &dp);
+        if next_index == stone_value.len() - 1 {
+            dp[stone_value.len() - 3][0] += dp[stone_value.len() - 1][0];
+        }
+        let mut sum = 0;
+        for i in 0..3 {
+            sum += stone_value[stone_value.len() - 1 - i];
+        }
+        for i in (0..stone_value.len() - 3).rev() {
+            sum += stone_value[i];
+            for j in 0..3 {
+                for k in 0..=j {
+                    dp[i][j] += stone_value[i + k];
+                }
+                next_index = i + j + 1;
+                // (next_index, _) = get_max(next_index, &dp);
+                {
+                    let i = next_index;
+                    if i >= dp.len() {
+                        next_index = i;
+                    } else {
+                        let (mut index, mut ans) = (i, -100000000);
+                        for k in 0..3 {
+                            if dp[i][k] > ans {
+                                ans = dp[i][k];
+                                index = i + k + 1;
+                            }
+                        }
+                        next_index = index;
+                    }
+                }
+                {
+                    let i = next_index;
+                    if i >= dp.len() {
+                        local_max = 0;
+                    } else {
+                        let (mut index, mut ans) = (i, -100000000);
+                        for k in 0..3 {
+                            if dp[i][k] > ans {
+                                ans = dp[i][k];
+                                index = i + k + 1;
+                            }
+                        }
+                        local_max = ans;
+                    }
+                }
+                dp[i][j] += local_max;
+            }
+        }
+        if dp[0][1] > sum - dp[0][1] || dp[0][2] > sum - dp[0][2] || dp[0][0] > sum - dp[0][0] {
+            return get_ans(1, 0);
+        }
+        if dp[0][1] == sum - dp[0][1] || dp[0][2] == sum - dp[0][2] || dp[0][0] == sum - dp[0][0] {
+            return get_ans(0, 0);
+        }
+        get_ans(0, 1)
     }
 }
 fn main() {
-    println!("{:?}", Solution::stone_game(vec![1,5,1]));
+    println!("{:?}", Solution::stone_game_iii(vec![-11, -14, 7, -1, 14]));
 }