Leetcode 第 120 场周赛----在二叉树中分配硬币

给定一个有 N 个结点的二叉树的根结点 root，树中的每个结点上都对应有 node.val 枚硬币，并且总共有 N 枚硬币。

在一次移动中，我们可以选择两个相邻的结点，然后将一枚硬币从其中一个结点移动到另一个结点。(移动可以是从父结点到子结点，或者从子结点移动到父结点。)。

返回使每个结点上只有一枚硬币所需的移动次数。

原题链接：

在二叉树中分配硬币

 

解题思路：

小白为了练手，每周参加一次leetcode的竞赛，接题思路简单粗暴，望有更好的解题思路交流：

这道题我采用的是从上到下逐层计算需要移动的硬币数（左右子树各自的money和各自的总节点数的差）的办法，依次计算每一层左右子结点需要移动的硬币次数，然后递归当前节点的左右节点，把移动次数相加即可。

每遍历一个节点，需要判断的条件如下:

注意每个条件下左右子结点是否为空的判断。

其实算法相当简单粗暴emmm，不细心很容易出错，具体看下面的代码

 

AC代码如下：

/**
 * 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:
    
    int checkMoney(TreeNode* root, int money){ // 递归计算当前结点的左右子树各自的money
        money+=root->val;
        
        if(root->left!=NULL){
            money=checkMoney(root->left, money);
        }
        if(root->right!=NULL){
            money=checkMoney(root->right, money);
        }
        
        return money;
    }
    
    int checkNodeNum(TreeNode* root, int nodeNum){ // 递归计算当前结点的左右子树各自的结点数
        nodeNum+=1;
        if(root->left!=NULL){
            nodeNum=checkNodeNum(root->left, nodeNum);
        }
        if(root->right!=NULL){
            nodeNum=checkNodeNum(root->right, nodeNum);
        }
        
        return nodeNum;
    }
    
    
    int checkAndMove(TreeNode* root, int moveNum){ // 递归计算每个结点需要移动的硬币数
        
        // 分三种情况
        int situation = -1;
        if(root->val <= 0){ 
            situation = 0;
        }
        else if(root->val==1){
            situation = 1;
        }
        else if(root->val>1){
            situation = 2;
        }
        
        if(situation == 0){ // 当前结点缺钱的情况
            int leftMoney = 0;
            int leftNodeNum = 0;
            int rightMoney = 0;
            int rightNodeNum = 0;
        
            if(root->left!=NULL && root->right!=NULL){ // 左右子结点都不为空的情况
                leftMoney = checkMoney(root->left, leftMoney); // 左子树的Money
                leftNodeNum = checkNodeNum(root->left, leftNodeNum); // 左子树的结点数
                
                rightMoney = checkMoney(root->right, rightMoney); // 右子树的Money
                rightNodeNum = checkNodeNum(root->right, rightNodeNum); // 右子树的结点数
                
                
                int leftOverflow = leftMoney-leftNodeNum; // 值为正时左子树多出的钱，为负时，其绝对值表示左子树缺的钱
                int rightOverflow = rightMoney-rightNodeNum; // 同上
                
                //############### 左右子树为正负数的判断 ###############//注意从左子树移动到右子树或者右子树移动到左子树的硬币的移动步数要x2
                if(leftOverflow>=0 && rightOverflow >=0){ 
                    root->left->val-=leftOverflow; 
                    root->right->val-=rightOverflow; 
                    moveNum+=(leftOverflow+rightOverflow);
                }
                else if(leftOverflow>=0 && rightOverflow<0){
                    root->left->val-=leftOverflow;
                    root->right->val+=(-rightOverflow);
                    moveNum+=((-rightOverflow)*2+(leftOverflow-(-rightOverflow)));
                }
                else if(leftOverflow<0 && rightOverflow >=0){
                    root->right->val-=rightOverflow;
                    root->left->val+=(-leftOverflow);
                    moveNum+=((-leftOverflow)*2+(rightOverflow-(-leftOverflow)));
                }
                else if(leftOverflow<0 && rightOverflow<0){
                    root->right->val+=((-1)*rightOverflow);
                    root->left->val+=((-1)*leftOverflow);
                    moveNum+=((-1)*rightOverflow+(-1)*leftOverflow);
                }
                //####################################################
            }
            else if(root->left==NULL && root->right!=NULL){ // 右子结点都不为空的情况
                rightMoney = checkMoney(root->right, rightMoney);
                rightNodeNum = checkNodeNum(root->right, rightNodeNum);
                
                int rightOverflow = rightMoney-rightNodeNum;
                if(rightOverflow >0){
                    root->right->val-=rightOverflow;
                    moveNum+=(rightOverflow);
                }
                
            }
            else if(root->left!=NULL && root->right==NULL){ // 左子结点都不为空的情况
                
                leftMoney = checkMoney(root->left, leftMoney);
                leftNodeNum = checkNodeNum(root->left, leftNodeNum);
                
                int leftOverflow = leftMoney-leftNodeNum;
                if(leftOverflow >0){
                    root->left->val-=leftOverflow;
                    moveNum+=(leftOverflow);
                }
               
            }
            root->val = 1; // 最终当前结点的Val一定是1，因为我们本来就是从上到下，依依使得每个结点的值为1的
        }
        else if(situation == 1){ // 当前结点不缺钱也没多钱的情况，下面的注释和上面相似，不多赘诉
            int leftMoney = 0;
            int leftNodeNum = 0;
            int rightMoney = 0;
            int rightNodeNum = 0;
            if(root->left!=NULL && root->right!=NULL){
                leftMoney = checkMoney(root->left, leftMoney);
                leftNodeNum = checkNodeNum(root->left, leftNodeNum);
                
                rightMoney = checkMoney(root->right, rightMoney);
                rightNodeNum = checkNodeNum(root->right, rightNodeNum);
                
               
                int leftNeedMoney = leftNodeNum-leftMoney; 
                int rightNeedMoney = rightNodeNum-rightMoney; 
                if(leftNeedMoney >=0 && rightNeedMoney >=0){
                    root->left->val+=leftNeedMoney;
                    root->right->val+=rightNeedMoney;
                    moveNum+=(leftNeedMoney+rightNeedMoney);
                   
                }
                else if(leftNeedMoney<=0 && rightNeedMoney >=0){ 
                    moveNum+=(rightNeedMoney*2);
                    moveNum+=(((-1)*leftNeedMoney)-rightNeedMoney);
                    root->left->val-=((-1)*leftNeedMoney);
                    root->right->val+=(rightNeedMoney);
                }
                else if(leftNeedMoney >=0 && rightNeedMoney <=0){
                    moveNum+=(leftNeedMoney*2);
                    moveNum+=(((-1)*rightNeedMoney)-leftNeedMoney);
                    root->left->val+=(leftNeedMoney);
                    root->right->val-=((-1)*rightNeedMoney);
                   
                }
                
            }
            root->val = 1;
        }
        else if(situation == 2){ // 当前结点多了钱的情况，下面的注释和上面相似，不多赘诉
            int leftMoney = 0;
            int leftNodeNum = 0;
            int rightMoney = 0;
            int rightNodeNum = 0;
            if(root->left!=NULL && root->right!=NULL){
                leftMoney = checkMoney(root->left, leftMoney);
                leftNodeNum = checkNodeNum(root->left, leftNodeNum);

                rightMoney = checkMoney(root->right, rightMoney);
                rightNodeNum = checkNodeNum(root->right, rightNodeNum);

             
                int leftNeedMoney = leftNodeNum-leftMoney; 
                int rightNeedMoney = rightNodeNum-rightMoney; 
                if(leftNeedMoney >=0 && rightNeedMoney >=0){
                    root->left->val+=leftNeedMoney;
                    root->right->val+=rightNeedMoney;
                    moveNum+=(leftNeedMoney+rightNeedMoney);
                    
                }
                else if(leftNeedMoney<=0 && rightNeedMoney >0){ 
                    if(rightNeedMoney<root->val-1){
                        moveNum+=rightNeedMoney;
                        moveNum+=((-1)*leftNeedMoney);
                    }
                    else{
                    	moveNum+=root->val-1;
                    	moveNum+=((rightNeedMoney-(root->val-1))*2);
                    	moveNum+=(((-1)*leftNeedMoney)-(rightNeedMoney-(root->val-1)));

                    	
                    }

                    root->left->val-=((-1)*leftNeedMoney);
                    root->right->val+=(rightNeedMoney);
                }
                else if(leftNeedMoney >0 && rightNeedMoney <=0){
                    if(leftNeedMoney<=root->val-1){
                        moveNum+=leftNeedMoney;
                        moveNum+=((-1)*rightNeedMoney);
                    }
                    else{
                        moveNum+=root->val-1;
                    	moveNum+=((leftNeedMoney-(root->val-1))*2);
                    	moveNum+=(((-1)*rightNeedMoney)-(leftNeedMoney-(root->val-1)));
                    }

                    root->left->val+=(leftNeedMoney);
                    root->right->val-=((-1)*rightNeedMoney);
                }  
            }                      
            else if (root->left==NULL && root->right!=NULL){
                rightMoney = checkMoney(root->right, rightMoney);
                rightNodeNum = checkNodeNum(root->right, rightNodeNum);
                int rightNeedMoney = rightNodeNum-rightMoney;
                if(rightNeedMoney >0){
                    root->right->val+=rightNeedMoney;
                    moveNum+=(rightNeedMoney);
                }
            }
            else if (root->left!=NULL && root->right==NULL){
                leftMoney = checkMoney(root->left, leftMoney);
                leftNodeNum = checkNodeNum(root->left, leftNodeNum);
                int leftNeedMoney = leftNodeNum-leftMoney;
                if(leftNeedMoney >0){
                    root->left->val+=leftNeedMoney;
                    moveNum+=(leftNeedMoney);
                }
            }
            root->val = 1;

        }
        
        if(root->left!=NULL){ // 接下来开始递归当前结点的左结点
            moveNum = checkAndMove(root->left, moveNum); 
        }
        if(root->right!=NULL){ // 接下来开始递归当前结点的右结点
            moveNum = checkAndMove(root->right,moveNum);
        }
        
        return moveNum;
    }
    
    
   
    
    int distributeCoins(TreeNode* root) {
        int moveNum = 0;
        
        // 从上到下遍历，让每个结点的值满足为1 
        moveNum = checkAndMove(root, moveNum);
        
        return moveNum;
    }
};