59 lines
1.5 KiB
C++
59 lines
1.5 KiB
C++
#include <algorithm>
|
|
#include <numeric>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
|
|
struct TreeNode {
|
|
int val;
|
|
TreeNode* left;
|
|
TreeNode* right;
|
|
|
|
explicit TreeNode(int x, TreeNode* left = nullptr, TreeNode* right = nullptr) : val(x), left(left), right(right) {}
|
|
};
|
|
|
|
/**
|
|
* 1372. Longest ZigZag Path in a Binary Tree
|
|
*
|
|
* You are given the root of a binary tree.
|
|
*
|
|
* A ZigZag path for a binary tree is defined as follow:
|
|
*
|
|
* Choose any node in the binary tree and a direction (right or left).
|
|
* If the current direction is right, move to the right child of the current node; otherwise, move to the left child.
|
|
* Change the direction from right to left or from left to right.
|
|
* Repeat the second and third steps until you can't move in the tree.
|
|
* Zigzag length is defined as the number of nodes visited - 1. (A single node has a length of 0).
|
|
*
|
|
* Return the longest ZigZag path contained in that tree.
|
|
*/
|
|
|
|
class Solution {
|
|
private:
|
|
std::pair<int, int> f(TreeNode* r) noexcept;
|
|
|
|
std::unordered_map<TreeNode*, std::pair<int, int>> m;
|
|
|
|
public:
|
|
int longestZigZag(TreeNode* root) noexcept;
|
|
};
|
|
|
|
int Solution::longestZigZag(TreeNode* root) noexcept {
|
|
f(root);
|
|
return std::transform_reduce(m.begin(), m.end(), 0, [](int x, int y) { return std::max(x, y); }, [](auto&& x) {
|
|
return std::max(x.second.first, x.second.second);
|
|
});
|
|
}
|
|
|
|
std::pair<int, int> Solution::f(TreeNode* r) noexcept {
|
|
if (m.count(r))
|
|
return m[r];
|
|
return m[r] = {
|
|
r->left ? f(r->left).second + 1 : 0,
|
|
r->right ? f(r->right).first + 1 : 0
|
|
};
|
|
}
|
|
|
|
int main() {
|
|
return 0;
|
|
}
|