feat: add solutions to lc problem: No.2473

No.2473.Minimum Cost to Buy Apples

Author: yanglbme

solution/0700-0799/0766.Toeplitz Matrix/Solution.py

@@ -1,4 +1,8 @@
 class Solution:
     def isToeplitzMatrix(self, matrix: List[List[int]]) -> bool:
         m, n = len(matrix), len(matrix[0])
-        return all(matrix[i][j] == matrix[i - 1][j - 1] for i in range(1, m) for j in range(1, n))
+        return all(
+            matrix[i][j] == matrix[i - 1][j - 1]
+            for i in range(1, m)
+            for j in range(1, n)
+        )

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/Solution.py

@@ -16,4 +16,6 @@ def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
             if stk:
                 r[i] = stk[-1]
             stk.append(i)
-        return sum((i - l[i]) * (r[i] - i) for i, v in enumerate(nums) if left <= v <= right)
+        return sum(
+            (i - l[i]) * (r[i] - i) for i, v in enumerate(nums) if left <= v <= right
+        )

solution/2400-2499/2467.Most Profitable Path in a Tree/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def mostProfitablePath(self, edges: List[List[int]], bob: int, amount: List[int]) -> int:
+    def mostProfitablePath(
+        self, edges: List[List[int]], bob: int, amount: List[int]
+    ) -> int:
         def dfs1(i, fa, t):
             if i == 0:
                 ts[i] = min(ts[i], t)

solution/2400-2499/2468.Split Message Based on Limit/Solution.py

@@ -11,7 +11,7 @@ def splitMessage(self, message: str, limit: int) -> List[str]:
                 i = 0
                 for j in range(1, k + 1):
                     tail = f'<{j}/{k}>'
-                    t = message[i: i + limit - len(tail)] + tail
+                    t = message[i : i + limit - len(tail)] + tail
                     ans.append(t)
                     i += limit - len(tail)
                 return ans

solution/2400-2499/2473.Minimum Cost to Buy Apples/README.md

@@ -54,22 +54,208 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：堆优化版 Dijkstra 算法**
+
+我们枚举起点，对于每个起点，使用 Dijkstra 算法求出到其他所有点的最短距离，更新最小值即可。
+
+时间复杂度 $O(n \times m \times \log m)$，其中 $n$ 和 $m$ 分别是城市数量和道路数量。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def minCost(self, n: int, roads: List[List[int]], appleCost: List[int], k: int) -> List[int]:
+        def dijkstra(i):
+            q = [(0, i)]
+            dist = [inf] * n
+            dist[i] = 0
+            ans = inf
+            while q:
+                d, u = heappop(q)
+                ans = min(ans, appleCost[u] + d * (k + 1))
+                for v, w in g[u]:
+                    if dist[v] > dist[u] + w:
+                        dist[v] = dist[u] + w
+                        heappush(q, (dist[v], v))
+            return ans
 
+        g = defaultdict(list)
+        for a, b, c in roads:
+            a, b = a - 1, b - 1
+            g[a].append((b, c))
+            g[b].append((a, c))
+        return [dijkstra(i) for i in range(n)]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int k;
+    private int[] cost;
+    private int[] dist;
+    private List<int[]>[] g;
+    private static final int INF = 0x3f3f3f3f;
+
+    public long[] minCost(int n, int[][] roads, int[] appleCost, int k) {
+        cost = appleCost;
+        g = new List[n];
+        dist = new int[n];
+        this.k = k;
+        for (int i = 0; i < n; ++i) {
+            g[i] = new ArrayList<>();
+        }
+        for (var e : roads) {
+            int a = e[0] - 1, b = e[1] - 1, c = e[2];
+            g[a].add(new int[] {b, c});
+            g[b].add(new int[] {a, c});
+        }
+        long[] ans = new long[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = dijkstra(i);
+        }
+        return ans;
+    }
+
+    private long dijkstra(int u) {
+        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+        q.offer(new int[] {0, u});
+        Arrays.fill(dist, INF);
+        dist[u] = 0;
+        long ans = Long.MAX_VALUE;
+        while (!q.isEmpty()) {
+            var p = q.poll();
+            int d = p[0];
+            u = p[1];
+            ans = Math.min(ans, cost[u] + (long) (k + 1) * d);
+            for (var ne : g[u]) {
+                int v = ne[0], w = ne[1];
+                if (dist[v] > dist[u] + w) {
+                    dist[v] = dist[u] + w;
+                    q.offer(new int[] {dist[v], v});
+                }
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+using ll = long long;
+using pii = pair<int, int>;
+
+class Solution {
+public:
+    const int inf = 0x3f3f3f3f;
+
+    vector<long long> minCost(int n, vector<vector<int>>& roads, vector<int>& appleCost, int k) {
+        vector<vector<pii>> g(n);
+        for (auto& e : roads) {
+            int a = e[0] - 1, b = e[1] - 1, c = e[2];
+            g[a].push_back({b, c});
+            g[b].push_back({a, c});
+        }
+        int dist[n];
+        auto dijkstra = [&](int u) {
+            memset(dist, 63, sizeof dist);
+            priority_queue<pii, vector<pii>, greater<pii>> q;
+            q.push({0, u});
+            dist[u] = 0;
+            ll ans = LONG_MAX;
+            while (!q.empty()) {
+                auto p = q.top();
+                q.pop();
+                int d = p.first;
+                u = p.second;
+                ans = min(ans, appleCost[u] + 1ll * d * (k + 1));
+                for (auto& ne : g[u]) {
+                    auto [v, w] = ne;
+                    if (dist[v] > dist[u] + w) {
+                        dist[v] = dist[u] + w;
+                        q.push({dist[v], v});
+                    }
+                }
+            }
+            return ans;
+        };
+        vector<ll> ans(n);
+        for (int i = 0; i < n; ++i) ans[i] = dijkstra(i);
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func minCost(n int, roads [][]int, appleCost []int, k int) []int64 {
+	g := make([]pairs, n)
+	for _, e := range roads {
+		a, b, c := e[0]-1, e[1]-1, e[2]
+		g[a] = append(g[a], pair{b, c})
+		g[b] = append(g[b], pair{a, c})
+	}
+	const inf int = 0x3f3f3f3f
+	dist := make([]int, n)
+	dijkstra := func(u int) int64 {
+		var ans int64 = math.MaxInt64
+		for i := range dist {
+			dist[i] = inf
+		}
+		dist[u] = 0
+		q := make(pairs, 0)
+		heap.Push(&q, pair{0, u})
+		for len(q) > 0 {
+			p := heap.Pop(&q).(pair)
+			d := p.first
+			u = p.second
+			ans = min(ans, int64(appleCost[u]+d*(k+1)))
+			for _, ne := range g[u] {
+				v, w := ne.first, ne.second
+				if dist[v] > dist[u]+w {
+					dist[v] = dist[u] + w
+					heap.Push(&q, pair{dist[v], v})
+				}
+			}
+		}
+		return ans
+	}
+	ans := make([]int64, n)
+	for i := range ans {
+		ans[i] = dijkstra(i)
+	}
+	return ans
+}
+
+func min(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+type pair struct{ first, 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 interface{}) { *a = append(*a, x.(pair)) }
+func (a *pairs) Pop() interface{}   { l := len(*a); t := (*a)[l-1]; *a = (*a)[:l-1]; return t }
 ```
 
 ### **TypeScript**