feat: add solutions to lc problem: No.2976

No.2976.Minimum Cost to Convert String I

solution/2900-2999/2976.Minimum Cost to Convert String I/README.md

@@ -76,27 +76,215 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minimumCost(
+        self,
+        source: str,
+        target: str,
+        original: List[str],
+        changed: List[str],
+        cost: List[int],
+    ) -> int:
+        g = [[inf] * 26 for _ in range(26)]
+        for i in range(26):
+            g[i][i] = 0
+        for x, y, z in zip(original, changed, cost):
+            x = ord(x) - ord('a')
+            y = ord(y) - ord('a')
+            g[x][y] = min(g[x][y], z)
+        for k in range(26):
+            for i in range(26):
+                for j in range(26):
+                    g[i][j] = min(g[i][j], g[i][k] + g[k][j])
+        ans = 0
+        for a, b in zip(source, target):
+            if a != b:
+                x, y = ord(a) - ord('a'), ord(b) - ord('a')
+                if g[x][y] >= inf:
+                    return -1
+                ans += g[x][y]
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+import java.util.Arrays;
+
+class Solution {
+    public long minimumCost(String source, String target, char[] original, char[] changed, int[] cost) {
+        final int inf = 1 << 29;
+        int[][] g = new int[26][26];
+        for (int i = 0; i < 26; ++i) {
+            Arrays.fill(g[i], inf);
+            g[i][i] = 0;
+        }
+        for (int i = 0; i < original.length; ++i) {
+            int x = original[i] - 'a';
+            int y = changed[i] - 'a';
+            int z = cost[i];
+            g[x][y] = Math.min(g[x][y], z);
+        }
+        for (int k = 0; k < 26; ++k) {
+            for (int i = 0; i < 26; ++i) {
+                for (int j = 0; j < 26; ++j) {
+                    g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
+                }
+            }
+        }
+        long ans = 0;
+        int n = source.length();
+        for (int i = 0; i < n; ++i) {
+            int x = source.charAt(i) - 'a';
+            int y = target.charAt(i) - 'a';
+            if (x != y) {
+                if (g[x][y] >= inf) {
+                    return -1;
+                }
+                ans += g[x][y];
+            }
+        }
+        return ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    long long minimumCost(string source, string target, vector<char>& original, vector<char>& changed, vector<int>& cost) {
+        const int inf = 1 << 29;
+        int g[26][26];
+        for (int i = 0; i < 26; ++i) {
+            fill(begin(g[i]), end(g[i]), inf);
+            g[i][i] = 0;
+        }
+
+        for (int i = 0; i < original.size(); ++i) {
+            int x = original[i] - 'a';
+            int y = changed[i] - 'a';
+            int z = cost[i];
+            g[x][y] = min(g[x][y], z);
+        }
+
+        for (int k = 0; k < 26; ++k) {
+            for (int i = 0; i < 26; ++i) {
+                for (int j = 0; j < 26; ++j) {
+                    g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
+                }
+            }
+        }
+
+        long long ans = 0;
+        int n = source.length();
+        for (int i = 0; i < n; ++i) {
+            int x = source[i] - 'a';
+            int y = target[i] - 'a';
+            if (x != y) {
+                if (g[x][y] >= inf) {
+                    return -1;
+                }
+                ans += g[x][y];
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func minimumCost(source string, target string, original []byte, changed []byte, cost []int) (ans int64) {
+	const inf = 1 << 29
+	g := make([][]int, 26)
+	for i := range g {
+		g[i] = make([]int, 26)
+		for j := range g[i] {
+			if i == j {
+				g[i][j] = 0
+			} else {
+				g[i][j] = inf
+			}
+		}
+	}
+
+	for i := 0; i < len(original); i++ {
+		x := int(original[i] - 'a')
+		y := int(changed[i] - 'a')
+		z := cost[i]
+		g[x][y] = min(g[x][y], z)
+	}
+
+	for k := 0; k < 26; k++ {
+		for i := 0; i < 26; i++ {
+			for j := 0; j < 26; j++ {
+				g[i][j] = min(g[i][j], g[i][k]+g[k][j])
+			}
+		}
+	}
+	n := len(source)
+	for i := 0; i < n; i++ {
+		x := int(source[i] - 'a')
+		y := int(target[i] - 'a')
+		if x != y {
+			if g[x][y] >= inf {
+				return -1
+			}
+			ans += int64(g[x][y])
+		}
+	}
+	return
+}
+```
 
+### **TypeScript**
+
+```ts
+function minimumCost(
+    source: string,
+    target: string,
+    original: string[],
+    changed: string[],
+    cost: number[],
+): number {
+    const g: number[][] = Array.from({ length: 26 }, () => Array(26).fill(Infinity));
+    for (let i = 0; i < 26; ++i) {
+        g[i][i] = 0;
+    }
+    for (let i = 0; i < original.length; ++i) {
+        let x: number = original[i].charCodeAt(0) - 'a'.charCodeAt(0);
+        let y: number = changed[i].charCodeAt(0) - 'a'.charCodeAt(0);
+        let z: number = cost[i];
+        g[x][y] = Math.min(g[x][y], z);
+    }
+
+    for (let k = 0; k < 26; ++k) {
+        for (let i = 0; i < 26; ++i) {
+            for (let j = 0; j < 26; ++j) {
+                g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
+            }
+        }
+    }
+
+    let ans: number = 0;
+    let n: number = source.length;
+    for (let i = 0; i < n; ++i) {
+        let x: number = source.charCodeAt(i) - 'a'.charCodeAt(0);
+        let y: number = target.charCodeAt(i) - 'a'.charCodeAt(0);
+        if (x !== y) {
+            if (g[x][y] >= Infinity) {
+                return -1;
+            }
+            ans += g[x][y];
+        }
+    }
+    return ans;
+}
 ```
 
 ### **...**