LeetCode-834. 树中距离之和

问题地址

LeetCode每日一题/2020-10-06

LeetCode834. 树中距离之和

问题描述

规则

给定一个无向、连通的树。树中有 N 个标记为 0…N-1 的节点以及 N-1 条边 。

第 i 条边连接节点 edges[i][0] 和 edges[i][1] 。

返回一个表示节点 i 与其他所有节点距离之和的列表 ans。

示例

• 示例1

输入: N = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
输出: [8,12,6,10,10,10]
解释: 
如下为给定的树的示意图：
  0
 / \
1   2
   /|\
  3 4 5
我们可以计算出 dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) 
也就是 1 + 1 + 2 + 2 + 2 = 8。 因此，answer[0] = 8，以此类推。

说明

• 1 <= N <= 10000

解析

解题思路

数据操作分析

• 见思路分析

复杂度分析

1. 时间复杂度
2. 空间复杂度

编码实现

官方解法

方法一：树形动态规划

思路与算法：

• 首先我们来考虑一个节点的情况，即每次题目指定一棵树，以 \textit{root} 为根，询问节点 \textit{root} 与其他所有节点的距离之和。
• 很容易想到一个树形动态规划：定义 \textit{dp}[u] 表示以 u 为根的子树，它的所有子节点到它的距离之和，同时定义 \textit{sz}[u] 表示以 u 为根的子树的节点数量，不难得出如下的转移方程：

\textit{dp}[u]=\sum_{v\in \textit{son}[u]}\textit{dp}[v] + \textit{sz}[v]

• 方程说明
  • 其中 \textit{son}[u] 表示 u 的所有后代节点集合。转移方程表示的含义就是考虑每个后代节点 v，已知 v 的所有子节点到它的距离之和为 \textit{dp}[v]，那么这些节点到 u 的距离之和还要考虑 u\rightarrow v 这条边的贡献。考虑这条边长度为 1，一共有 sz[v] 个节点到节点 u 的距离会包含这条边，因此贡献即为 1\times \textit{sz}[v]=\textit{sz}[v]。我们遍历整棵树，从叶子节点开始自底向上递推到根节点 \textit{root} 即能得出最后的答案为 \textit{dp}[\textit{root}]。
• 回到本题中，题目要求的其实是上题的扩展，即要求我们求出每个节点为根节点的时候，它与其他所有节点的距离之和。暴力的角度我们可以考虑对每个节点都做一次如上的树形动态规划，这样时间复杂度即为 O(N^2)，那么有没有更优雅的方法呢？
  • 经过一次树形动态规划后其实我们获得了在 u 为根的树中，每个节点为根的子树的答案 \textit{dp}，我们可以利用这些已有信息来优化时间复杂度。
  • 假设 u 的某个后代节点为 v，如果要算 v 的答案，本来我们要以 v 为根来进行一次树形动态规划。但是利用已有的信息，我们可以考虑树的形态做一次改变，让 v 换到根的位置，u 变为其孩子节点，同时维护原有的 \textit{dp} 信息。在这一次的转变中，我们观察到除了 u 和 v 的 \textit{dp} 值，其他节点的 \textit{dp} 值都不会改变，因此只要更新 \textit{dp}[u] 和 \textit{dp}[v] 的值即可。
  • 那么我们来看 v 换到根的位置的时候怎么利用已有信息求出 \textit{dp}[u] 和 \textit{dp}[v] 的值。重新回顾第一次树形动态规划的转移方程，我们可以知道当 u 变为 v 的孩子的时候 v 不在 u 的后代集合 \textit{son}[u] 中了，因此此时 \textit{dp}[u] 需要减去 v 的贡献，即

\textit{dp}[u]=\textit{dp}[u]-(\textit{dp}[v]+\textit{sz}[v])

• 接上：
  • 同时 \textit{sz}[u] 也要相应减去 \textit{sz}[v]。
  • 而 v 的后代节点集合中多出了 u，因此 \textit{dp}[v] 的值要由 u 更新上来， \textit{sz}[v] 也要相应加上 \textit{sz}[u]，即

\textit{dp}[v]=\textit{dp}[v]+(\textit{dp}[u]+\textit{sz}[u])

• 至此我们完成了一次「换根」操作，在 O(1) 的时间内维护了 \textit{dp} 的信息，且此时的树结构以 v 为根。那么接下来我们不断地进行换根的操作，即能在 O(N) 的时间内求出每个节点为根的答案，实现了时间复杂度的优化。
  

