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,30 +1,29 @@
-use crate::arr::make_matrix;
-
-struct Solution;
 mod arr;
+struct Solution {}
 impl Solution {
-    pub fn number_of_paths(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+    pub fn min_distance(word1: String, word2: String) -> i32 {
-        let mut arr = vec![vec![vec![0; k as usize]; grid[0].len()]; grid.len()];
+        let mut dp = vec![vec![0; word2.len() + 1]; word1.len() + 1];
-        let r#mod = 1e9 as i32 + 7;
+        let word1 = word1.chars().collect::<Vec<char>>();
-        arr[0][0][(grid[0][0] % k) as usize] = 1;
+        let word2 = word2.chars().collect::<Vec<char>>();
-        for i in 0..grid.len() {
+        for i in 1..=word1.len() {
-            for j in 0..grid[i].len() {
+            dp[i][0] = dp[i - 1][0] + 1;
-                if i < grid.len() - 1 {
+        }
-                    for l in 0..k {
+        for i in 1..=word2.len() {
-                        arr[i + 1][j][((l + grid[i + 1][j]) % k) as usize] = (arr[i + 1][j][((l + grid[i + 1][j]) % k) as usize] + arr[i][j][l as usize]) % r#mod;
+            dp[0][i] = dp[0][i - 1] + 1;
-                    }
+        }
-                }
+        for i in 0..word1.len() {
-                if j < grid[0].len() - 1 {
+            for j in 0..word2.len() {
-                    for l in 0..k {
+                dp[i + 1][j + 1] = (dp[i][j] + if word1[i] != word2[j] { 1 } else { 0 })
-                        arr[i][j + 1][((l + grid[i][j + 1]) % k) as usize] = (arr[i][j + 1][((l + grid[i][j + 1]) % k) as usize] + arr[i][j][l as usize]) % r#mod;
+                    .min(dp[i][j + 1] + 1)
-                    }
+                    .min(dp[i + 1][j] + 1);
-                }
             }
         }
-        arr[grid.len() - 1][grid[0].len() - 1][0]
+        dp[word1.len()][word2.len()]
     }
 }
 fn main() {
-    let result = Solution::number_of_paths(make_matrix("[[5,2,4],[3,0,5],[0,7,2]]"), 3);
+    println!(
-    println!("{:?}", result);
+        "{:?}",
+        Solution::min_distance("intention".to_string(), "execution".to_string())
+    );
 }