match_192

Author: caibirdme

src/lib.rs

@@ -436,6 +436,7 @@ mod kmp;
 mod trans_tree;
 mod night_match_27;
 mod match_191;
+mod match_192;
 #[cfg(test)]
 mod tests {
     #[test]

src/match_192/mod.rs

@@ -0,0 +1,3 @@
+mod prob_5429;
+mod prob_5430;
+mod prob_5431;

src/match_192/prob_5429.rs

@@ -0,0 +1,47 @@
+impl Solution {
+    pub fn get_strongest(mut arr: Vec<i32>, k: i32) -> Vec<i32> {
+        arr.sort();
+        let n = arr.len();
+        let m = arr[(n-1)/2];
+        arr.sort_by(|&a,&b| {
+            let absa = Self::abs(a-m);
+            let absb = Self::abs(b-m);
+            if absa == absb {
+                a.cmp(&b)
+            } else {
+                absa.cmp(&absb)
+            }
+        });
+        let mut ans = vec![];
+        for i in (n-(k as usize)..n).rev() {
+            ans.push(arr[i]);
+        }
+        ans
+    }
+    fn abs(x: i32) -> i32 {
+        if x < 0 {
+            -x
+        } else {
+            x
+        }
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_get_strongest() {
+        let test_cases = vec![
+            (vec![1,2,3,4,5], 2, vec![5,1]),
+            (vec![1,1,3,5,5], 2, vec![5,5]),
+            (vec![6,7,11,7,6,8], 5, vec![11,8,6,6,7]),
+        ];
+        for (nums, k, expect) in test_cases {
+            assert_eq!(Solution::get_strongest(nums.clone(), k), expect, "nums:{:?} k: {}", nums, k);
+        }
+    }
+}

src/match_192/prob_5430.rs

@@ -0,0 +1,36 @@
+struct BrowserHistory {
+    q: Vec<String>,
+    idx: usize,
+}
+
+impl BrowserHistory {
+
+    fn new(homepage: String) -> Self {
+        Self{
+            q: vec![homepage],
+            idx: 0,
+        }
+    }
+
+    fn visit(&mut self, url: String) {
+        self.q.truncate(self.idx+1);
+        self.q.push(url);
+        self.idx += 1;
+    }
+
+    fn back(&mut self, steps: i32) -> String {
+        let d = self.idx.min(steps as usize);
+        self.idx -= d;
+        return self.q[self.idx].clone();
+    }
+
+    fn forward(&mut self, steps: i32) -> String {
+        let d = self.idx+steps as usize;
+        if d >= self.q.len() {
+            self.idx = self.q.len()-1;
+        } else {
+            self.idx = d;
+        }
+        return self.q[self.idx].clone();
+    }
+}

src/match_192/prob_5431.rs

@@ -0,0 +1,134 @@
+impl Solution {
+    pub fn min_cost(houses: Vec<i32>, cost: Vec<Vec<i32>>, m: i32, n: i32, target: i32) -> i32 {
+        let m = m as usize;
+        let n = n as usize;
+        let target = target as usize;
+        let mut f = vec![vec![vec![std::i32::MAX; n+1]; target+1]; m+1];
+        // 初始化
+        if houses[0] > 0 {
+            f[0][1][houses[0] as usize] = 0;
+        } else {
+            for c in 1..=n {
+                f[0][1][c] = cost[0][c-1];
+            }
+        }
+        // 枚举房子
+        for i in 1..m {
+            // 枚举街区
+            for j in 1..=target {
+                // 如果当前房子已经着色
+                if houses[i] > 0 {
+                    let hc = houses[i] as usize;
+                    // 和前面一样
+                    if f[i-1][j][hc] != std::i32::MAX {
+                        f[i][j][hc] = f[i-1][j][hc];
+                    }
+                    // 新街区
+                    for k in 1..=n {
+                        if k != hc && f[i-1][j-1][k] != std::i32::MAX {
+                            f[i][j][hc] = f[i][j][hc].min(f[i-1][j-1][k]);
+                        }
+                    }
+                    continue;
+                }
+                // 当前房子没颜色，枚举一个
+                for c in 1..=n {
+                    if f[i-1][j][c] != std::i32::MAX {
+                        f[i][j][c] = f[i-1][j][c] + cost[i][c-1];
+                    }
+                    for k in 1..=n {
+                        if k != c && f[i-1][j-1][k] != std::i32::MAX {
+                            f[i][j][c] = f[i][j][c].min(f[i-1][j-1][k] + cost[i][c-1]);
+                        }
+                    }
+                }
+            }
+        }
+        let mut ans = std::i32::MAX;
+        for c in 1..=n {
+            ans = ans.min(f[m-1][target][c]);
+        }
+        if ans == std::i32::MAX {
+            -1
+        } else {
+            ans
+        }
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_min_cost() {
+        let test_cases = vec![
+            (
+                vec![0,0,0,3],
+                vec![
+                    vec![2,2,5],
+                    vec![1,5,5],
+                    vec![5,1,2],
+                    vec![5,2,5],
+                ],
+                4,3,3,
+                4
+            ),
+            (
+                vec![3,1,2,3],
+                vec![
+                    vec![1,1,1],
+                    vec![1,1,1],
+                    vec![1,1,1],
+                    vec![1,1,1],
+                    vec![1,1,1],
+                ],
+                4,3,3,
+                -1
+            ),
+            (
+                vec![0,0,0,0,0],
+                vec![
+                    vec![1,10],
+                    vec![10,1],
+                    vec![1,10],
+                    vec![10,1],
+                    vec![1,10],
+                ],
+                5,2,5,
+                5
+            ),
+
+            (
+                vec![0,2,1,2,0],
+                vec![
+                    vec![1,10],
+                    vec![10,1],
+                    vec![10,1],
+                    vec![1,10],
+                    vec![5,1],
+                ],
+                5,2,3,
+                11
+            ),
+            (
+                vec![0,0,0,0,0],
+                vec![
+                    vec![1,10],
+                    vec![10,1],
+                    vec![10,1],
+                    vec![1,10],
+                    vec![5,1],
+                ],
+                5,2,3,
+                9
+            ),
+
+        ];
+        for(houses, cost, m,n,target, expect) in test_cases {
+            assert_eq!(Solution::min_cost(houses.clone(), cost.clone(), m,n,target), expect, "houses:{:?}, cost: {:?}, m:{},n:{},target:{}",houses,cost,m,n,target);
+        }
+    }
+}