72. 编辑距离

src/main.rs

@@ -1,134 +1,29 @@
-use crate::arr::make_matrix;
-
 mod arr;
 struct Solution {}
 impl Solution {
-    fn get_ans_from_tree(tree: &Vec<i32>, layer_count: usize, l: usize, r: usize) -> usize {
+    pub fn min_distance(word1: String, word2: String) -> i32 {
-        let (cl, cr) = (0, 2_usize.pow(layer_count as u32 - 1) - 1);
+        let mut dp = vec![vec![0; word2.len() + 1]; word1.len() + 1];
-        Self::dfs(tree, 1, cl, cr, l, r)
+        let word1 = word1.chars().collect::<Vec<char>>();
+        let word2 = word2.chars().collect::<Vec<char>>();
+        for i in 1..=word1.len() {
+            dp[i][0] = dp[i - 1][0] + 1;
         }
-    fn dfs(
+        for i in 1..=word2.len() {
-        tree: &Vec<i32>,
+            dp[0][i] = dp[0][i - 1] + 1;
-        root: usize,
-        l: usize,
-        r: usize,
-        target_l: usize,
-        target_r: usize,
-    ) -> usize {
-        if l >= target_l && r <= target_r {
-            return tree[root] as usize;
         }
-        if l > target_r || r < target_l {
+        for i in 0..word1.len() {
-            return 0;
+            for j in 0..word2.len() {
-        }
+                dp[i + 1][j + 1] = (dp[i][j] + if word1[i] != word2[j] { 1 } else { 0 })
-        let from_l = Self::dfs(tree, root * 2, l, (r - l) / 2 + l, target_l, target_r);
+                    .min(dp[i][j + 1] + 1)
-        let from_r = Self::dfs(
+                    .min(dp[i + 1][j] + 1);
-            tree,
-            root * 2 + 1,
-            (r - l) / 2 + l + 1,
-            r,
-            target_l,
-            target_r,
-        );
-        from_l.max(from_r)
-    }
-    pub fn max_active_sections_after_trade(s: String, queries: Vec<Vec<i32>>) -> Vec<i32> {
-        let arr = s
-            .chars()
-            .map(|x| -> u8 { x as u8 - b'0' })
-            .collect::<Vec<u8>>();
-        let mut zero_start = vec![];
-        let mut zero_end = vec![];
-        let mut zero_len = vec![];
-        // let mut one_count = vec![0];
-        let mut one_count = 0;
-        let mut zero_count = -1;
-        for i in 0..arr.len() {
-            if arr[i] == 0 {
-                // one_count.push(one_count[one_count.len() - 1]);
-                if zero_count == -1 {
-                    zero_start.push(i);
-                    zero_count = 1;
-                } else {
-                    zero_count = zero_count + 1;
-                }
-            } else {
-                // one_count.push(one_count[one_count.len() - 1] + 1);
-                one_count += 1;
-                if zero_count != -1 {
-                    zero_len.push(zero_count);
-                    zero_end.push(i - 1);
-                    zero_count = -1;
             }
         }
-        }
+        dp[word1.len()][word2.len()]
-        if zero_count != -1 {
-            zero_len.push(zero_count);
-            zero_end.push(arr.len() - 1);
-        }
-
-        let len = zero_len.len() as f64 - 1f64;
-        let layer_count = len.log2().ceil() as usize + 1;
-        let tree_len = 2_usize.pow(layer_count as u32);
-        let mut tree = vec![0; tree_len];
-        let base = 2_usize.pow(layer_count as u32 - 1);
-        if zero_len.len() > 0 {
-            for i in 0..zero_len.len() - 1 {
-                tree[base + i] = zero_len[i] + zero_len[i + 1];
-            }
-            for i in (1..base).rev() {
-                tree[i] = tree[i * 2].max(tree[i * 2 + 1]);
-            }
-        }
-        let mut ans = vec![];
-        for query in queries {
-            let (l, r) = (query[0] as usize, query[1] as usize);
-            // let one = one_count[one_count.len() - 1] - one_count[0];
-            let one = one_count;
-            let i = zero_start.partition_point(|&x| x < l);
-            let j = zero_end.partition_point(|&x| x <= r);
-            let mut local_ans = 0;
-
-            if j as i32 - i as i32 >= 2 {
-                local_ans = local_ans.max(Self::get_ans_from_tree(&tree, layer_count, i, j - 2));
-            }
-            if j as i32 - i as i32 >= 1 {
-                if i > 0 && i < zero_end.len() {
-                    if zero_end[i - 1] >= l {
-                        let pz = zero_end[i] - zero_start[i] + 1 + zero_end[i - 1] - l + 1;
-                        local_ans = local_ans.max(pz);
-                    }
-                }
-                if j < zero_end.len() && j > 0 {
-                    if r >= zero_start[j] {
-                        let pz = zero_end[j - 1] - zero_start[j - 1] + 1 + r - zero_start[j] + 1;
-                        local_ans = local_ans.max(pz);
-                    }
-                }
-            }
-            if i == j {
-                if i > 0
-                    && i < zero_len.len()
-                    && j < zero_len.len()
-                    && j > 0
-                    && zero_end[i - 1] >= l
-                    && zero_start[i] <= r
-                {
-                    let pz = zero_end[j - 1] - l + 1 + r - zero_start[j] + 1;
-                    local_ans = local_ans.max(pz);
-                }
-            }
-            ans.push((local_ans + one) as i32);
-        }
-        ans
     }
 }
 fn main() {
     println!(
         "{:?}",
-        Solution::max_active_sections_after_trade(
+        Solution::min_distance("intention".to_string(), "execution".to_string())
-            "0110110101010000101".to_string(),
-            make_matrix("[[12,17]]")
-        )
     );
 }