feat: add ts solution to lc problem: No.1334

Author: rain84

solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md

@@ -526,4 +526,67 @@ function findTheCity(n: number, edges: number[][], distanceThreshold: number): n
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 3
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
+    const MAX = Number.POSITIVE_INFINITY;
+    const g = Array.from({ length: n }, () => new Map<number, number>());
+    const dist: number[] = Array(n).fill(MAX);
+    const vis: boolean[] = Array(n).fill(false);
+    for (const [f, t, w] of edges) {
+        g[f].set(t, w);
+        g[t].set(f, w);
+    }
+
+    const dijkstra = (u: number): number => {
+        dist.fill(MAX);
+        vis.fill(false);
+        dist[u] = 0;
+        const pq = new MinPriorityQueue();
+        pq.enqueue(u, 0);
+
+        while (!pq.isEmpty()) {
+            const u = pq.dequeue().element;
+            if (vis[u]) continue;
+            vis[u] = true;
+
+            for (const [v, w] of g[u]) {
+                if (vis[v]) continue;
+
+                const wNext = dist[u] + w;
+                if (wNext < dist[v]) {
+                    dist[v] = wNext;
+                    pq.enqueue(v, dist[v]);
+                }
+            }
+        }
+
+        return dist.filter(d => d <= distanceThreshold).length;
+    };
+
+    let ans = n;
+    let cnt = MAX;
+    for (let i = n - 1; i >= 0; --i) {
+        const t = dijkstra(i);
+        if (t < cnt) {
+            cnt = t;
+            ans = i;
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README_EN.md

@@ -508,4 +508,67 @@ function findTheCity(n: number, edges: number[][], distanceThreshold: number): n
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 3
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
+    const MAX = Number.POSITIVE_INFINITY;
+    const g = Array.from({ length: n }, () => new Map<number, number>());
+    const dist: number[] = Array(n).fill(MAX);
+    const vis: boolean[] = Array(n).fill(false);
+    for (const [f, t, w] of edges) {
+        g[f].set(t, w);
+        g[t].set(f, w);
+    }
+
+    const dijkstra = (u: number): number => {
+        dist.fill(MAX);
+        vis.fill(false);
+        dist[u] = 0;
+        const pq = new MinPriorityQueue();
+        pq.enqueue(u, 0);
+
+        while (!pq.isEmpty()) {
+            const u = pq.dequeue().element;
+            if (vis[u]) continue;
+            vis[u] = true;
+
+            for (const [v, w] of g[u]) {
+                if (vis[v]) continue;
+
+                const wNext = dist[u] + w;
+                if (wNext < dist[v]) {
+                    dist[v] = wNext;
+                    pq.enqueue(v, dist[v]);
+                }
+            }
+        }
+
+        return dist.filter(d => d <= distanceThreshold).length;
+    };
+
+    let ans = n;
+    let cnt = MAX;
+    for (let i = n - 1; i >= 0; --i) {
+        const t = dijkstra(i);
+        if (t < cnt) {
+            cnt = t;
+            ans = i;
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/Solution3.ts

@@ -0,0 +1,48 @@
+function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
+    const MAX = Number.POSITIVE_INFINITY;
+    const g = Array.from({ length: n }, () => new Map<number, number>());
+    const dist: number[] = Array(n).fill(MAX);
+    const vis: boolean[] = Array(n).fill(false);
+    for (const [f, t, w] of edges) {
+        g[f].set(t, w);
+        g[t].set(f, w);
+    }
+
+    const dijkstra = (u: number): number => {
+        dist.fill(MAX);
+        vis.fill(false);
+        dist[u] = 0;
+        const pq = new MinPriorityQueue();
+        pq.enqueue(u, 0);
+
+        while (!pq.isEmpty()) {
+            const u = pq.dequeue().element;
+            if (vis[u]) continue;
+            vis[u] = true;
+
+            for (const [v, w] of g[u]) {
+                if (vis[v]) continue;
+
+                const wNext = dist[u] + w;
+                if (wNext < dist[v]) {
+                    dist[v] = wNext;
+                    pq.enqueue(v, dist[v]);
+                }
+            }
+        }
+
+        return dist.filter(d => d <= distanceThreshold).length;
+    };
+
+    let ans = n;
+    let cnt = MAX;
+    for (let i = n - 1; i >= 0; --i) {
+        const t = dijkstra(i);
+        if (t < cnt) {
+            cnt = t;
+            ans = i;
+        }
+    }
+
+    return ans;
+}