字节跳动bytecamp夏令营在线笔试编程题2

第二题忘了题目是什么了，反正个人感觉只是返回’True’或者’False’的话，估计直接return一个也能过很多case了吧。给出第一题和第三题的解法。
脱离了他给的环境，所以js没办法用getline和print来模拟输入输出。
还是不吐槽为什么不用子函数形式来出题了，习惯了。

// bytedance-q1
function BinaryTree(left = null, right = null) {
  this.left = left
  this.right = right
}
let root = new BinaryTree()
function createTree(root, b, w, layer) {
  // left->black, right->white
  if(b >= layer) {
    let left = new BinaryTree()
    root.left = left
    createTree(left, b - layer, w, layer + 1)
  }
  if(w >= layer) {
    let right = new BinaryTree()
    root.right = right
    createTree(right, b, w - layer, layer + 1)
  }
  if(layer === maxLayer + 1) {
    n++
  }
  else if(layer > maxLayer + 1) {
    maxLayer = layer - 1
    n = 1
  }
}
let maxLayer = 0, n = 0
createTree(root, 9, 6, 1)
console.log('maxLayer:', maxLayer, 'n:', n)

第一题直接用树穷举所有情况，性能做了一下小小的优化，建树的时候直接统计了最大层数和种类，就不用再去遍历了。

// bytedance-q3
const n = 6, q = 6
let tree = []
for(let i = 0; i < n + 1; i++) {
  tree.push({})
}
const val_arr = [1, 2, 3, 4, 5, 6]
for(let i = 1; i <= n; i++) {
  tree[i].val = val_arr[i - 1]
  tree[i].children = []
}
const relation = [[
  1, 2, 'q'
], [
  1, 3, 'q'
], [
  3, 4, 'a'
], [
  3, 5, 'a'
], [
  3, 6, 'a'
]]
for(let i = 0; i < n - 1; i++) {
  let root = relation[i][0]
  let child = relation[i][1]
  tree[root].children.push(child)
  tree[child].flag = relation[i][2]
}
for(let i = 1; i <= n; i++) {
  let children = tree[i].children
  let sec = true
  if(children.length === 0) {
    sec = false
  }
  for(let child of children) {
    if(tree[child].children.length !== 0) {
      sec = false
      break
    } 
  }
  if(sec) {
    tree[i].sec = true
  }
  else {
    tree[i].sec = false
  }
  
}
const qArray = [1, 2, 3, 4, 5, 6]
for(let q of qArray) {
  console.log(getMax(q))
}
function getMax(root) {
  if(tree[root].children.length === 0) {
    return tree[root].val
  }
  if(tree[root].sec){
    let children = tree[root].children
    let sum = 0
    for(let child of children) {
      sum += getMax(child)
    }
    return sum
  }
  else {
    let children = tree[root].children
    let max = 0
    for(let child of children) {
      const cur = getMax(child)
      if(max < cur) {
        max = cur
      } 
    }
    return max
  }
}

第三题，以我的思路来说是，倒数第一层的结果就是自己的值，倒数第二层的节点，其值为其孩子值之和。其余的节点，值为其孩子中最大的那一分支。
这里可以做性能优化，用个MAP缓存已经获得的节点的result，因为父节点的值取决于子节点嘛，但是懒得搞了哈哈哈，知道能这么做就行。