从零学算法1334

1334 .阈值距离内邻居最少的城市

有 n 个城市，按从 0 到 n-1 编号。给你一个边数组 edges，其中 edges $i$ = $fromi, toi, weighti$ 代表 fromi 和 toi 两个城市之间的双向加权边，距离阈值是一个整数 distanceThreshold。

返回在路径距离限制为 distanceThreshold 以内可到达城市最少的城市。如果有多个这样的城市，则返回编号最大的城市。

注意，连接城市 i 和 j 的路径的距离等于沿该路径的所有边的权重之和。

示例 1：

输入：n = 4, edges = $\[0,1,3$ , $1,2,1$ , $1,3,4$ , $2,3,1$ ], distanceThreshold = 4

输出：3

解释：城市分布图如上。

每个城市阈值距离 distanceThreshold = 4 内的邻居城市分别是：

城市 0 -> $城市 1, 城市 2$

城市 1 -> $城市 0, 城市 2, 城市 3$

城市 2 -> $城市 0, 城市 1, 城市 3$

城市 3 -> $城市 1, 城市 2$

城市 0 和 3 在阈值距离 4 以内都有 2 个邻居城市，但是我们必须返回城市 3，因为它的编号最大。

示例 2：

输入：n = 5, edges = $\[0,1,2$ , $0,4,8$ , $1,2,3$ , $1,4,2$ , $2,3,1$ , $3,4,1$ ], distanceThreshold = 2

输出：0

解释：城市分布图如上。

每个城市阈值距离 distanceThreshold = 2 内的邻居城市分别是：

城市 0 -> $城市 1$

城市 1 -> $城市 0, 城市 4$

城市 2 -> $城市 3, 城市 4$

城市 3 -> $城市 2, 城市 4$

城市 4 -> $城市 1, 城市 2, 城市 3$

城市 0 在阈值距离 2 以内只有 1 个邻居城市。

提示：

2 <= n <= 100

1 <= edges.length <= n * (n - 1) / 2

edges $i$ .length == 3

0 <= fromi < toi < n

1 <= weighti, distanceThreshold <= 10^4

所有 (fromi, toi) 都是不同的。

主逻辑很简单，从 0 ~ n-1 计算每个城市的相邻城市个数，有多个时取编号最大的，难点在于计算某个城市的相邻城市个数
首先肯定要根据 edges 记录每个城市的相连情况，可以用哈希表 map 记录
从一个城市出发后，我们可以通过相连的边去往其他城市（前提是没到达阈值 distanceThreshold），同时到达过的城市（阈值范围内相邻的城市）在之后再到达不该重复计算，所以用一个数组记录城市的到达情况。到达一个城市后，又可以通过相连的边去往其他城市...所以用递归来解决
从不同的路径到达同一个城市，此时剩余权重的情况可能不同，所以我们递归时不能简单地判断如果到达过某个城市就不再过去，而是根据剩余权重来判断：如果到达该城市时剩余的权重比之前的路径剩余的更多，那应该再尝试一下此时的路径
- 比如有两条路能从城市1到城市4，一条路权重和为3，另一条和为5，而阈值为5，当我们递归时先走了和为5的路，之后还应该尝试走和为3的路，这样可能还能从城市4去往新的城市

js 复制代码

  var findTheCity = function (n, edges, distanceThreshold) {
      const map = {}
      for (let e of edges) {
          if (!map[e[0]]) map[e[0]] = {}
          if (!map[e[1]]) map[e[1]] = {}
          map[e[0]][e[1]] = e[2]
          map[e[1]][e[0]] = e[2]
      }
      const getCount = (i, t) => {
          // 相邻城市个数
          let count = 0
          // visited[i]:到达城市i时剩余可用权重
          // visited[i]=-1：没到达过该城市
          const visited = new Array(n).fill(-1)
          // 作为起点的自身不算自己的相邻城市
          visited[i] = t
          const getRes = (i, t) => {
              // 城市 i 直接相连的城市
              const neighbor = i in map ? map[i] : {}
              for (let city of Object.keys(neighbor)) {
                  // 剩余权重
                  const remain = t - neighbor[city]
                  if (remain < 0) continue
                  if (remain < visited[city]) continue
                  if (visited[city] === -1) {
                      count++
                  }
                  visited[city] = remain
                  getRes(city, t - neighbor[city])
              }
          }
          getRes(i, t)
          return count
      }
      let ans = 0
      let count = Number.MAX_VALUE
      for (let i = 0; i < n; i++) {
          const c = getCount(i, distanceThreshold)
          if (c < count || (c === count && i > ans)) {
              ans = i
              count = c
          }
      }
      return ans
  };