Find the shortest path starting from node s and ending at node t. Generate step-by-step directions of such path as a string consisting of only the uppercase letters 'L', 'R', and 'U'. Each letter indicates a specific direction:

• 'L' means to go from a node to its left child node.
• 'R' means to go from a node to its right child node.
• 'U' means to go from a node to its parent node.

Return the step-by-step directions of the shortest path from node s to node t.

Example 1:

Input: root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6
Output: "UURL"
Explanation: The shortest path is: 3 → 1 → 5 → 2 → 6.

Example 2:

Input: root = [2,1], startValue = 2, destValue = 1
Output: "L"
Explanation: The shortest path is: 2 → 1.

Constraints:

• The number of nodes in the tree is n.
• 2 <= n <= 105
• 1 <= Node.val <= n
• All the values in the tree are unique.
• 1 <= startValue, destValue <= n
• startValue != destValue

Solution: Lowest common ancestor

It’s no hard to see that the shortest path is from the start node to the lowest common ancestor (LCA) of (start, end), then to the end node. The key is to find the LCA while finding paths from root to two nodes.

We can use recursion to find/build a path from root to a target node.
The common prefix of these two paths is the path from root to the LCA that we need to remove from the shortest path.
e.g.
root to start “LLRLR”
root to dest “LLLR”
common prefix is “LL”, after removing, it becomes:
LCA to start “RLR”
LCA to dest “LR”
Final path becomes “UUU” + “LR” = “UUULR”

The final step is to replace the L/R with U for the start path since we are moving up and then concatenate with the target path.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  string getDirections(TreeNode* root, int startValue, int destValue) {
    string startPath;
    string destPath;
    buildPath(root, startValue, startPath);
    buildPath(root, destValue, destPath);    
    // Remove common suffix (shared path from root to LCA)
    while (!startPath.empty() && !destPath.empty() 
           && startPath.back() == destPath.back()) {
      startPath.pop_back();
      destPath.pop_back();
    }
    reverse(begin(destPath), end(destPath));
    return string(startPath.size(), 'U') + destPath;
  }
