feat: add solutions to lc problem: No.0743

solution/0700-0799/0743.Network Delay Time/Solution.cpp

@@ -1,13 +1,14 @@
 class Solution {
 public:
-    const int inf = 0x3f3f;
-
     int networkDelayTime(vector<vector<int>>& times, int n, int k) {
+        const int inf = 1 << 29;
         vector<vector<int>> g(n, vector<int>(n, inf));
-        for (auto& t : times) g[t[0] - 1][t[1] - 1] = t[2];
-        vector<bool> vis(n);
+        for (const auto& e : times) {
+            g[e[0] - 1][e[1] - 1] = e[2];
+        }
         vector<int> dist(n, inf);
         dist[k - 1] = 0;
+        vector<bool> vis(n);
         for (int i = 0; i < n; ++i) {
             int t = -1;
             for (int j = 0; j < n; ++j) {
@@ -20,7 +21,7 @@ class Solution {
                 dist[j] = min(dist[j], dist[t] + g[t][j]);
             }
         }
-        int ans = *max_element(dist.begin(), dist.end());
+        int ans = ranges::max(dist);
         return ans == inf ? -1 : ans;
     }
-};
+};

solution/0700-0799/0743.Network Delay Time/Solution.go

@@ -1,19 +1,23 @@
 func networkDelayTime(times [][]int, n int, k int) int {
-	const inf = 0x3f3f
-	dist := make([]int, n)
-	vis := make([]bool, n)
+	const inf = 1 << 29
 	g := make([][]int, n)
-	for i := range dist {
-		dist[i] = inf
+	for i := range g {
 		g[i] = make([]int, n)
 		for j := range g[i] {
 			g[i][j] = inf
 		}
 	}
-	for _, t := range times {
-		g[t[0]-1][t[1]-1] = t[2]
+	for _, e := range times {
+		g[e[0]-1][e[1]-1] = e[2]
+	}
+
+	dist := make([]int, n)
+	for i := range dist {
+		dist[i] = inf
 	}
 	dist[k-1] = 0
+
+	vis := make([]bool, n)
 	for i := 0; i < n; i++ {
 		t := -1
 		for j := 0; j < n; j++ {
@@ -26,9 +30,9 @@ func networkDelayTime(times [][]int, n int, k int) int {
 			dist[j] = min(dist[j], dist[t]+g[t][j])
 		}
 	}
-	ans := slices.Max(dist)
-	if ans == inf {
-		return -1
+
+	if ans := slices.Max(dist); ans != inf {
+		return ans
 	}
-	return ans
-}
+	return -1
+}

solution/0700-0799/0743.Network Delay Time/Solution.java

@@ -1,18 +1,17 @@
 class Solution {
-    private static final int INF = 0x3f3f;
-
     public int networkDelayTime(int[][] times, int n, int k) {
         int[][] g = new int[n][n];
         int[] dist = new int[n];
-        boolean[] vis = new boolean[n];
-        for (int i = 0; i < n; ++i) {
-            dist[i] = INF;
-            Arrays.fill(g[i], INF);
+        final int inf = 1 << 29;
+        Arrays.fill(dist, inf);
+        for (var e : g) {
+            Arrays.fill(e, inf);
         }
-        for (int[] t : times) {
-            g[t[0] - 1][t[1] - 1] = t[2];
+        for (var e : times) {
+            g[e[0] - 1][e[1] - 1] = e[2];
         }
         dist[k - 1] = 0;
+        boolean[] vis = new boolean[n];
         for (int i = 0; i < n; ++i) {
             int t = -1;
             for (int j = 0; j < n; ++j) {
@@ -26,9 +25,9 @@ public int networkDelayTime(int[][] times, int n, int k) {
             }
         }
         int ans = 0;
-        for (int d : dist) {
-            ans = Math.max(ans, d);
+        for (int x : dist) {
+            ans = Math.max(ans, x);
         }
-        return ans == INF ? -1 : ans;
+        return ans == inf ? -1 : ans;
     }
-}
+}

solution/0700-0799/0743.Network Delay Time/Solution.py

@@ -1,12 +1,11 @@
 class Solution:
     def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
-        INF = 0x3F3F
-        dist = [INF] * n
-        vis = [False] * n
-        g = [[INF] * n for _ in range(n)]
+        g = [[inf] * n for _ in range(n)]
         for u, v, w in times:
             g[u - 1][v - 1] = w
+        dist = [inf] * n
         dist[k - 1] = 0
+        vis = [False] * n
         for _ in range(n):
             t = -1
             for j in range(n):
@@ -16,4 +15,4 @@ def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
             for j in range(n):
                 dist[j] = min(dist[j], dist[t] + g[t][j])
         ans = max(dist)
-        return -1 if ans == INF else ans
+        return -1 if ans == inf else ans

solution/0700-0799/0743.Network Delay Time/Solution.ts

@@ -0,0 +1,23 @@
+function networkDelayTime(times: number[][], n: number, k: number): number {
+    const g: number[][] = Array.from({ length: n }, () => Array(n).fill(Infinity));
+    for (const [u, v, w] of times) {
+        g[u - 1][v - 1] = w;
+    }
+    const dist: number[] = Array(n).fill(Infinity);
+    dist[k - 1] = 0;
+    const vis: boolean[] = Array(n).fill(false);
+    for (let i = 0; i < n; ++i) {
+        let t = -1;
+        for (let j = 0; j < n; ++j) {
+            if (!vis[j] && (t === -1 || dist[j] < dist[t])) {
+                t = j;
+            }
+        }
+        vis[t] = true;
+        for (let j = 0; j < n; ++j) {
+            dist[j] = Math.min(dist[j], dist[t] + g[t][j]);
+        }
+    }
+    const ans = Math.max(...dist);
+    return ans === Infinity ? -1 : ans;
+}

solution/0700-0799/0743.Network Delay Time/Solution2.cpp

@@ -1,27 +1,33 @@
 class Solution {
 public:
-    const int inf = 0x3f3f;
-
     int networkDelayTime(vector<vector<int>>& times, int n, int k) {
-        vector<vector<vector<int>>> g(n);
-        for (auto& t : times) g[t[0] - 1].push_back({t[1] - 1, t[2]});
+        const int inf = 1 << 29;
+        using pii = pair<int, int>;
+        vector<vector<pii>> g(n);
+        for (auto& edge : times) {
+            g[edge[0] - 1].emplace_back(edge[1] - 1, edge[2]);
+        }
+
         vector<int> dist(n, inf);
         dist[k - 1] = 0;
-        priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> q;
-        q.push({0, k - 1});
-        while (!q.empty()) {
-            auto p = q.top();
-            q.pop();
-            int u = p[1];
-            for (auto& ne : g[u]) {
-                int v = ne[0], w = ne[1];
+        priority_queue<pii, vector<pii>, greater<>> pq;
+        pq.emplace(0, k - 1);
+
+        while (!pq.empty()) {
+            auto [d, u] = pq.top();
+            pq.pop();
+            if (d > dist[u]) {
+                continue;
+            }
+            for (auto& [v, w] : g[u]) {
                 if (dist[v] > dist[u] + w) {
                     dist[v] = dist[u] + w;
-                    q.push({dist[v], v});
+                    pq.emplace(dist[v], v);
                 }
             }
         }
-        int ans = *max_element(dist.begin(), dist.end());
+
+        int ans = ranges::max(dist);
         return ans == inf ? -1 : ans;
     }
-};
+};

solution/0700-0799/0743.Network Delay Time/Solution2.go

@@ -1,55 +1,42 @@
-const Inf = 0x3f3f3f3f
-
-type pair struct {
-	first  int
-	second int
-}
-
-var _ heap.Interface = (*pairs)(nil)
-
-type pairs []pair
-
-func (a pairs) Len() int { return len(a) }
-func (a pairs) Less(i int, j int) bool {
-	return a[i].first < a[j].first || a[i].first == a[j].first && a[i].second < a[j].second
-}
-func (a pairs) Swap(i int, j int) { a[i], a[j] = a[j], a[i] }
-func (a *pairs) Push(x any)       { *a = append(*a, x.(pair)) }
-func (a *pairs) Pop() any         { l := len(*a); t := (*a)[l-1]; *a = (*a)[:l-1]; return t }
-
 func networkDelayTime(times [][]int, n int, k int) int {
-	graph := make([]pairs, n)
-	for _, time := range times {
-		from, to, time := time[0]-1, time[1]-1, time[2]
-		graph[from] = append(graph[from], pair{to, time})
+	g := make([][][2]int, n)
+	for _, e := range times {
+		u, v, w := e[0]-1, e[1]-1, e[2]
+		g[u] = append(g[u], [2]int{v, w})
 	}
-
-	dis := make([]int, n)
-	for i := range dis {
-		dis[i] = Inf
+	dist := make([]int, n)
+	const inf int = 1 << 29
+	for i := range dist {
+		dist[i] = inf
 	}
-	dis[k-1] = 0
-
-	vis := make([]bool, n)
-	h := make(pairs, 0)
-	heap.Push(&h, pair{0, k - 1})
-	for len(h) > 0 {
-		from := heap.Pop(&h).(pair).second
-		if vis[from] {
+	dist[k-1] = 0
+	pq := hp{{0, k - 1}}
+	for len(pq) > 0 {
+		p := heap.Pop(&pq).(pair)
+		d, u := p.x, p.i
+		if d > dist[u] {
 			continue
 		}
-		vis[from] = true
-		for _, e := range graph[from] {
-			to, d := e.first, dis[from]+e.second
-			if d < dis[to] {
-				dis[to] = d
-				heap.Push(&h, pair{d, to})
+		for _, e := range g[u] {
+			v, w := e[0], e[1]
+			if nd := d + w; nd < dist[v] {
+				dist[v] = nd
+				heap.Push(&pq, pair{nd, v})
 			}
 		}
 	}
-	ans := slices.Max(dis)
-	if ans == Inf {
-		return -1
+	if ans := slices.Max(dist); ans < inf {
+		return ans
 	}
-	return ans
-}
+	return -1
+
+}
+
+type pair struct{ x, i int }
+type hp []pair
+
+func (h hp) Len() int           { return len(h) }
+func (h hp) Less(i, j int) bool { return h[i].x < h[j].x }
+func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(x any)        { *h = append(*h, x.(pair)) }
+func (h *hp) Pop() (x any)      { a := *h; x = a[len(a)-1]; *h = a[:len(a)-1]; return }

solution/0700-0799/0743.Network Delay Time/Solution2.java

@@ -1,34 +1,31 @@
 class Solution {
-    private static final int INF = 0x3f3f;
-
     public int networkDelayTime(int[][] times, int n, int k) {
+        final int inf = 1 << 29;
         List<int[]>[] g = new List[n];
-        int[] dist = new int[n];
-        for (int i = 0; i < n; ++i) {
-            dist[i] = INF;
-            g[i] = new ArrayList<>();
-        }
-        for (int[] t : times) {
-            g[t[0] - 1].add(new int[] {t[1] - 1, t[2]});
+        Arrays.setAll(g, i -> new ArrayList<>());
+        for (var e : times) {
+            g[e[0] - 1].add(new int[] {e[1] - 1, e[2]});
         }
+        int[] dist = new int[n];
+        Arrays.fill(dist, inf);
         dist[k - 1] = 0;
-        PriorityQueue<int[]> q = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
-        q.offer(new int[] {0, k - 1});
-        while (!q.isEmpty()) {
-            int[] p = q.poll();
-            int u = p[1];
-            for (int[] ne : g[u]) {
-                int v = ne[0], w = ne[1];
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        pq.offer(new int[] {0, k - 1});
+        while (!pq.isEmpty()) {
+            var p = pq.poll();
+            int d = p[0], u = p[1];
+            if (d > dist[u]) {
+                continue;
+            }
+            for (var e : g[u]) {
+                int v = e[0], w = e[1];
                 if (dist[v] > dist[u] + w) {
                     dist[v] = dist[u] + w;
-                    q.offer(new int[] {dist[v], v});
+                    pq.offer(new int[] {dist[v], v});
                 }
             }
         }
-        int ans = 0;
-        for (int d : dist) {
-            ans = Math.max(ans, d);
-        }
-        return ans == INF ? -1 : ans;
+        int ans = Arrays.stream(dist).max().getAsInt();
+        return ans == inf ? -1 : ans;
     }
-}
+}

solution/0700-0799/0743.Network Delay Time/Solution2.py

@@ -1,17 +1,18 @@
 class Solution:
     def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
-        INF = 0x3F3F
-        g = defaultdict(list)
+        g = [[] for _ in range(n)]
         for u, v, w in times:
             g[u - 1].append((v - 1, w))
-        dist = [INF] * n
+        dist = [inf] * n
         dist[k - 1] = 0
-        q = [(0, k - 1)]
-        while q:
-            _, u = heappop(q)
+        pq = [(0, k - 1)]
+        while pq:
+            d, u = heappop(pq)
+            if d > dist[u]:
+                continue
             for v, w in g[u]:
-                if dist[v] > dist[u] + w:
-                    dist[v] = dist[u] + w
-                    heappush(q, (dist[v], v))
+                if (nd := d + w) < dist[v]:
+                    dist[v] = nd
+                    heappush(pq, (nd, v))
         ans = max(dist)
-        return -1 if ans == INF else ans
+        return -1 if ans == inf else ans