复杂度分析：

1. 时间复杂度:O(N)，其中 N 是树中的节点个数。我们只需要遍历整棵树两次即可得到答案，其中每个节点被访问两次，因此时间复杂度为 O(2N)=O(N)。
2. 空间复杂度：O(N)。我们需要线性的空间存图，N 个节点的树包含 N-1 条边，数组 \textit{dp} 和 \textit{sz} 的长度均为 N。

编码实现

class Solution {
    int[] ans;
    int[] sz;
    int[] dp;
    List<List<Integer>> graph;

    public int[] sumOfDistancesInTree(int N, int[][] edges) {
        ans = new int[N];
        sz = new int[N];
        dp = new int[N];
        graph = new ArrayList<List<Integer>>();
        for (int i = 0; i < N; ++i) {
            graph.add(new ArrayList<Integer>());
        }
        for (int[] edge: edges) {
            int u = edge[0], v = edge[1];
            graph.get(u).add(v);
            graph.get(v).add(u);
        }
        dfs(0, -1);
        dfs2(0, -1);
        return ans;
    }

    public void dfs(int u, int f) {
        sz[u] = 1;
        dp[u] = 0;
        for (int v: graph.get(u)) {
            if (v == f) {
                continue;
            }
            dfs(v, u);
            dp[u] += dp[v] + sz[v];
            sz[u] += sz[v];
        }
    }

    public void dfs2(int u, int f) {
        ans[u] = dp[u];
        for (int v: graph.get(u)) {
            if (v == f) {
                continue;
            }
            int pu = dp[u], pv = dp[v];
            int su = sz[u], sv = sz[v];

            dp[u] -= dp[v] + sz[v];
            sz[u] -= sz[v];
            dp[v] += dp[u] + sz[u];
            sz[v] += sz[u];

            dfs2(v, u);

            dp[u] = pu;
            dp[v] = pv;
            sz[u] = su;
            sz[v] = sv;
        }
    }
}

精彩评论

跳转地址1：「手画图解」树中距离之和 | 树形DP | 思路详解

思路：

– 如图，我们看节点 2，其他节点和它之间的距离和，可以分为两部分：
– 节点 2 所在的子树中的节点，与它的距离和。
– 子树之外的节点与它的距离和。
– 前者是一个子树内部的问题，我们寻找一下递归关系。
– 定义distSum[i]表示：节点i所在的子树中的节点到节点i的距离和。

• distSum[2]仅仅是它的子节点的distSum累加吗？不是的，还要算上走红色分支的次数。
  • 节点 2 到子树 3 中的节点，要走两次红色路径，因为子树 3 有两个节点。
  • 节点 2 到子树 4 中的节点，要走一次红色路径，因为子树 4 有一个节点。
  • 节点 2 到子树 5 中的节点，要走一次红色路径，因为子树 5 有一个节点。
• 因此还需要计算每个子树的节点个数nodeNum[i]，递归公式如下：

$$
nodeNum[root]=sum(nodeNum[child])+1 \\
distSum[root] = sum(nodeNum[child] + distSum[child])
$$

• 从上往下递归，到达底部就遇到「结果已知的 base case」，随着递归的出栈，结果不断向上返回，最后求出当前子树的 distSum。
• 什么时候结束递归呢，即，什么时候才算遇到 base case 呢？
  • 显然，我们需要遍历当前 root 节点的所有邻居，如果它的邻居只有它的父亲，说明它除了父亲，没有子节点，它就是 base case：nodeNum 为 1，distSum 为 0。
• 因为我们要遍历所有的邻居，所以需要构建邻接关系表：

const graph = new Array(N);
for (let i = 0; i < graph.length; i++) {
    graph[i] = [];
}
for (const edge of edges) {
    const [from, to] = edge;
    graph[from].push(to);
    graph[to].push(from);
}

• from bottom to top，由小的子树的结果，计算出大的子树的结果，即，在递归完当前节点的所有子树之后，再计算当前节点。在递归出栈时解决问题。因此，采用后序遍历：

const postOrder = (root, parent) => {
    const neighbors = graph[root]; // 与它相连的节点们
    for (const neighbor of neighbors) {
        if (neighbor == parent) {  // 如果邻居是自己父亲，跳过。
            continue;              // 如果邻居只有自己父亲，则for循环结束，当前递归结束  
        }
        postOrder(neighbor, root);
        nodeNum[root] += nodeNum[neighbor];
        distSum[root] += nodeNum[neighbor] + distSum[neighbor];
    }
};

