|
86 | 86 |
|
87 | 87 | <!-- 这里可写通用的实现逻辑 --> |
88 | 88 |
|
| 89 | +**方法一:二进制枚举 + Floyd 算法** |
| 90 | + |
| 91 | +我们注意到 $n \leq 10,ドル所以我们不妨考虑使用二进制枚举的方法来枚举所有的分部集合。 |
| 92 | + |
| 93 | +对于每个分部集合,我们可以使用 Floyd 算法来计算出剩余分部之间的最短距离,然后判断是否满足题目要求即可。具体地,我们先枚举中间点 $k,ドル再枚举起点 $i$ 和终点 $j,ドル如果 $g[i][k] + g[k][j] \lt g[i][j],ドル那么我们就用更短的距离 $g[i][k] + g[k][j]$ 更新 $g[i][j]$。 |
| 94 | + |
| 95 | +时间复杂度 $O(2^n \times (n^3 + m)),ドル空间复杂度 $O(n^2)$。其中 $n$ 和 $m$ 分别是分部数量和道路数量。 |
| 96 | + |
89 | 97 | <!-- tabs:start --> |
90 | 98 |
|
91 | 99 | ### **Python3** |
92 | 100 |
|
93 | 101 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
94 | 102 |
|
95 | 103 | ```python |
96 | | - |
| 104 | +class Solution: |
| 105 | + def numberOfSets(self, n: int, maxDistance: int, roads: List[List[int]]) -> int: |
| 106 | + ans = 0 |
| 107 | + for mask in range(1 << n): |
| 108 | + g = [[inf] * n for _ in range(n)] |
| 109 | + for u, v, w in roads: |
| 110 | + if mask >> u & 1 and mask > v & 1: |
| 111 | + g[u][v] = min(g[u][v], w) |
| 112 | + g[v][u] = min(g[v][u], w) |
| 113 | + for k in range(n): |
| 114 | + if mask >> k & 1: |
| 115 | + g[k][k] = 0 |
| 116 | + for i in range(n): |
| 117 | + for j in range(n): |
| 118 | + # g[i][j] = min(g[i][j], g[i][k] + g[k][j]) |
| 119 | + if g[i][k] + g[k][j] < g[i][j]: |
| 120 | + g[i][j] = g[i][k] + g[k][j] |
| 121 | + if all( |
| 122 | + g[i][j] <= maxDistance |
| 123 | + for i in range(n) |
| 124 | + for j in range(n) |
| 125 | + if mask >> i & 1 and mask >> j & 1 |
| 126 | + ): |
| 127 | + ans += 1 |
| 128 | + return ans |
97 | 129 | ``` |
98 | 130 |
|
99 | 131 | ### **Java** |
100 | 132 |
|
101 | 133 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
102 | 134 |
|
103 | 135 | ```java |
104 | | - |
| 136 | +class Solution { |
| 137 | + public int numberOfSets(int n, int maxDistance, int[][] roads) { |
| 138 | + int ans = 0; |
| 139 | + for (int mask = 0; mask < 1 << n; ++mask) { |
| 140 | + int[][] g = new int[n][n]; |
| 141 | + for (var e : g) { |
| 142 | + Arrays.fill(e, 1 << 29); |
| 143 | + } |
| 144 | + for (var e : roads) { |
| 145 | + int u = e[0], v = e[1], w = e[2]; |
| 146 | + if ((mask >> u & 1) == 1 && (mask >> v & 1) == 1) { |
| 147 | + g[u][v] = Math.min(g[u][v], w); |
| 148 | + g[v][u] = Math.min(g[v][u], w); |
| 149 | + } |
| 150 | + } |
| 151 | + for (int k = 0; k < n; ++k) { |
| 152 | + if ((mask >> k & 1) == 1) { |
| 153 | + g[k][k] = 0; |
| 154 | + for (int i = 0; i < n; ++i) { |
| 155 | + for (int j = 0; j < n; ++j) { |
| 156 | + g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]); |
| 157 | + } |
| 158 | + } |
| 159 | + } |
| 160 | + } |
| 161 | + int ok = 1; |
| 162 | + for (int i = 0; i < n && ok == 1; ++i) { |
| 163 | + for (int j = 0; j < n && ok == 1; ++j) { |
| 164 | + if ((mask >> i & 1) == 1 && (mask >> j & 1) == 1) { |
| 165 | + if (g[i][j] > maxDistance) { |
| 166 | + ok = 0; |
| 167 | + } |
| 168 | + } |
| 169 | + } |
| 170 | + } |
| 171 | + ans += ok; |
| 172 | + } |
| 173 | + return ans; |
| 174 | + } |
| 175 | +} |
105 | 176 | ``` |
106 | 177 |
|
107 | 178 | ### **C++** |
108 | 179 |
|
109 | 180 | ```cpp |
110 | | - |
| 181 | +class Solution { |
| 182 | +public: |
| 183 | + int numberOfSets(int n, int maxDistance, vector<vector<int>>& roads) { |
| 184 | + int ans = 0; |
| 185 | + for (int mask = 0; mask < 1 << n; ++mask) { |
| 186 | + int g[n][n]; |
| 187 | + memset(g, 0x3f, sizeof(g)); |
| 188 | + for (auto& e : roads) { |
| 189 | + int u = e[0], v = e[1], w = e[2]; |
| 190 | + if ((mask >> u & 1) & (mask >> v & 1)) { |
| 191 | + g[u][v] = min(g[u][v], w); |
| 192 | + g[v][u] = min(g[v][u], w); |
| 193 | + } |
| 194 | + } |
| 195 | + for (int k = 0; k < n; ++k) { |
| 196 | + if (mask >> k & 1) { |
| 197 | + g[k][k] = 0; |
| 198 | + for (int i = 0; i < n; ++i) { |
| 199 | + for (int j = 0; j < n; ++j) { |
| 200 | + g[i][j] = min(g[i][j], g[i][k] + g[k][j]); |
| 201 | + } |
| 202 | + } |
| 203 | + } |
| 204 | + } |
| 205 | + int ok = 1; |
| 206 | + for (int i = 0; i < n && ok == 1; ++i) { |
| 207 | + for (int j = 0; j < n && ok == 1; ++j) { |
| 208 | + if ((mask >> i & 1) & (mask >> j & 1) && g[i][j] > maxDistance) { |
| 209 | + ok = 0; |
| 210 | + } |
| 211 | + } |
| 212 | + } |
| 213 | + ans += ok; |
| 214 | + } |
| 215 | + return ans; |
| 216 | + } |
| 217 | +}; |
111 | 218 | ``` |
112 | 219 | |
113 | 220 | ### **Go** |
114 | 221 | |
115 | 222 | ```go |
| 223 | +func numberOfSets(n int, maxDistance int, roads [][]int) (ans int) { |
| 224 | + for mask := 0; mask < 1<<n; mask++ { |
| 225 | + g := make([][]int, n) |
| 226 | + for i := range g { |
| 227 | + g[i] = make([]int, n) |
| 228 | + for j := range g[i] { |
| 229 | + g[i][j] = 1 << 29 |
| 230 | + } |
| 231 | + } |
| 232 | + for _, e := range roads { |
| 233 | + u, v, w := e[0], e[1], e[2] |
| 234 | + if mask>>u&1 == 1 && mask>>v&1 == 1 { |
| 235 | + g[u][v] = min(g[u][v], w) |
| 236 | + g[v][u] = min(g[v][u], w) |
| 237 | + } |
| 238 | + } |
| 239 | + for k := 0; k < n; k++ { |
| 240 | + if mask>>k&1 == 1 { |
| 241 | + g[k][k] = 0 |
| 242 | + for i := 0; i < n; i++ { |
| 243 | + for j := 0; j < n; j++ { |
| 244 | + g[i][j] = min(g[i][j], g[i][k]+g[k][j]) |
| 245 | + } |
| 246 | + } |
| 247 | + } |
| 248 | + } |
| 249 | + ok := 1 |
| 250 | + for i := 0; i < n && ok == 1; i++ { |
| 251 | + for j := 0; j < n && ok == 1; j++ { |
| 252 | + if mask>>i&1 == 1 && mask>>j&1 == 1 && g[i][j] > maxDistance { |
| 253 | + ok = 0 |
| 254 | + } |
| 255 | + } |
| 256 | + } |
| 257 | + ans += ok |
| 258 | + } |
| 259 | + return |
| 260 | +} |
| 261 | +``` |
116 | 262 |
|
| 263 | +### **TypeScript** |
| 264 | + |
| 265 | +```ts |
| 266 | +function numberOfSets(n: number, maxDistance: number, roads: number[][]): number { |
| 267 | + let ans = 0; |
| 268 | + for (let mask = 0; mask < 1 << n; ++mask) { |
| 269 | + const g: number[][] = Array.from({ length: n }, () => Array(n).fill(Infinity)); |
| 270 | + for (const [u, v, w] of roads) { |
| 271 | + if ((mask >> u) & 1 && (mask >> v) & 1) { |
| 272 | + g[u][v] = Math.min(g[u][v], w); |
| 273 | + g[v][u] = Math.min(g[v][u], w); |
| 274 | + } |
| 275 | + } |
| 276 | + for (let k = 0; k < n; ++k) { |
| 277 | + if ((mask >> k) & 1) { |
| 278 | + g[k][k] = 0; |
| 279 | + for (let i = 0; i < n; ++i) { |
| 280 | + for (let j = 0; j < n; ++j) { |
| 281 | + g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]); |
| 282 | + } |
| 283 | + } |
| 284 | + } |
| 285 | + } |
| 286 | + let ok = 1; |
| 287 | + for (let i = 0; i < n && ok; ++i) { |
| 288 | + for (let j = 0; j < n && ok; ++j) { |
| 289 | + if ((mask >> i) & 1 && (mask >> j) & 1 && g[i][j] > maxDistance) { |
| 290 | + ok = 0; |
| 291 | + } |
| 292 | + } |
| 293 | + } |
| 294 | + ans += ok; |
| 295 | + } |
| 296 | + return ans; |
| 297 | +} |
117 | 298 | ``` |
118 | 299 |
|
119 | 300 | ### **...** |
|
0 commit comments