feat: add solutions to lc problem: No.1548 (doocs#1632)

Author: yanglbme

solution/1500-1599/1548.The Most Similar Path in a Graph/README.md

@@ -80,22 +80,269 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划**
+
+我们先根据给定的道路构建一个邻接表 $g$，其中 $g[i]$ 表示与城市 $i$ 直接相连的城市列表。
+
+然后我们定义 $f[i][j]$ 表示 $targetPath$ 的第 $i$ 个城市与 $names$ 的第 $j$ 个城市匹配时，前 $i$ 个城市的最小编辑距离。
+
+那么我们可以得到状态转移方程：
+
+$$
+f[i][j] = \min_{k \in g[j]} f[i - 1][k] + (targetPath[i] \neq names[j])
+$$
+
+在状态转移的过程中，我们记录下每个状态的前驱城市，最后根据前驱城市数组 $pre$ 从后往前还原出最优路径。
+
+时间复杂度 $O(m \times n^2)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是 $targetPath$ 和 $names$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def mostSimilar(
+        self, n: int, roads: List[List[int]], names: List[str], targetPath: List[str]
+    ) -> List[int]:
+        g = [[] for _ in range(n)]
+        for a, b in roads:
+            g[a].append(b)
+            g[b].append(a)
+        m = len(targetPath)
+        f = [[inf] * n for _ in range(m)]
+        pre = [[-1] * n for _ in range(m)]
+        for j, s in enumerate(names):
+            f[0][j] = targetPath[0] != s
+        for i in range(1, m):
+            for j in range(n):
+                for k in g[j]:
+                    if (t := f[i - 1][k] + (targetPath[i] != names[j])) < f[i][j]:
+                        f[i][j] = t
+                        pre[i][j] = k
+        k = 0
+        mi = inf
+        for j in range(n):
+            if f[-1][j] < mi:
+                mi = f[-1][j]
+                k = j
+        ans = [0] * m
+        for i in range(m - 1, -1, -1):
+            ans[i] = k
+            k = pre[i][k]
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public List<Integer> mostSimilar(int n, int[][] roads, String[] names, String[] targetPath) {
+        List<Integer>[] g = new List[n];
+        Arrays.setAll(g, i -> new ArrayList<>());
+        for (int[] r : roads) {
+            int a = r[0], b = r[1];
+            g[a].add(b);
+            g[b].add(a);
+        }
+        int m = targetPath.length;
+        final int inf = 1 << 30;
+        int[][] f = new int[m][n];
+        int[][] pre = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            Arrays.fill(f[i], inf);
+            Arrays.fill(pre[i], -1);
+        }
+        for (int j = 0; j < n; ++j) {
+            f[0][j] = targetPath[0].equals(names[j]) ? 0 : 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                for (int k : g[j]) {
+                    int t = f[i - 1][k] + (targetPath[i].equals(names[j]) ? 0 : 1);
+                    if (t < f[i][j]) {
+                        f[i][j] = t;
+                        pre[i][j] = k;
+                    }
+                }
+            }
+        }
+        int mi = inf, k = 0;
+        for (int j = 0; j < n; ++j) {
+            if (f[m - 1][j] < mi) {
+                mi = f[m - 1][j];
+                k = j;
+            }
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (int i = m - 1; i >= 0; --i) {
+            ans.add(k);
+            k = pre[i][k];
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> mostSimilar(int n, vector<vector<int>>& roads, vector<string>& names, vector<string>& targetPath) {
+        vector<int> g[n];
+        for (auto& r : roads) {
+            int a = r[0], b = r[1];
+            g[a].push_back(b);
+            g[b].push_back(a);
+        }
+        int m = targetPath.size();
+        int f[m][n];
+        int pre[m][n];
+        memset(f, 0x3f, sizeof(f));
+        memset(pre, -1, sizeof(pre));
+        for (int j = 0; j < n; ++j) {
+            f[0][j] = targetPath[0] != names[j];
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                for (int k : g[j]) {
+                    int t = f[i - 1][k] + (targetPath[i] != names[j]);
+                    if (t < f[i][j]) {
+                        f[i][j] = t;
+                        pre[i][j] = k;
+                    }
+                }
+            }
+        }
+        int k = 0;
+        int mi = 1 << 30;
+        for (int j = 0; j < n; ++j) {
+            if (f[m - 1][j] < mi) {
+                mi = f[m - 1][j];
+                k = j;
+            }
+        }
+        vector<int> ans(m);
+        for (int i = m - 1; ~i; --i) {
+            ans[i] = k;
+            k = pre[i][k];
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func mostSimilar(n int, roads [][]int, names []string, targetPath []string) []int {
+	g := make([][]int, n)
+	for _, r := range roads {
+		a, b := r[0], r[1]
+		g[a] = append(g[a], b)
+		g[b] = append(g[b], a)
+	}
+	m := len(targetPath)
+	const inf = 1 << 30
+	f := make([][]int, m)
+	pre := make([][]int, m)
+	for i := range f {
+		f[i] = make([]int, n)
+		pre[i] = make([]int, n)
+		for j := range f[i] {
+			f[i][j] = inf
+			pre[i][j] = -1
+		}
+	}
+	for j, s := range names {
+		if targetPath[0] != s {
+			f[0][j] = 1
+		} else {
+			f[0][j] = 0
+		}
+	}
+	for i := 1; i < m; i++ {
+		for j := 0; j < n; j++ {
+			for _, k := range g[j] {
+				t := f[i-1][k]
+				if targetPath[i] != names[j] {
+					t++
+				}
+				if t < f[i][j] {
+					f[i][j] = t
+					pre[i][j] = k
+				}
+			}
+		}
+	}
+	mi, k := inf, 0
+	for j := 0; j < n; j++ {
+		if f[m-1][j] < mi {
+			mi = f[m-1][j]
+			k = j
+		}
+	}
+	ans := make([]int, m)
+	for i := m - 1; i >= 0; i-- {
+		ans[i] = k
+		k = pre[i][k]
+	}
+	return ans
+}
+```
 
+### **TypeScript**
+
+```ts
+function mostSimilar(
+    n: number,
+    roads: number[][],
+    names: string[],
+    targetPath: string[],
+): number[] {
+    const g: number[][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of roads) {
+        g[a].push(b);
+        g[b].push(a);
+    }
+    const m = targetPath.length;
+    const f = Array.from({ length: m }, () => Array.from({ length: n }, () => Infinity));
+    const pre: number[][] = Array.from({ length: m }, () => Array.from({ length: n }, () => -1));
+    for (let j = 0; j < n; ++j) {
+        f[0][j] = names[j] === targetPath[0] ? 0 : 1;
+    }
+    for (let i = 1; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            for (const k of g[j]) {
+                const t = f[i - 1][k] + (names[j] === targetPath[i] ? 0 : 1);
+                if (t < f[i][j]) {
+                    f[i][j] = t;
+                    pre[i][j] = k;
+                }
+            }
+        }
+    }
+    let k = 0;
+    let mi = Infinity;
+    for (let j = 0; j < n; ++j) {
+        if (f[m - 1][j] < mi) {
+            mi = f[m - 1][j];
+            k = j;
+        }
+    }
+    const ans: number[] = Array(m).fill(0);
+    for (let i = m - 1; ~i; --i) {
+        ans[i] = k;
+        k = pre[i][k];
+    }
+    return ans;
+}
 ```
 
 ### **...**