Algorithms

572. Subtree of Another Tree

Enumerate all subtrees of tree s, and check whether the subtree is equal to t.

public class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if (s == null) {
            return t == null;
        } else if (t == null) {…

563. Binary Tree Tilt

Simple recursion is okay.

public class Solution {
    static class Result {
        int sum;
        int titlSum;
        
        public Result(final int sum, final int titlSum) {
            this.sum = sum;
            this.titlSum = titlSum;
        }
    }…

606. Construct String from Binary Tree

Simple recursion problem.

For each non-null node, output the node value, if all its children are non-null, we are done, otherwise, append parenthesis and recurse on left child, if the right child is null, its parenthesis can be omitted…

599. Minimum Index Sum of Two Lists

We can simply enumerate all potential pairs, which costs O(mn).

public String[] findRestaurant(String[] list1, String[] list2) {
    List<String> ret = new ArrayList<>();
    
    int minSum = list1.length + list2.length;
    
    for (int i…

623. Add One Row to Tree

Just a procedural problem. Do it according to the definition.

• If d == 1, do it in a specific way
• If d > 1 , find the row d — 1 , for each element in the row, add new children and relink all relevant pointers.

624. Maximum Distance in Arrays

Make sure you understand the problem:

• pick up two integers from two different arrays
• |a-b|
• Each given array will have at least 1 number. There will be at least two non-empty arrays.

611. Valid Triangle Number

The obvious solution is to enumerate all possible solutions which costs O(n³). 1000³ = 10⁹ will produce a TLE. For faster lookup, we can always sort it and using binary search.

Assume the three sides are a, b, c where a <= b <= c. If we’ve known a and b…

617. Merge Two Binary Trees

A tree problem.

It’s naturally to solve it recursively. Just be attention for the base cases.

public class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null) {
            return t2…

561. Array Partition I

Actually, this is a math problem.

For simplicity, assume ai < bi, and it’s naturally to make <ai, bi> consecutive such that sumOf(ai) will be the largest.

315. Count of Smaller Numbers After Self

They’re almost the same: