91 lines
2.7 KiB
C++
91 lines
2.7 KiB
C++
// Source : https://leetcode.com/problems/distribute-coins-in-binary-tree/
|
|
// Author : Hao Chen
|
|
// Date : 2019-03-29
|
|
|
|
/*****************************************************************************************************
|
|
*
|
|
* Given the root of a binary tree with N nodes, each node in the tree has node.val coins, and there
|
|
* are N coins total.
|
|
*
|
|
* In one move, we may choose two adjacent nodes and move one coin from one node to another. (The
|
|
* move may be from parent to child, or from child to parent.)
|
|
*
|
|
* Return the number of moves required to make every node have exactly one coin.
|
|
*
|
|
* Example 1:
|
|
*
|
|
* Input: [3,0,0]
|
|
* Output: 2
|
|
* Explanation: From the root of the tree, we move one coin to its left child, and one coin to its
|
|
* right child.
|
|
*
|
|
* Example 2:
|
|
*
|
|
* Input: [0,3,0]
|
|
* Output: 3
|
|
* Explanation: From the left child of the root, we move two coins to the root [taking two moves].
|
|
* Then, we move one coin from the root of the tree to the right child.
|
|
*
|
|
* Example 3:
|
|
*
|
|
* Input: [1,0,2]
|
|
* Output: 2
|
|
*
|
|
* Example 4:
|
|
*
|
|
* Input: [1,0,0,null,3]
|
|
* Output: 4
|
|
*
|
|
* Note:
|
|
*
|
|
* 1<= N <= 100
|
|
* 0 <= node.val <= N
|
|
*
|
|
******************************************************************************************************/
|
|
|
|
/**
|
|
* 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 distributeCoins(TreeNode* root) {
|
|
int result = 0;
|
|
dfs(root, result);
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// if a node has 0 coin, which means one move from its parent.
|
|
// 1 coin, which means zero move from its parent.
|
|
// N coins, which means N-1 moves to its parent.
|
|
//
|
|
// So, we can simply know, the movement = coins -1.
|
|
// - negative number means the the coins needs be moved in.
|
|
// - positive number means the the coins nees be moved out.
|
|
//
|
|
// A node needs to consider the movement requests from both its left side and right side.
|
|
// and need to calculate the coins after left and right movement.
|
|
//
|
|
// So, the node coins = my conins - the coins move out + the coins move in.
|
|
//
|
|
// Then we can have to code as below.
|
|
//
|
|
int dfs(TreeNode* root, int& result) {
|
|
if (root == NULL) return 0;
|
|
|
|
int left_move = dfs(root->left, result);
|
|
int right_move = dfs(root->right, result);
|
|
result += (abs(left_move) + abs(right_move));
|
|
|
|
// the coin after movement: coins = root->val +left_move + right_move
|
|
// the movement needs: movement = coins - 1
|
|
return root->val + left_move + right_move - 1;
|
|
}
|
|
};
|