1483. 树节点的第 K 个祖先

给你一棵树，树上有 n 个节点，按从 0 到 n-1 编号。树以父节点数组的形式给出，其中 parent[i] 是节点 i 的父节点。树的根节点是编号为 0 的节点。

树节点的第 k 个祖先节点是从该节点到根节点路径上的第 k 个节点。

实现 TreeAncestor 类：

• TreeAncestor（int n， int[] parent） 对树和父数组中的节点数初始化对象。
• getKthAncestor(int node, int k) 返回节点 node 的第 k 个祖先节点。如果不存在这样的祖先节点，返回 -1 。
• 示例 1：

• 

  输入：
  ["TreeAncestor","getKthAncestor","getKthAncestor","getKthAncestor"]
  [[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]
  
  输出：
  [null,1,0,-1]
  
  解释：
  TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
  
  treeAncestor.getKthAncestor(3, 1);  // 返回 1 ，它是 3 的父节点
  treeAncestor.getKthAncestor(5, 2);  // 返回 0 ，它是 5 的祖父节点
  treeAncestor.getKthAncestor(6, 3);  // 返回 -1 因为不存在满足要求的祖先节点
  

  提示：

• 1 <= k <= n <= 5 * 104
• parent[0] == -1 表示编号为 0 的节点是根节点。
• 对于所有的 0 < i < n ，0 <= parent[i] < n 总成立
• 0 <= node < n
• 至多查询 5 * 104 次

题解：

// [-1,0,0,1,1,2,2]

// dp[0][dp[0][0]] = -1;dp[0][2]=parent[dp[0][1]] = -1;dp[0][3] = -1;dp[0][4]=-1;

// dp[1][0] = 1;dp[1][1] = parent[dp[1][0]] = 0;dp[1][2] =parent[dp[1][1]]=-1;...........

// dp[i][j]表示从i节点跳j步到达的节点

class TreeAncestor {
    int[][] dp;

    public TreeAncestor(int n, int[] parent) {
        dp = new int[n][n+1];

		// [-1,0,0,1,1,2,2]
		// dp[0][dp[0][0]] = -1;dp[0][2]=parent[dp[0][1]] = -1;dp[0][3] = -1;dp[0][4]=-1;
		// dp[1][0] = 1;dp[1][1] = parent[dp[1][0]] = 0;dp[1][2] = parent[dp[1][1]]=-1;...........
		//dp[i][j]表示从i节点跳j步到达的节点
		for (int i = 0; i < n; i++) {
			dp[i][0] = i;
			for (int j = 1; j < n+1; j++) {
				if (dp[i][j - 1] != -1) {
					dp[i][j] = parent[dp[i][j - 1]];
				} else {
					dp[i][j] = -1;
				}
			}
		}
    }
    
    public int getKthAncestor(int node, int k) {
        return dp[node][k];
    }
}

/**
 * Your TreeAncestor object will be instantiated and called as such:
 * TreeAncestor obj = new TreeAncestor(n, parent);
 * int param_1 = obj.getKthAncestor(node,k);
 */

在此超过内存限制

在这里，不需要去枚举每一个的跳数，我们可以每一跳选择一定的步数，然后多跳几步，这样可以节省空间。我们知道，任何一个数都能通过二进制进行表示，例如5->101。然后，我们就可以把这个数跳1，然后将这个数改为跳1步的数，此时，将二进制数变为100。在选择最右边的1，跳1步， 然后将这个数改为跳1步的数，此时二进制的数变为0，结束循环。

class TreeAncestor {
    int[][] dp;

    public TreeAncestor(int n, int[] parent) {
        int k = (int) (Math.log(n) / Math.log(2) + 1);
		dp = new int[n][k+1];

		for (int i = 0; i < n; i++) {
			dp[i][0] = i;
			dp[i][1] = parent[i];
		}


        for (int j = 2; j <= k; j++) {
			for (int i = 0; i < n; i++) {
				if (dp[i][j - 1] != -1) {
					dp[i][j] = dp[dp[i][j - 1]][j - 1];
				} else {
					dp[i][j] = -1;
				}
			}
		}
        //System.out.println(Arrays.deepToString(dp));
    }
    
    public int getKthAncestor(int node, int k) {
        while (k != 0) {
			int number = Integer.numberOfTrailingZeros(k);
			node = dp[node][number+1];
			if (node == -1)
				break;
			k &= ~(1 << number);
		}
		return node;
    }
}

/**
 * Your TreeAncestor object will be instantiated and called as such:
 * TreeAncestor obj = new TreeAncestor(n, parent);
 * int param_1 = obj.getKthAncestor(node,k);
 */