• 此时的distSum数组，存放 root 到所在子树中的节点的距离和，显然，还要加上子树外的节点到 root 的距离和，才是最后的结果。
• 后者怎么求？不好求。需要求吗？其实不需要。
  • 我们看到，对整个树的根节点来说，它的distSum已经是正确的，因为，它的子树就是整棵树。
  • 我们这样：根据已知的对的distSum，自顶而下更新它下面的子节点的distSum。怎么利用已知的distSum[root]呢？
    
• 图，节点2所在的子树的节点个数为nodeNum[2]，从计算distSum[0]变成计算distSum[2]：从节点 0 到这些节点，变成从节点 2 到这些节点，这nodeNum[2]个节点，每个节点都少走了一步，一共少走了nodeNum[2]步。
• 子树以外的节点呢，有N – nodeNum[2]个，从计算distSum[0]变成计算distSum[2]：从节点 0 到这些节点，变成从节点 2 到这些节点，每个节点都多走了一步，一共多走了N-nodeNum[2]步。
• 因此，我们找到distSum[i]与distSum[root]之间的递推关系：

distSum[i] = distSum[root] – nodeNum[i] + (N – nodeNum[i])

• 这是从上往下计算，不是等到遇到底部的 base case 向上返回再计算。而是，在压栈前解决问题：递归当前节点的子树之前，就更新出当前节点的distSum，使之正确，在子递归中，它作为正确的父节点 distSum，递推出子节点的 distSum。因此采用前序遍历：

const preOrder = (root, parent) => {
    const neighbors = graph[root];
    for (const neighbor of neighbors) {
      if (neighbor == parent) {
        continue;
      }
      distSum[neighbor] = distSum[root] - nodeNum[neighbor] + (N - nodeNum[neighbor]);
      preOrder(neighbor, root);
    }
  };

• 可以看到，我们用了两次 DFS 搜索，前者是计算出每个子树的 nodeNum 和 distSum，后者是计算出真正的 distSum，即每个节点与「其他所有节点」的距离和，注意二者的区别。

const sumOfDistancesInTree = (N, edges) => {
  // 建立映射表，graph[i]：存放与节点i相连的所有节点
  const graph = new Array(N);
  for (let i = 0; i < graph.length; i++) {
    graph[i] = [];
  }
  for (const edge of edges) {
    const [from, to] = edge;
    graph[from].push(to);
    graph[to].push(from);
  }

  // distSum[i]：节点i到它所在子树的节点的距离和，后面更新为：节点i到其他所有节点的距离和
  const distSum = new Array(N).fill(0);
  // nodeNum[i]：节点i所在子树的节点个数，保底为1
  const nodeNum = new Array(N).fill(1);

  const postOrder = (root, parent) => {
    const neighbors = graph[root]; // 与它相连的节点们
    for (const neighbor of neighbors) {
      if (neighbor == parent) {    // 如果邻居是自己父亲，跳过。
        continue;                  // 如果邻居只有自己父亲，则for循环结束，当前递归结束  
      }
      postOrder(neighbor, root);
      nodeNum[root] += nodeNum[neighbor];
      distSum[root] += nodeNum[neighbor] + distSum[neighbor];
    }
  };

  const preOrder = (root, parent) => {
    const neighbors = graph[root];
    for (const neighbor of neighbors) {
      if (neighbor == parent) {
        continue;
      }
      distSum[neighbor] = distSum[root] - nodeNum[neighbor] + (N - nodeNum[neighbor]);
      preOrder(neighbor, root);
    }
  };

  postOrder(0, -1); // dfs的入口。因为N>=1，节点0肯定存在，就从节点0开始搜
  preOrder(0, -1);
  return distSum;
};

复盘总结

• 我们重复利用了distSum数组这个空间。它先是代表：节点到它所在子树的节点的距离和。后面就更新为：节点到其他所有节点的距离和。
• 当然，也可以开辟一个新的容器，毕竟它们两个是不同的定义。不开辟就节省了一点空间。
• 本题的突破口，依然是：总是关注子树，关注子树，递归解决，子树是一种重复的结构，适合用递归求解，这道题巧妙地将目标拆分为两部分：
  • 子树内的节点与 root 的距离和
  • 子树外的节点与 root 的距离和
• 用递归求解前者，这是主旋律，后者不用特地求，因为我们有一个已知的，正确的 distSum，利用递推公式，往下递推出每个节点的正确的 distSum，就像沿着一棵树在填表，这就是树形DP。