72. 编辑距离

.gitignore

@@ -1 +1,2 @@
 **/target
+.idea

src/arr.rs

@@ -0,0 +1,204 @@
+pub fn make_string_arr(s: &str) -> Vec<String> {
+    s.trim_matches(&['[', ']'][..])
+        .split(',')
+        .map(|s| s.trim_matches(&['"',' ']).to_string())
+        .collect()
+}
+pub fn make_arr(s: &str) -> Vec<i32> {
+    s.trim_matches(&['[', ']'][..])
+        .split(',')
+        .map(|x| {
+            let x = x.trim();
+            if x == "null" {
+                -1
+            } else {
+                x.parse::<i32>().unwrap()
+            }
+        })
+        .collect()
+}
+
+pub fn make_matrix(s: &str) -> Vec<Vec<i32>> {
+    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<i32>> = 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<i32> = row_str
+            .split(',')
+            .map(|x| {
+                let x = x.trim();
+                if x == "null" || x.is_empty() {
+                    -1
+                } else {
+                    x.parse::<i32>().unwrap()
+                }
+            })
+            .collect();
+        rows.push(row_vec);
+    }
+
+    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/list.rs

@@ -0,0 +1,33 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+  pub val: i32,
+  pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+  #[inline]
+  fn new(val: i32) -> Self {
+    ListNode {
+      next: None,
+      val
+    }
+  }
+}
+
+pub fn make_list(arr: Vec<i32>) -> Option<Box<ListNode>> {
+    let mut head: Option<Box<ListNode>> = None;
+    let mut current = &mut head;
+
+    for &value in arr.iter() {
+        let new_node = Box::new(ListNode::new(value));
+        if current.is_none() {
+            *current = Some(new_node);
+        } else {
+            current.as_mut().unwrap().next = Some(new_node);
+            current = &mut current.as_mut().unwrap().next;
+        }
+    }
+
+    head
+}

src/main.rs

@@ -1,44 +1,29 @@
-use std::cmp::max;
-use std::collections::HashMap;
-
-struct Solution;
+mod arr;
+struct Solution {}
 impl Solution {
-    pub fn maximum_unique_subarray(nums: Vec<i32>) -> i32 {
-        let mut map: HashMap<i32, usize> = HashMap::new();
-        let mut ans = 0;
-        for i in  0..nums.len() {
-            if map.contains_key(&nums[i]) {
-                let l = i - map.len();
-                let r = i;
-                let mut temp = 0;
-                let mut j = l;
-                while j < r {
-                    temp += nums[j];
-                    j+=1;
-                }
-                ans = max(ans, temp);
-                j = l;
-                while nums[j] != nums[i] {
-                    map.remove(&nums[j]);
-                    j += 1;
-                }
-                map.insert(nums[i], i);
-            }
-            else {
-                map.insert(nums[i], i);
+    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 temp = 0;
-        let mut j = nums.len() - map.len();
-        while j < nums.len() {
-            temp += nums[j];
-            j += 1;
-        }
-        max(ans, temp)
+        dp[word1.len()][word2.len()]
     }
 }
-
 fn main() {
-    let sl = Solution::maximum_unique_subarray(vec![4,2,4,5,6]);
-    println!("{}", sl);
+    println!(
+        "{:?}",
+        Solution::min_distance("intention".to_string(), "execution".to_string())
+    );
 }

src/tree.rs

@@ -0,0 +1,48 @@
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::VecDeque;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode { val, left: None, right: None }
+    }
+}
+
+pub fn build_tree(vals: &[Option<i32>]) -> Option<Rc<RefCell<TreeNode>>> {
+    if vals.is_empty() || vals[0].is_none() {
+        return None;
+    }
+    let root = Rc::new(RefCell::new(TreeNode::new(vals[0].unwrap())));
+    let mut queue = VecDeque::new();
+    queue.push_back(root.clone());
+    let mut i = 1;
+    while i < vals.len() {
+        if let Some(node) = queue.pop_front() {
+            if i < vals.len() {
+                if let Some(val) = vals[i] {
+                    let left = Rc::new(RefCell::new(TreeNode::new(val)));
+                    node.borrow_mut().left = Some(left.clone());
+                    queue.push_back(left);
+                }
+                i += 1;
+            }
+            if i < vals.len() {
+                if let Some(val) = vals[i] {
+                    let right = Rc::new(RefCell::new(TreeNode::new(val)));
+                    node.borrow_mut().right = Some(right.clone());
+                    queue.push_back(right);
+                }
+                i += 1;
+            }
+        }
+    }
+    Some(root)
+}