private:
  bool buildPath(TreeNode* root, int t, string& path) {
    if (!root) return false;
    if (root->val == t) return true;
    if (buildPath(root->left, t, path)) {
      path.push_back('L');
      return true;
    } else if (buildPath(root->right, t, path)) {
      path.push_back('R');
      return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 2096. Step-By-Step Directions From a Binary Tree Node to Another appeared first on Huahua's Tech Road.

Note: A leaf is a node with no children.

Example:

Input:

   1
 /   \
2     3
 \
  5

Output: ["1->2->5", "1->3"]

Explanation: All root-to-leaf paths are: 1->2->5, 1->3

Solution: Recursion

Time complexity: O(n)
Space complexity: O(n) / output can be O(n^2)

// Author: Huahua
class Solution {
public:
  vector<string> binaryTreePaths(TreeNode* root) {
    vector<string> ans;
    string s;
    function<void(TreeNode*, int)> preorder = [&](TreeNode* node, int l) {
      if (!node) return;
      s += (l > 0 ? "->" : "") + to_string(node->val);
      if (!node->left && !node->right)
        ans.push_back(s);
      preorder(node->left, s.size());
      preorder(node->right, s.size());
      while (s.size() != l) s.pop_back();
    };
    preorder(root, 0);
    return ans;
  }
};

The post 花花酱 LeetCode 257. Binary Tree Paths appeared first on Huahua's Tech Road.

If a folder[i] is located within another folder[j], it is called a sub-folder of it.

The format of a path is one or more concatenated strings of the form: / followed by one or more lowercase English letters. For example, /leetcode and /leetcode/problems are valid paths while an empty string and / are not.

Example 1:

Input: folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
Output: ["/a","/c/d","/c/f"]
Explanation: Folders "/a/b/" is a subfolder of "/a" and "/c/d/e" is inside of folder "/c/d" in our filesystem.

Example 2:

Input: folder = ["/a","/a/b/c","/a/b/d"]
Output: ["/a"]
Explanation: Folders "/a/b/c" and "/a/b/d/" will be removed because they are subfolders of "/a".

Example 3:

Input: folder = ["/a/b/c","/a/b/ca","/a/b/d"]
Output: ["/a/b/c","/a/b/ca","/a/b/d"]

Constraints:

• 1 <= folder.length <= 4 * 10^4
• 2 <= folder[i].length <= 100
• folder[i] contains only lowercase letters and ‘/’
• folder[i] always starts with character ‘/’
• Each folder name is unique.

Solution: HashTable

Time complexity: O(n*L)
Space complexity: O(n*L)

// Author: Huahua
class Solution {
public:
  vector<string> removeSubfolders(vector<string>& folder) {
    unordered_set<string> s(begin(folder), end(folder));
    vector<string> ans;
    for (const auto& cur : folder) {
      string f = cur;
      bool valid = true;
      while (!f.empty() && valid) {
        while (f.back() != '/') f.pop_back();
        f.pop_back();
        if (s.count(f)) valid = false;
      }
      if (valid) ans.push_back(cur);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1233. Remove Sub-Folders from the Filesystem appeared first on Huahua's Tech Road.

On an N x N grid, each square grid[i][j] represents the elevation at that point (i,j).

Now rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distance in zero time. Of course, you must stay within the boundaries of the grid during your swim.

You start at the top left square (0, 0). What is the least time until you can reach the bottom right square (N-1, N-1)?

Example 1:

Input: [[0,2],[1,3]]
Output: 3
Explanation:
At time 0, you are in grid location (0, 0).
You cannot go anywhere else because 4-directionally adjacent neighbors have a higher elevation than t = 0.

You cannot reach point (1, 1) until time 3.
When the depth of water is 3, we can swim anywhere inside the grid.

Example 2:

Input: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
Output: 16
Explanation:
 0  1  2  3  4
24 23 22 21  5
12 13 14 15 16
11 17 18 19 20
10  9  8  7  6

The final route is marked in bold.
We need to wait until time 16 so that (0, 0) and (4, 4) are connected.

Note:

1. 2 <= N <= 50.
2. grid[i][j] is a permutation of [0, …, N*N – 1].

Solution 1: Dijkstra’s Algorithm

Time complexity: O(n^2*logn)
Space complexity: O(n^2)

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int swimInWater(vector<vector<int>>& grid) {
    const int n = grid.size();
    priority_queue<pair<int, int>> q; // {-time, y * N + x}
    q.push({-grid[0][0], 0 * n + 0});
    vector<int> seen(n * n);
    vector<int> dirs{-1, 0, 1, 0, -1};
    seen[0 * n + 0] = 1;
    while (!q.empty()) {
      auto node = q.top(); q.pop();
      int t = -node.first;
      int x = node.second % n;
      int y = node.second / n;      
      if (x == n - 1 && y == n - 1) return t;
      for (int i = 0; i < 4; ++i) {
        int tx = x + dirs[i];
        int ty = y + dirs[i + 1];
        if (tx < 0 || ty < 0 || tx >= n || ty >= n) continue;
        if (seen[ty * n + tx]) continue;
        seen[ty * n + tx] = 1;
        q.push({-max(t, grid[ty][tx]), ty * n + tx});
      }
    }
    return -1;
  }
};

Solution 2: Binary Search + BFS

Time complexity: O(2logn * n^2)
Space complexity: O(n^2)

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int swimInWater(vector<vector<int>>& grid) {
    const int n = grid.size();
    auto hasPath = [&grid, n](int t) {
      if (grid[0][0] > t) return false;      
      queue<int> q;
      vector<int> seen(n * n);
      vector<int> dirs{1, 0, -1, 0, 1};
      q.push(0);
      
      while (!q.empty()) {
        const int x = q.front() % n;
        const int y = q.front() / n;
        q.pop();
        if (x == n - 1 && y == n - 1) return true;
        for (int i = 0; i < 4; ++i) {
          const int tx = x + dirs[i];
          const int ty = y + dirs[i + 1];
          if (tx < 0 || ty < 0 || tx >= n || ty >= n || grid[ty][tx] > t) continue;
          const int key = ty * n + tx;
          if (seen[key]) continue;
          seen[key] = 1;
          q.push(key);
        }
      }
      return false;
    };
    int l = 0;
    int r = n * n;
    while (l < r) {
      int m = l + (r - l) / 2;
      if (hasPath(m)) {
        r = m;
      } else {
        l = m + 1;
      }
    }
    return l;
  }
};

The post 花花酱 LeetCode 778. Swim in Rising Water appeared first on Huahua's Tech Road.

Given a square array of integers A, we want the minimum sum of a falling path through A.

A falling path starts at any element in the first row, and chooses one element from each row.  The next row’s choice must be in a column that is different from the previous row’s column by at most one.

Example 1:

Input: [[1,2,3],[4,5,6],[7,8,9]]
Output: 12
Explanation: 
The possible falling paths are:

• [1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]
• [2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]
• [3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]

The falling path with the smallest sum is [1,4,7], so the answer is 12.

Note:

1. 1 <= A.length == A[0].length <= 100
2. -100 <= A[i][j] <= 100

Solution: DP

Time complexity: O(mn)

Space complexity: O(mn)

// Author: Huahua, 12 ms
class Solution {
public:
  int minFallingPathSum(vector<vector<int>>& A) {
    int n = A.size();
    int m = A[0].size();
    vector<vector<int>> dp(n + 2, vector<int>(m + 2));
          
    for (int i = 1; i <= n; ++i) {
      dp[i][0] = dp[i][m + 1] = INT_MAX;
      for (int j = 1; j <= m; ++j)
        dp[i][j] = *min_element(dp[i - 1].begin() + j - 1, 
                                dp[i - 1].begin() + j + 2) + A[i - 1][j - 1];      
    }
    return *min_element(dp[n].begin() + 1, dp[n].end() - 1);
  }
};

// Author: Huahua, 12 ms
class Solution {
public:
  int minFallingPathSum(vector<vector<int>>& A) {
    int n = A.size();
    int m = A[0].size();    
          
    for (int i = 1; i < n; ++i)
      for (int j = 0; j < m; ++j) {
        int sum = A[i - 1][j];
        if (j > 0) sum = min(sum, A[i - 1][j - 1]);
        if (j < m - 1) sum = min(sum, A[i - 1][j + 1]);
        A[i][j] += sum;
      }
            
    return *min_element(begin(A.back()), end(A.back()));
  }
};

The post 花花酱 LeetCode 931. Minimum Falling Path Sum appeared first on Huahua's Tech Road.

Problem

There is an m by n grid with a ball. Given the start coordinate (i,j) of the ball, you can move the ball to adjacent cell or cross the grid boundary in four directions (up, down, left, right). However, you can at most move N times. Find out the number of paths to move the ball out of grid boundary. The answer may be very large, return it after mod 10⁹ + 7.

Example 1:

Input:m = 2, n = 2, N = 2, i = 0, j = 0
Output: 6
Explanation:

Example 2:

Input:m = 1, n = 3, N = 3, i = 0, j = 1
Output: 12
Explanation:

Note:

1. Once you move the ball out of boundary, you cannot move it back.
2. The length and height of the grid is in range [1,50].
3. N is in range [0,50].

Solution

Time complexity: O(m*n + N * m * n)

Space complexity: O(N*m*n) -> O(m*n)

C++

// Author: Huahua
// Running time: 19 ms
class Solution {
public:
  int findPaths(int m, int n, int N, int i, int j) {
    constexpr int kMod = 1000000007;
    vector<vector<vector<int>>> dp(N + 1, vector<vector<int>>(m, vector<int>(n, 0)));
    vector<int> dirs{-1, 0, 1, 0, -1};
    for (int s = 1; s <= N; ++s)
      for (int y = 0; y < m; ++y)
        for (int x = 0; x < n; ++x)
          for (int d = 0; d < 4; ++d) {
            int tx = x + dirs[d];
            int ty = y + dirs[d + 1];            
            if (tx < 0 || ty < 0 || tx >= n || ty >= m)
              dp[s][y][x] += 1;
            else
              dp[s][y][x] = (dp[s][y][x] + dp[s - 1][ty][tx]) % kMod;
          }        
    return dp[N][i][j];
  }
};

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
  int findPaths(int m, int n, int N, int i, int j) {
    constexpr int kMod = 1000000007;
    vector<vector<int>> dp(m, vector<int>(n, 0));
    vector<int> dirs{-1, 0, 1, 0, -1};
    for (int s = 1; s <= N; ++s) {
      vector<vector<int>> tmp(m, vector<int>(n, 0));
      for (int y = 0; y < m; ++y)
        for (int x = 0; x < n; ++x)
          for (int d = 0; d < 4; ++d) {
            int tx = x + dirs[d];
            int ty = y + dirs[d + 1];            
            if (tx < 0 || ty < 0 || tx >= n || ty >= m)
              tmp[y][x] += 1;
            else
              tmp[y][x] = (tmp[y][x] + dp[ty][tx]) % kMod;
          }
      dp.swap(tmp);
    }
    return dp[i][j];
  }
};

Recursion with memorization

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int findPaths(int m, int n, int N, int i, int j) {    
    m_ = m;
    n_ = n;
    dp_ = vector<vector<vector<int>>>(N + 1, vector<vector<int>>(m, vector<int>(n, INT_MIN)));    
    return paths(N, j, i);    
  }
private:
  vector<vector<vector<int>>> dp_;
  int m_;
  int n_;
  
  // number of paths starts from out-of-boundary to (x, y) by moving at most N steps.
  int paths(int N, int x, int y) {
    static vector<int> dirs{-1, 0, 1, 0, -1};
    static const int kMod = 1000000007;
    // Out of boundary, one path.
    if (x < 0 || x >= n_ || y < 0 || y >= m_) return 1;
    // Can not move but still in the grid, no path.
    if (N == 0) return 0;
    // Already computed.
    if (dp_[N][y][x] != INT_MIN) return dp_[N][y][x];
    
    dp_[N][y][x] = 0;
    
    for (int d = 0; d < 4; ++d) {
      int tx = x + dirs[d];
      int ty = y + dirs[d + 1];
      dp_[N][y][x] = (dp_[N][y][x] + paths(N - 1, tx, ty)) % kMod;
    }        
    
    return dp_[N][y][x];
  }
};

no loops

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int findPaths(int m, int n, int N, int i, int j) {    
    m_ = m;
    n_ = n;
    dp_ = vector<vector<vector<int>>>(N + 1, vector<vector<int>>(m, vector<int>(n, INT_MIN)));    
    return paths(N, j, i);    
  }
private:
  vector<vector<vector<int>>> dp_;
  int m_;
  int n_;
  
  // number of paths start from (x, y) and move at most N steps.
  int paths(int N, int x, int y) {    
    static const int kMod = 1000000007;
    
    if (x < 0 || x >= n_ || y < 0 || y >= m_) return 1;
    if (N == 0) return 0;
    if (dp_[N][y][x] != INT_MIN) return dp_[N][y][x];
    
    long ans = 0;
    ans += paths(N - 1, x + 1, y);
    ans += paths(N - 1, x - 1, y);
    ans += paths(N - 1, x, y + 1);
    ans += paths(N - 1, x, y - 1);
    ans %= kMod;
    
    return dp_[N][y][x] = ans;
  }
};

