feat: add Rust solution for lc No.2977 (#4990)

Author: yanglbme

solution/2900-2999/2977.Minimum Cost to Convert String II/README.md

@@ -50,7 +50,7 @@ tags:
 - 将子串 source[2..2] 从 "c" 改为 "e" ，成本为 1 。
 - 将子串 source[2..2] 从 "e" 改为 "b" ，成本为 2 。
 - 将子串 source[3..3] 从 "d" 改为 "e" ，成本为 20 。
-产生的总成本是 5 + 1 + 2 + 20 = 28 。 
+产生的总成本是 5 + 1 + 2 + 20 = 28 。
 可以证明这是可能的最小成本。
 </pre>
 
@@ -569,6 +569,136 @@ function minimumCost(
 }
 ```
 
+#### Rust
+
+```rust
+use std::cmp::min;
+
+struct Node {
+    children: [Option<Box<Node>>; 26],
+    v: i32,
+}
+
+impl Node {
+    fn new() -> Self {
+        Self {
+            children: std::array::from_fn(|_| None),
+            v: -1,
+        }
+    }
+}
+
+impl Solution {
+    pub fn minimum_cost(
+        source: String,
+        target: String,
+        original: Vec<String>,
+        changed: Vec<String>,
+        cost: Vec<i32>,
+    ) -> i64 {
+        let inf: i64 = 1 << 60;
+        let mut root = Box::new(Node::new());
+        let mut idx: usize = 0;
+        let m = cost.len();
+        let n = m << 1;
+
+        let mut g = vec![vec![inf; n]; n];
+        for i in 0..n {
+            g[i][i] = 0;
+        }
+
+        let mut insert = |w: &str, root: &mut Box<Node>, idx: &mut usize| -> usize {
+            let mut node: &mut Box<Node> = root;
+            for c in w.bytes() {
+                let i = (c - b'a') as usize;
+                if node.children[i].is_none() {
+                    node.children[i] = Some(Box::new(Node::new()));
+                }
+                node = node.children[i].as_mut().unwrap();
+            }
+            if node.v < 0 {
+                node.v = *idx as i32;
+                *idx += 1;
+            }
+            node.v as usize
+        };
+
+        for i in 0..m {
+            let x = insert(&original[i], &mut root, &mut idx);
+            let y = insert(&changed[i], &mut root, &mut idx);
+            g[x][y] = min(g[x][y], cost[i] as i64);
+        }
+
+        for k in 0..idx {
+            for i in 0..idx {
+                if g[i][k] >= inf {
+                    continue;
+                }
+                for j in 0..idx {
+                    let v = g[i][k] + g[k][j];
+                    if v < g[i][j] {
+                        g[i][j] = v;
+                    }
+                }
+            }
+        }
+
+        let s = source.into_bytes();
+        let t = target.into_bytes();
+        let len = s.len();
+        let mut f: Vec<Option<i64>> = vec![None; len];
+
+        fn dfs(
+            i: usize,
+            s: &[u8],
+            t: &[u8],
+            root: &Box<Node>,
+            g: &Vec<Vec<i64>>,
+            f: &mut Vec<Option<i64>>,
+            inf: i64,
+        ) -> i64 {
+            if i >= s.len() {
+                return 0;
+            }
+            if let Some(v) = f[i] {
+                return v;
+            }
+            let mut res = if s[i] == t[i] {
+                dfs(i + 1, s, t, root, g, f, inf)
+            } else {
+                inf
+            };
+            let mut p: Option<&Box<Node>> = Some(root);
+            let mut q: Option<&Box<Node>> = Some(root);
+            for j in i..s.len() {
+                p = p.and_then(|x| x.children[(s[j] - b'a') as usize].as_ref());
+                q = q.and_then(|x| x.children[(t[j] - b'a') as usize].as_ref());
+                if p.is_none() || q.is_none() {
+                    break;
+                }
+                let pv = p.unwrap().v;
+                let qv = q.unwrap().v;
+                if pv < 0 || qv < 0 {
+                    continue;
+                }
+                let c = g[pv as usize][qv as usize];
+                if c < inf {
+                    let v = c + dfs(j + 1, s, t, root, g, f, inf);
+                    if v < res {
+                        res = v;
+                    }
+                }
+            }
+            f[i] = Some(res);
+            res
+        }
+
+        let ans = dfs(0, &s, &t, &root, &g, &mut f, inf);
+        if ans >= inf { -1 } else { ans }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2977.Minimum Cost to Convert String II/README_EN.md

@@ -47,7 +47,7 @@ tags:
 - Change substring source[2..2] from "c" to "e" at a cost of 1.
 - Change substring source[2..2] from "e" to "b" at a cost of 2.
 - Change substring source[3..3] from "d" to "e" at a cost of 20.
-The total cost incurred is 5 + 1 + 2 + 20 = 28. 
+The total cost incurred is 5 + 1 + 2 + 20 = 28.
 It can be shown that this is the minimum possible cost.
 </pre>
 
@@ -565,6 +565,136 @@ function minimumCost(
 }
 ```
 
+#### Rust
+
+```rust
+use std::cmp::min;
+
+struct Node {
+    children: [Option<Box<Node>>; 26],
+    v: i32,
+}
+
+impl Node {
+    fn new() -> Self {
+        Self {
+            children: std::array::from_fn(|_| None),
+            v: -1,
+        }
+    }
+}
+
+impl Solution {
+    pub fn minimum_cost(
+        source: String,
+        target: String,
+        original: Vec<String>,
+        changed: Vec<String>,
+        cost: Vec<i32>,
+    ) -> i64 {
+        let inf: i64 = 1 << 60;
+        let mut root = Box::new(Node::new());
+        let mut idx: usize = 0;
+        let m = cost.len();
+        let n = m << 1;
+
+        let mut g = vec![vec![inf; n]; n];
+        for i in 0..n {
+            g[i][i] = 0;
+        }
+
+        let mut insert = |w: &str, root: &mut Box<Node>, idx: &mut usize| -> usize {
+            let mut node: &mut Box<Node> = root;
+            for c in w.bytes() {
+                let i = (c - b'a') as usize;
+                if node.children[i].is_none() {
+                    node.children[i] = Some(Box::new(Node::new()));
+                }
+                node = node.children[i].as_mut().unwrap();
+            }
+            if node.v < 0 {
+                node.v = *idx as i32;
+                *idx += 1;
+            }
+            node.v as usize
+        };
+
+        for i in 0..m {
+            let x = insert(&original[i], &mut root, &mut idx);
+            let y = insert(&changed[i], &mut root, &mut idx);
+            g[x][y] = min(g[x][y], cost[i] as i64);
+        }
+
+        for k in 0..idx {
+            for i in 0..idx {
+                if g[i][k] >= inf {
+                    continue;
+                }
+                for j in 0..idx {
+                    let v = g[i][k] + g[k][j];
+                    if v < g[i][j] {
+                        g[i][j] = v;
+                    }
+                }
+            }
+        }
+
+        let s = source.into_bytes();
+        let t = target.into_bytes();
+        let len = s.len();
+        let mut f: Vec<Option<i64>> = vec![None; len];
+
+        fn dfs(
+            i: usize,
+            s: &[u8],
+            t: &[u8],
+            root: &Box<Node>,
+            g: &Vec<Vec<i64>>,
+            f: &mut Vec<Option<i64>>,
+            inf: i64,
+        ) -> i64 {
+            if i >= s.len() {
+                return 0;
+            }
+            if let Some(v) = f[i] {
+                return v;
+            }
+            let mut res = if s[i] == t[i] {
+                dfs(i + 1, s, t, root, g, f, inf)
+            } else {
+                inf
+            };
+            let mut p: Option<&Box<Node>> = Some(root);
+            let mut q: Option<&Box<Node>> = Some(root);
+            for j in i..s.len() {
+                p = p.and_then(|x| x.children[(s[j] - b'a') as usize].as_ref());
+                q = q.and_then(|x| x.children[(t[j] - b'a') as usize].as_ref());
+                if p.is_none() || q.is_none() {
+                    break;
+                }
+                let pv = p.unwrap().v;
+                let qv = q.unwrap().v;
+                if pv < 0 || qv < 0 {
+                    continue;
+                }
+                let c = g[pv as usize][qv as usize];
+                if c < inf {
+                    let v = c + dfs(j + 1, s, t, root, g, f, inf);
+                    if v < res {
+                        res = v;
+                    }
+                }
+            }
+            f[i] = Some(res);
+            res
+        }
+
+        let ans = dfs(0, &s, &t, &root, &g, &mut f, inf);
+        if ans >= inf { -1 } else { ans }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->