863. All Nodes Distance K in Binary Tree

问题：

给定一棵二叉树。

求给定节点target开始，距离K的所有节点。

Example 1:
Input: root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2
Output: [7,4,1]
Explanation: 
The nodes that are a distance 2 from the target node (with value 5)
have values 7, 4, and 1.

Note that the inputs "root" and "target" are actually TreeNodes.
The descriptions of the inputs above are just serializations of these objects.
 

Note:
The given tree is non-empty.
Each node in the tree has unique values 0 <= node.val <= 500.
The target node is a node in the tree.
0 <= K <= 1000.

　　

解法：DFS+BFS

思想：

• 首先找到target节点，
  • 由于需要其父节点路径，因此使用->DFS
• 对当前target节点：
  • 向下：遍历找到距离层次为K的所有子节点->BFS
  • 向上：每上一层父节点，K--，从其父节点再向下：遍历找到距离层次为K的所有子节点->BFS
    • 如果K==0，那么只需返回父节点即可，无需继续从该父节点继续向下展开。

⚠️ 注意：对于每个父节点，需要知道的信息为自己应该向下遍历的K应该是多少。

因此DFS返回K值。

• DFS的状态为：
  • 当前节点root
• BFS的状态为：
  • 当前节点root，展开层数K

代码参考：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void bfs(vector<int>& res, TreeNode* root, int K) {
        queue<TreeNode*> q;
        q.push(root);
        if(K<0) return;
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                TreeNode* cur = q.front();
                q.pop();
                if(K==0) res.push_back(cur->val);
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
            if(K==0) return;
            K--;
        }
        return;
    }
    int dfs(vector<int>& res, TreeNode* root, TreeNode* target, int K) {
        if(!root) return INT_MAX;
        int left = INT_MAX, right = INT_MAX;
        if(root->val == target->val) {
            bfs(res, root, K);
            return K-1;
        } else {
            if(root->left) left = dfs(res, root->left, target, K);
            if(left==INT_MAX && root->right) right = dfs(res, root->right, target, K);
        }
        if(left!=INT_MAX) {
            if(left==0)res.push_back(root->val);
            else if(root->right) bfs(res, root->right, left-1);
            return left-1;
        } else if(right!=INT_MAX) {
            if(right==0)res.push_back(root->val);
            else if(root->left)bfs(res, root->left, right-1);
            return right-1;
        }
        return INT_MAX;
    }
    vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
        vector<int> res;
        dfs(res, root, target, K);
        return res;
    }
};