Related Problems

• 花花酱 LeetCode 62. Unique Paths
• 花花酱 LeetCode 63. Unique Paths II
• 花花酱 688. Knight Probability in Chessboard

The post 花花酱 LeetCode 576. Out of Boundary Paths appeared first on Huahua's Tech Road.

Problem

Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

Input: nums = 
[
  [9,9,4],
  [6,6,8],
  [2,1,1]
] 
Output: 4 
Explanation: The longest increasing path is [1, 2, 6, 9].

Example 2:

Input: nums = 
[
  [3,4,5],
  [3,2,6],
  [2,2,1]
] 
Output: 4 
Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

Solution1: DFS + Memorization

Time complexity: O(mn)

Space complexity: O(mn)

C++

// Author: Huahua
// Running time: 36 ms
class Solution {
public:
  int longestIncreasingPath(vector<vector<int>>& matrix) {
    if (matrix.empty()) return 0;
    m_ = matrix.size();
    n_ = matrix[0].size();
    dp_ = vector<vector<int>>(m_, vector<int>(n_, -1)); 
    int ans = 0;
    for (int y = 0; y < m_; ++y)
      for (int x = 0; x < n_; ++x)
        ans = max(ans, dfs(matrix, x, y));
    return ans;
  }
private:
  int dfs(const vector<vector<int>>& mat, int x, int y) {
    if (dp_[y][x] != -1) return dp_[y][x];
    static int dirs[] = {0, -1, 0, 1, 0};
    dp_[y][x] = 1;
    for (int i = 0; i < 4; ++i) {
      int tx = x + dirs[i];
      int ty = y + dirs[i + 1];
      if (tx < 0 || ty < 0 || tx >= n_ || ty >= m_ || mat[ty][tx] <= mat[y][x]) 
        continue;
      dp_[y][x] = max(dp_[y][x], 1 + dfs(mat, tx, ty));
    }
    return dp_[y][x];
  }
  
