72. 编辑距离

src/arr.rs

@@ -79,3 +79,126 @@ pub fn make_matrix(s: &str) -> Vec<Vec<i32>> {
 
     rows
 }
+
+pub fn make_char_matrix(s: &str) -> Vec<Vec<char>> {
+    let s = s.trim();
+
+    // Remove only the outermost pair of brackets if present, e.g. "[[1,2],[3,4]]" -> "[1,2],[3,4]"
+    let inner = if s.len() >= 2 && s.starts_with('[') && s.ends_with(']') {
+        &s[1..s.len() - 1]
+    } else {
+        s
+    }
+        .trim();
+
+    if inner.is_empty() {
+        return Vec::new();
+    }
+
+    let bytes = inner.as_bytes();
+    let mut i = 0usize;
+    let mut rows: Vec<Vec<char>> = Vec::new();
+    while i < bytes.len() {
+        // find next '['
+        while i < bytes.len() && bytes[i] != b'[' {
+            i += 1;
+        }
+        if i >= bytes.len() {
+            break;
+        }
+        let start = i + 1; // byte index after '['
+        i = start;
+        // find matching ']'
+        while i < bytes.len() && bytes[i] != b']' {
+            i += 1;
+        }
+        let end = i; // exclusive
+        // move i past ']' for next iteration (if in bounds)
+        if i < bytes.len() {
+            i += 1;
+        }
+
+        if end <= start {
+            // empty row like []
+            rows.push(Vec::new());
+            continue;
+        }
+
+        let row_str = &inner[start..end];
+        let row_vec: Vec<char> = row_str
+            .split(',')
+            .map(|x| {
+                let x = x.trim().trim_matches('"');
+                if x == "null" || x.is_empty() {
+                    ' '
+                } else {
+                    x.to_string().chars().nth(0).unwrap()
+                }
+            })
+            .collect();
+        rows.push(row_vec);
+    }
+
+    rows
+}
+pub fn make_string_matrix(s: &str) -> Vec<Vec<String>> {
+    let s = s.trim();
+
+    // Remove only the outermost pair of brackets if present, e.g. "[[1,2],[3,4]]" -> "[1,2],[3,4]"
+    let inner = if s.len() >= 2 && s.starts_with('[') && s.ends_with(']') {
+        &s[1..s.len() - 1]
+    } else {
+        s
+    }
+        .trim();
+
+    if inner.is_empty() {
+        return Vec::new();
+    }
+
+    let bytes = inner.as_bytes();
+    let mut i = 0usize;
+    let mut rows: Vec<Vec<String>> = Vec::new();
+    while i < bytes.len() {
+        // find next '['
+        while i < bytes.len() && bytes[i] != b'[' {
+            i += 1;
+        }
+        if i >= bytes.len() {
+            break;
+        }
+        let start = i + 1; // byte index after '['
+        i = start;
+        // find matching ']'
+        while i < bytes.len() && bytes[i] != b']' {
+            i += 1;
+        }
+        let end = i; // exclusive
+        // move i past ']' for next iteration (if in bounds)
+        if i < bytes.len() {
+            i += 1;
+        }
+
+        if end <= start {
+            // empty row like []
+            rows.push(Vec::new());
+            continue;
+        }
+
+        let row_str = &inner[start..end];
+        let row_vec: Vec<String> = row_str
+            .split(',')
+            .map(|x| {
+                let x = x.trim().trim_matches('"');
+                if x == "null" || x.is_empty() {
+                    "".to_string()
+                } else {
+                    x.to_string()
+                }
+            })
+            .collect();
+        rows.push(row_vec);
+    }
+
+    rows
+}

src/main.rs

@@ -1,44 +1,29 @@
-use crate::arr::make_matrix;
-use std::collections::HashSet;
-
-struct Solution;
 mod arr;
+struct Solution {}
 impl Solution {
-    pub fn max_k_divisible_components(
-        n: i32,
-        edges: Vec<Vec<i32>>,
-        values: Vec<i32>,
-        k: i32,
-    ) -> i32 {
-        let mut edge = vec![HashSet::new(); n as usize];
-        edges.iter().for_each(|x| {
-            edge[x[0] as usize].insert(x[1] as usize);
-            edge[x[1] as usize].insert(x[0] as usize);
-        });
-        fn dfs(total_ans:&mut i32, k:i32, root: usize, last: usize, edge: &Vec<HashSet<usize>>,values: &Vec<i32>) -> i64{
-            let mut ans = values[root] as i64;
-            for &t in edge[root].iter() {
-                if t == last { continue; }
-                ans += dfs(total_ans,k,t, root, edge,values);
-            }
-            if ans % k as i64 == 0 {
-                *total_ans += 1;
-                0
-            }else {
-                ans
+    pub fn min_distance(word1: String, word2: String) -> i32 {
+        let mut dp = vec![vec![0; word2.len() + 1]; word1.len() + 1];
+        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;
+        }
+        for i in 1..=word2.len() {
+            dp[0][i] = dp[0][i - 1] + 1;
+        }
+        for i in 0..word1.len() {
+            for j in 0..word2.len() {
+                dp[i + 1][j + 1] = (dp[i][j] + if word1[i] != word2[j] { 1 } else { 0 })
+                    .min(dp[i][j + 1] + 1)
+                    .min(dp[i + 1][j] + 1);
             }
         }
-        let mut ans = 0;
-        dfs(&mut ans,k,0, usize::MAX, &edge,&values);
-        ans
+        dp[word1.len()][word2.len()]
     }
 }
 fn main() {
-    let result = Solution::max_k_divisible_components(
-        7,
-        make_matrix("[[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]"),
-        vec![3, 0, 6, 1, 5, 2, 1],
-        3,
+    println!(
+        "{:?}",
+        Solution::min_distance("intention".to_string(), "execution".to_string())
     );
-    println!("{:?}", result);
 }