2463. 最小移动总距离

src/main.rs

@@ -1,21 +1,70 @@
+use crate::arr::make_matrix;
+
 mod arr;
 
 struct Solution {}
 impl Solution {
-    pub fn get_min_distance(nums: Vec<i32>, target: i32, start: i32) -> i32 {
+    pub fn minimum_total_distance(robot: Vec<i32>, factory: Vec<Vec<i32>>) -> i64 {
-        let mut ans = 1000000;
+        let mut robot = robot.into_iter().map(|x| x as i64).collect::<Vec<i64>>();
-        for i in 0..nums.len() {
+        let mut factory = factory.into_iter().map(|x| x.into_iter().map(|y| y as i64).collect::<Vec<i64>>()).collect::<Vec<Vec<i64>>>();
-            if nums[i] == target {
+        robot.sort_unstable();
-                ans = ans.min((i as i32 - start).abs_diff(0) as i32);
+        factory.sort_unstable_by(|a, b| a[0].cmp(&b[0]));
+        factory = factory.into_iter().filter(|f| f[1] > 0).collect();
+        let mut dp = vec![vec![0; robot.len() + 1]; factory.len()];
+        // dp[0][0] = robot[0].abs_diff(factory[0][0]) as i64;
+        for i in 1..=factory[0][1] as usize {
+            dp[0][i] = robot[i - 1].abs_diff(factory[0][0]) as i64 + dp[0][i - 1];
+        }
+        for i in factory[0][1] as usize + 1..=robot.len() {
+            dp[0][i] = 1e11 as i64;
+        }
+        for i in 1..factory.len() {
+            let (f_pos, f_cap) = (factory[i][0], factory[i][1] as usize);
+            for j in 1..=f_cap {
+                dp[i][j] = dp[i][j - 1] + robot[j - 1].abs_diff(f_pos) as i64;
+                dp[i][j] = dp[i][j].min(dp[i - 1][j]);
+                let mut temp = 0;
+                for k in (1..j).rev() {
+                    temp += robot[k].abs_diff(f_pos) as i64;
+                    dp[i][j] = dp[i][j].min(dp[i - 1][k] + temp);
+                }
+            }
+            for j in f_cap + 1..=robot.len() {
+                dp[i][j] = dp[i-1][j];
+                let mut temp = 0;
+                let (mut min_i,mut min_j,mut min_k,mut min_temp,mut min_ans) = (i,j,-1_i64,0,0);
+                for k in (j-f_cap + 1..=j).rev() {
+                    // println!("i: {}, j: {}, k: {}", i, j, k);
+                    temp += robot[k-1].abs_diff(f_pos) as i64;
+                    // println!("temp: {}", temp);
+                    if dp[i - 1][k - 1] + temp < dp[i][j] {
+                        (min_i , min_j,min_k,min_temp,min_ans) = (i,j,k as i64,temp,dp[i - 1][k - 1] + temp)
+                    }
+                    dp[i][j] = dp[i][j].min(dp[i - 1][k - 1] + temp);
+                }
             }
         }
-        ans
+        dp[factory.len() - 1][robot.len()]
     }
 }
 
 fn main() {
     println!(
         "{:?}",
-        Solution::get_min_distance(vec![1, 1, 2, 3, 2, 1, 2], 1, 2)
+        Solution::minimum_total_distance(vec![-59,-84], make_matrix("[[-86, 2], [-76, 2], [-46, 2]]"))
     );
 }
+/*
+
+
+[[-86, 2], [-76, 2], [-46, 2]]
+[-84, -59]
+[[0, 2, 29], [0, 2, 10], [0, 2, 10]]
+10
+
+
+-8 -6 -4 -2
+-86 -74 -46 -29
+  -84  -60 -59
+  -7 -5 -3
+ */