  int m_;
  int n_;
  // dp[i][j]: max length start from (j, i)
  vector<vector<int>> dp_;  
};

Solution2: DP

DP

Time complexity: O(mn*log(mn))

Space complexity: O(mn)

// Author: Huahua
// Running time: 63 ms
class Solution {
public:
  int longestIncreasingPath(vector<vector<int>>& matrix) {
    if (matrix.empty()) return 0;
    int m = matrix.size();
    int n = matrix[0].size();
    vector<vector<int>> dp(m, vector<int>(n, 1)); 
    int ans = 0;
    
    vector<pair<int, pair<int, int>>> cells;
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        cells.push_back({matrix[y][x], {x, y}});
    sort(cells.rbegin(), cells.rend());
    
    vector<int> dirs {0, 1, 0, -1, 0};    
    for (const auto& cell : cells) {
      int x = cell.second.first;
      int y = cell.second.second;
      for (int i = 0; i < 4; ++i) {
        int tx = x + dirs[i];
        int ty = y + dirs[i + 1];
        if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
        if (matrix[ty][tx] <= matrix[y][x]) continue;
        dp[y][x] = max(dp[y][x], 1 + dp[ty][tx]);            
      }
      ans = max(ans, dp[y][x]);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 329. Longest Increasing Path in a Matrix appeared first on Huahua's Tech Road.

https://leetcode.com/problems/find-duplicate-file-in-system/description/

题目大意：输出系统中文件内容相同的文件名。

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.

A group of duplicate files consists of at least two files that have exactly the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt … fn.txt with content f1_content, f2_content … fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

"directory_path/file_name.txt"

Example 1:

Input:
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
Output:  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]

Note:

1. No order is required for the final output.
2. You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
3. The number of files given is in the range of [1,20000].
4. You may assume no files or directories share the same name in the same directory.
5. You may assume each given directory info represents a unique directory. Directory path and file info are separated by a single blank space.

Follow-up beyond contest:

1. Imagine you are given a real file system, how will you search files? DFS or BFS?
2. If the file content is very large (GB level), how will you modify your solution?
3. If you can only read the file by 1kb each time, how will you modify your solution?
4. What is the time complexity of your modified solution? What is the most time-consuming part and memory consuming part of it? How to optimize?
5. How to make sure the duplicated files you find are not false positive?

Solution: HashTable

Key: content, Value: Array of filenames

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 80ms (beats 94.68%)
class Solution {
public:
  vector<vector<string>> findDuplicate(vector<string>& paths) {
    unordered_map<string, vector<string>> files; // content -> filenames
    for (const string& path : paths) {
      string folder;
      int i = 0;
      while (path[i] != ' ') folder += path[i++]; 
      while (i < path.length()) {
        string filename;
        string content;
        ++i; // ' '
        while (path[i] != '(') filename += path[i++];
        ++i; // '('
        while (path[i] != ')') content += path[i++];
        ++i; // ')'        
        files[content].push_back(folder + "/" + filename);
      }      
    }
    vector<vector<string>> ans;
    for (auto& kv : files) 
      if (kv.second.size() > 1)
        ans.push_back(std::move(kv.second));      
    return ans;
  }
};

The post 花花酱 LeetCode 609. Find Duplicate File in System appeared first on Huahua's Tech Road.

题目大意：给你一棵二叉树，返回一条最长的路径，要求路径上所有的节点值都相同。

https://leetcode.com/problems/longest-univalue-path/description/

Problem: 

Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.

Note: The length of path between two nodes is represented by the number of edges between them.

Example 1:

Input:

              5
             / \
            4   5
           / \   \
          1   1   5

Output:

2

Example 2:

Input:

              1
             / \
            4   5
           / \   \
          4   4   5

Output:

2

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

Idea:

DFS

Solution: Recursion

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Runtime: 69 ms
class Solution {
public:
    int longestUnivaluePath(TreeNode* root) {
        if (root == nullptr) return 0;
        int ans = 0;
        univaluePath(root, &ans);
        return ans;
    }
private:
    int univaluePath(TreeNode* root, int* ans) {
        if (root == nullptr) return 0;
        int l = univaluePath(root->left, ans);
        int r = univaluePath(root->right, ans);
        int pl = 0;
        int pr = 0;
        if (root->left && root->val == root->left->val) pl = l + 1;
        if (root->right && root->val == root->right->val) pr = r + 1;
        *ans = max(*ans, pl + pr);
        return max(pl, pr);
    }
};

// Author: Huahua
// Runtime: 12 ms
class Solution {
    private int ans;
    public int longestUnivaluePath(TreeNode root) {
        if (root == null) return 0;        
        this.ans = 0;
        univaluePath(root);
        return this.ans;
    }
    
    private int univaluePath(TreeNode root) {
        if (root == null) return 0;
        int l = univaluePath(root.left);
        int r = univaluePath(root.right);
        int pl = 0;
        int pr = 0;
        if (root.left != null && root.val == root.left.val) pl = l + 1;
        if (root.right != null && root.val == root.right.val) pr = r + 1;
        this.ans = Math.max(this.ans, pl + pr);
        return Math.max(pl, pr);
    }
}

"""
Author: Huahua
Runtime: 899 ms
"""
class Solution:
    def longestUnivaluePath(self, root):
        self.ans = 0
        self._univaluePath(root)
        return self.ans
    
    def _univaluePath(self, root):
        if root is None: return 0
        l = self._univaluePath(root.left) if root.left is not None else -1
        r = self._univaluePath(root.right) if root.right is not None else -1
        pl = l + 1 if l >= 0 and root.val == root.left.val else 0
        pr = r + 1 if r >= 0 and root.val == root.right.val else 0
        self.ans = max(self.ans, pl + pr)
        return max(pl, pr)

Related Problems

• 花花酱 LeetCode 124. Binary Tree Maximum Path Sum

The post 花花酱 LeetCode 687. Longest Univalue Path appeared first on Huahua's Tech Road.