30 天刷题挑战（十六）

贝蕾亚2023-10-14 22:57

841. 钥匙和房间

思路

广度优先算法，使用一个 Set 记录访问过的房间，使用队列 queue 先进先出的特性依次遍历每一个房间，最后判断 Set 的大小是否等于房间数。

代码

js 复制代码

/**
 * @param {number[][]} rooms
 * @return {boolean}
 */
var canVisitAllRooms = function(rooms) {
  const visited = new Set()
  const queue = []

  queue.push(0)
  visited.add(0)

  while(queue.length) {
    let nextRooms = rooms[queue.shift()]
   
    for(let i = 0; i < nextRooms.length; i++) {
      const r = nextRooms[i]

      if (!visited.has(r)) {
        queue.push(r)
        visited.add(r)
      }
    }
  }

  return visited.size === rooms.length
};

547. 省份数量

思路

广度优先算法，使用一个 Set 记录没被访问的城市，每个城市都能被访问的时候省份加一。

代码

ini 复制代码

/**
 * @param {string[][]} equations
 * @param {number[]} values
 * @param {string[][]} queries
 * @return {number[]}
 */
var calcEquation = function(equations, values, queries) {
  const map = new Map()     // 存储顶点和它的边
  const visited = new Map() // 缓存
  const res = []

  const dfs = (src ,dst) => {
    if (src === dst) {
      return 1.0
    }

    let adjs = map.get(src)

    for (let i = 0; i < adjs.length; i++) {
      let next = adjs[i]

      if (!visited.get(next[0])) {
        visited.set(next[0], true)

        let ret = dfs(next[0], dst)

        visited.set(next[0], false)

        if (ret !== -1.0) {
          return next[1] *ret
        }
      }
    }

    return -1.0
  }
  

  for (let i = 0; i < equations.length; ++i) {
    let e = equations[i]
    let v = values[i]
   
    if (!map.has(e[0])) {
      map.set(e[0], [])
      visited.set(e[0], false)
    }

    if (!map.has(e[1])) {
      map.set(e[1], [])
      visited.set(e[1], false)
    }

    let adj1 = map.get(e[0])
    let adj2 = map.get(e[1])
    adj1.push([e[1], v])
    adj2.push([e[0],  1 / v])
  }

  for (let q of queries) {
    let n0 = q[0]
    let n1 = q[1]

     if (map.has(n0) && map.has(n1)) {
       visited.set(n0, true)
       res.push(dfs(n0, n1))
       visited.set(n0, false)
     } else {
       res.push(-1.0)
     }
  }

 return res
};

本文完，感谢阅读。