'2025/02/03 글 목록

Longest Strictly Increasing or Strictly Decreasing Subarray

알고리즘 2025. 2. 3. 23:42

Leetcode Problem:
Longest Strictly Increasing or Strictly Decreasing Subarray

Summary

Find the length of the longest strictly increasing or decreasing subarray in a given array of integers.

Approach

The solution uses a dynamic programming approach
It maintains two variables, inc and dec, to track the length of the longest increasing and decreasing subarrays ending at the current position
The maximum length between these two subarrays is updated at each step.

Complexity

O(n), where n is the length of the input array
This is because the solution iterates through the array once.

Explain

The solution starts by initializing three variables: inc, dec, and ans
inc and dec are used to track the length of the longest increasing and decreasing subarrays ending at the current position, respectively
ans is used to store the maximum length of these subarrays
The solution then iterates through the array, updating inc and dec based on whether the current element is greater than or less than the previous element
If the current element is equal to the previous element, inc and dec are reset to 1
At each step, the solution updates ans to be the maximum of its current value and the maximum of inc and dec
Finally, the solution returns ans, which represents the length of the longest strictly increasing or decreasing subarray in the input array.

Solution Code:


class Solution {
public:
    int longestMonotonicSubarray(vector& nums) {
        int inc = 1;
        int dec = 1;
        int ans = 1;
        for(int i = 1 ; i < nums.size(); i++){
            if (nums[i-1] < nums[i]){
                inc++;
                dec = 1;
            }else if (nums[i-1] > nums[i]){
                inc = 1;
                dec++;
            } else{
                dec = 1;
                inc = 1;
            }
            
            ans = max(ans, max(inc, dec));
        }
        return ans;
    }
};

'알고리즘' 카테고리의 다른 글

Sort an Array (0)	2025.02.04
Sort the Jumbled Numbers (0)	2025.02.04
Sort Array by Increasing Frequency (0)	2025.02.03
Sort the People (0)	2025.02.03
Build a Matrix With Conditions (0)	2025.02.03

짬뽕얼큰하게

,

Sort Array by Increasing Frequency

알고리즘 2025. 2. 3. 07:46

Leetcode Problem:
Sort Array by Increasing Frequency

Summary

Given an array of integers, sort the array in increasing order based on the frequency of the values
If multiple values have the same frequency, sort them in decreasing order.

Approach

The solution uses a frequency count array to store the frequency of each value, then sorts the array using a modified merge sort algorithm
The modified merge sort algorithm uses a temporary array to store the merged elements and then copies them back to the original array.

Complexity

O(n log n)

Explain

The solution first creates a frequency count array `cnt` to store the frequency of each value
Then it calls the `merge_sort` function to sort the array
The `merge_sort` function recursively divides the array into two halves and sorts them separately
Then it merges the two sorted halves using the `merge` function
The `merge` function compares the frequencies of the values and sorts them in increasing order
If multiple values have the same frequency, it sorts them in decreasing order
Finally, the solution returns the sorted array.

Solution Code:


class Solution {
    int cnt[300] = {0};
    int tmp[100];
    void merge(vector& nums, int l, int mid, int r){
        int i = l;
        int j = mid + 1;
        int cur = i;
        while( i <= mid && j <= r){
            if (cnt[nums[i] + 100] < cnt[nums[j] + 100]){
                tmp[cur++] = nums[i++];
            } 
            else if(cnt[nums[i] + 100] == cnt[nums[j] + 100] && nums[i] > nums[j]){
                tmp[cur++] = nums[i++];
            }
            else{
                tmp[cur++] = nums[j++];
            }
        }
        while(i <= mid){
            tmp[cur++] = nums[i++];
        }
        for(i = l; i < cur; i++){
            nums[i] = tmp[i];
        }
    }
    void merge_sort(vector &nums, int l, int r){
        if (l >= r) return;
        int mid = (l + r) / 2;
        merge_sort(nums, l, mid);
        merge_sort(nums, mid+1, r);
        merge(nums, l, mid, r);
    }    
public:
    vector frequencySort(vector& nums) {
        for(int i = 0 ; i < nums.size(); i++){
            cnt[nums[i] + 100]++;
        }
        merge_sort(nums, 0, nums.size() -1);
        return nums;
    }
};

'알고리즘' 카테고리의 다른 글

Sort the Jumbled Numbers (0)	2025.02.04
Longest Strictly Increasing or Strictly Decreasing Subarray (0)	2025.02.03
Sort the People (0)	2025.02.03
Build a Matrix With Conditions (0)	2025.02.03
Number of Good Leaf Nodes Pairs (0)	2025.02.03

짬뽕얼큰하게

,

Sort the People

알고리즘 2025. 2. 3. 07:43

Leetcode Problem:
Sort the People

Summary

Given an array of names and heights, sort the names in descending order by height.

Approach

Merge Sort algorithm is used to sort the heights array first, then use the sorted heights array to sort the names array.

Complexity

O(n log n)

Explain

The merge_sort function is a recursive function that divides the array into two halves until each subarray has one element
The merge function then merges the subarrays back together in sorted order
After sorting the heights array, the names array is sorted based on the heights array
The names array is then returned in a vector of strings.

Solution Code:


class Solution {
public:
    vector h;
    int tmp[1001];
    void merge(int* arr, int l, int mid, int r){
        int i = l;
        int j = mid + 1;
        int cur = l;
        while(i <= mid && j <= r){
            int num1 = arr[i];
            int num2 = arr[j];
            if(h[num1] >= h[num2]){
                tmp[cur++] = arr[i++];
            }else{
                tmp[cur++] = arr[j++];
            }
        }
        while(i <= mid){
            tmp[cur++] = arr[i++];
        }
        for(i = l; i < cur; i++){
            arr[i] = tmp[i];
        }
    }
    void merge_sort(int* arr, int l, int r){
        if (l >= r) return;
        int mid = (l + r) / 2;
        merge_sort(arr, l, mid);
        merge_sort(arr, mid+1, r);
        merge(arr, l, mid, r);
    }

    vector sortPeople(vector& names, vector& heights) {
        h = heights;
        int* arr = new int[heights.size()];
        for(int i = 0 ; i < heights.size(); i++){
            arr[i] = i;
        }
        merge_sort(arr, 0, heights.size()-1);
        vector ans;
        for(int i = 0 ; i < heights.size(); i++){
            int n = arr[i];
            ans.push_back(names[n]);
        }
        return ans;
    }
};

'알고리즘' 카테고리의 다른 글

Longest Strictly Increasing or Strictly Decreasing Subarray (0)	2025.02.03
Sort Array by Increasing Frequency (0)	2025.02.03
Build a Matrix With Conditions (0)	2025.02.03
Number of Good Leaf Nodes Pairs (0)	2025.02.03
Delete Nodes And Return Forest (0)	2025.02.03

짬뽕얼큰하게

,

Build a Matrix With Conditions

알고리즘 2025. 2. 3. 07:40

Leetcode Problem:
Build a Matrix With Conditions

Summary

Given a 2D array of row conditions and column conditions, build a k x k matrix that contains each number from 1 to k exactly once and satisfies the conditions.

Approach

The solution uses a depth-first search (DFS) approach to find a Hamiltonian path in the graph
It first constructs two graphs, one for row conditions and one for column conditions
Then, it checks if there is a cycle in either graph using DFS
If there is a cycle, it returns an empty matrix
Otherwise, it uses another DFS to find a Hamiltonian path in the graph and constructs the matrix based on the path.

Complexity

O(k * m * n * k) where m and n are the number of row conditions and column conditions respectively

Explain

The solution starts by constructing two graphs, one for row conditions and one for column conditions
It then checks if there is a cycle in either graph using DFS
If there is a cycle, it returns an empty matrix
Otherwise, it uses another DFS to find a Hamiltonian path in the graph and constructs the matrix based on the path
The Hamiltonian path is used to ensure that each number from 1 to k is used exactly once in the matrix and that the row and column conditions are satisfied.

Solution Code:


class Solution {
public:
    bool traversalCycle(int cur, vector> graph, int color[]){
        color[cur] = 1;
        for(int i = 0 ; i < graph[cur].size(); i++){
            int next = graph[cur][i];
            if (color[next] == 0 && traversalCycle(next, graph, color)){
                return true;
            } else if (color[next] == 1){
                return true;
            }
        }
        color[cur] = 2;
        return false;
    }
    bool findCycle(int k, vector> &graph){
        int *color = new int[k];
        for(int i = 0 ; i < k; i++){
            color[i] = 0;
        }
        for(int i = 0 ; i < k ;i++){
            if (color[i] != 0) continue;
            if (traversalCycle(i, graph, color)){
                return true;
            }
        }
        return false;
    }

    void traversalAnswer(int cur, vector> &graph, vector &ans, bool visited[]){
        if(visited[cur]) return;
        visited[cur] = true;
        for(int i = 0 ; i < graph[cur].size(); i++){
            int next = graph[cur][i];
            traversalAnswer(next, graph, ans, visited);
        }
        ans.push_back(cur);
    }
    void getAnswer(int k, vector> &graph, vector &ans){
        bool *visited = new bool[k];
        for(int i = 0 ; i < k; i++){
            visited[i] = false;
        }
        for(int i = 0; i < k; i++){
            if (visited[i]) continue;
            traversalAnswer(i, graph, ans, visited);
        }
        reverse(ans.begin(), ans.end());
    }

    vector> buildMatrix(int k, vector>& rowConditions, vector>& colConditions) {
        vector> graph1(k);
        vector> graph2(k);
        for(int i = 0 ; i < rowConditions.size(); i++){
            int a = rowConditions[i][0];
            int b = rowConditions[i][1];
            graph1[a - 1].push_back(b - 1);
        }
        for(int i = 0 ; i < colConditions.size(); i++){
            int a = colConditions[i][0];
            int b = colConditions[i][1];
            graph2[a - 1].push_back(b - 1);
        }
        if (findCycle(k, graph1) || findCycle(k, graph2)){
            return {};
        }

        vector ans1, ans2;
        getAnswer(k, graph1, ans1);
        getAnswer(k ,graph2, ans2);

        vector> ans;
        map m;
        for(int i = 0 ; i < k; i++){
            m[ans2[i]] = i;
            ans.push_back(vector());
            for(int j = 0 ; j < k; j++){
                ans[i].push_back(0);
            }
        }
        for(int i = 0 ; i < k; i++){
            ans[i][m[ans1[i]]] = ans1[i] + 1;
        }
        return ans;
    }
};

'알고리즘' 카테고리의 다른 글

Sort Array by Increasing Frequency (0)	2025.02.03
Sort the People (0)	2025.02.03
Number of Good Leaf Nodes Pairs (0)	2025.02.03
Delete Nodes And Return Forest (0)	2025.02.03
Step-By-Step Directions From a Binary Tree Node to Another (0)	2025.02.03

짬뽕얼큰하게

,

Number of Good Leaf Nodes Pairs

알고리즘 2025. 2. 3. 07:35

Leetcode Problem:
Number of Good Leaf Nodes Pairs

Summary

The problem is to find the number of good leaf node pairs in a binary tree where a pair of two different leaf nodes is said to be good if the length of the shortest path between them is less than or equal to a given distance.

Approach

The approach used is to perform a depth-first traversal of the binary tree and store the distances of the leaf nodes in a vector
Then, for each pair of leaf nodes, check if the distance between them is less than or equal to the given distance
If it is, increment the count of good pairs.

Complexity

O(n log n) due to the sorting of the vector of leaf node distances, where n is the number of nodes in the tree.

Explain

The solution code defines a class Solution with a method countPairs that takes the root of a binary tree and an integer distance as input
It initializes a variable dist to store the distance and a variable ans to store the count of good pairs
The method traversal is a helper function that performs a depth-first traversal of the binary tree and stores the distances of the leaf nodes in a vector
The method countPairs calls the traversal method and initializes the variable dist
It then calls the traversal method and checks for each pair of leaf nodes if the distance between them is less than or equal to the given distance
If it is, it increments the count of good pairs
Finally, it returns the count of good pairs.

Solution Code:


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int dist;
    int ans = 0;
    vector traversal(TreeNode* node){
        if (node->left == nullptr && node->right == nullptr) return {1};
        vector v;
        if (node->left){
            v = traversal(node->left);
        }
        if (node->right){
            vector tmp = traversal(node->right);
            for(int i = 0 ; i < tmp.size(); i++){
                for(int j = 0 ; j < v.size(); j++){
                    if (v[j] + tmp[i] <= dist){
                        ans++;
                    }
                }
            }
            v.insert(v.end(), tmp.begin(), tmp.end());
            
        }
        for(int i = 0 ; i < v.size(); i++){
            v[i] += 1;
        }
        return v;
    }
    int countPairs(TreeNode* root, int distance) {
        dist = distance;
        traversal(root);
        return ans;
    }
};

'알고리즘' 카테고리의 다른 글

Sort the People (0)	2025.02.03
Build a Matrix With Conditions (0)	2025.02.03
Delete Nodes And Return Forest (0)	2025.02.03
Step-By-Step Directions From a Binary Tree Node to Another (0)	2025.02.03
Create Binary Tree From Descriptions (0)	2025.02.03

짬뽕얼큰하게

,

Delete Nodes And Return Forest

알고리즘 2025. 2. 3. 07:32

Leetcode Problem:
Delete Nodes And Return Forest

Summary

Given a binary tree and a list of values to delete, return the roots of the trees in the remaining forest.

Approach

We use a depth-first search approach to traverse the binary tree
We first create a vector to store the roots of the trees in the remaining forest
Then, we iterate over the list of values to delete and for each value, we traverse the binary tree to find and delete the nodes with the given value
After deleting the nodes, we check if the node has children
If it does, we add the children to the vector of roots
Finally, we return the vector of roots.

Complexity

O(n * m) where n is the number of nodes in the binary tree and m is the number of values to delete.

Explain

The solution code defines a class Solution with a method delNodes that takes the root of a binary tree and a vector of values to delete as input
It uses a helper function traversal to delete the nodes with the given values
The traversal function checks if the current node has the given value and if so, it deletes the node and its children
If the node does not have the given value, it recursively calls itself on the left and right children of the node
After deleting the nodes, it checks if the node has children and if so, it adds the children to the vector of roots
The method returns the vector of roots.

Solution Code:


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool traversal(TreeNode* ptr, vector &ans, int target){
        if(ptr == nullptr) return false;
        if(ptr->val ==  target){
            for(int i = 0 ; i < ans.size(); i++){
                if (ans[i] == nullptr) continue;
                if (ans[i]->val == target){
                    ans[i] = nullptr;
                    break;
                }
            }
            if (ptr->left){
                ans.push_back(ptr->left);
            }
            if (ptr->right){
                ans.push_back(ptr->right);
            }
            return true;
        }

        if (traversal(ptr->left, ans, target)){
            ptr->left = nullptr;
        }
        if (traversal(ptr->right, ans, target)){
            ptr->right = nullptr;
        }
        return false;
    }
    vector delNodes(TreeNode* root, vector& to_delete) {
        vector ans = {root};
        for(int i = 0 ; i < to_delete.size(); i++){
            for(int j = 0 ; j < ans.size(); j++){
                traversal(ans[j], ans, to_delete[i]);
            }
        }
        vector ans2;
        for(int i = 0 ; i < ans.size(); i++){
            if (ans[i] == nullptr) continue;
            ans2.push_back(ans[i]);
        }
        return ans2;
    }
};

'알고리즘' 카테고리의 다른 글

Build a Matrix With Conditions (0)	2025.02.03
Number of Good Leaf Nodes Pairs (0)	2025.02.03
Step-By-Step Directions From a Binary Tree Node to Another (0)	2025.02.03
Create Binary Tree From Descriptions (0)	2025.02.03
Maximum Score From Removing Substrings (0)	2025.02.02

짬뽕얼큰하게

,

Step-By-Step Directions From a Binary Tree Node to Another

알고리즘 2025. 2. 3. 07:28

Leetcode Problem:
Step-By-Step Directions From a Binary Tree Node to Another

Summary

This problem requires finding the shortest path from a start node to a destination node in a binary tree
The path is represented as a string of 'L', 'R', and 'U' characters, where 'L' represents going to the left child, 'R' represents going to the right child, and 'U' represents going to the parent node.

Approach

This solution uses a depth-first search approach to find the shortest path from the start node to the destination node
It first searches for the start node and stores its path in the rootToStart vector
Then, it searches for the destination node and stores its path in the rootToDest vector
Finally, it constructs the shortest path by concatenating the 'U' characters to the start of the path and the 'L' and 'R' characters to the end of the path.

Complexity

The time complexity of this solution is O(n), where n is the number of nodes in the tree
This is because each node is visited once during the depth-first search
The space complexity is also O(n) due to the storage of the paths in the rootToStart and rootToDest vectors.

Explain

The solution uses two vectors, rootToStart and rootToDest, to store the paths from the start node to the destination node
The searchPath function is used to search for the start node and the destination node, and it uses a depth-first search approach to traverse the tree
The getDirections function is used to construct the shortest path by concatenating the 'U' characters to the start of the path and the 'L' and 'R' characters to the end of the path.

Solution Code:


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

vector rootToStart;
vector rootToDest;
vector rootToDestChar;
class Solution {
public:
    bool searchPath(TreeNode* ptr, int dest, vector &path){
        if (ptr == nullptr) return false;
        if (ptr->val == dest) {
            path.push_back(dest);
            return true;
        }
        path.push_back(ptr->val);
        rootToDestChar.push_back('L');
        if (searchPath(ptr->left, dest, path)){
            return true;
        }
        rootToDestChar.pop_back();
        rootToDestChar.push_back('R');
        if (searchPath(ptr->right, dest, path)){
            return true;
        }
        rootToDestChar.pop_back();
        path.pop_back();
        return false;
    }
    string getDirections(TreeNode* root, int startValue, int destValue) {
        rootToStart.clear();
        rootToDest.clear();
        searchPath(root, startValue, rootToStart);
        rootToDestChar.clear();
        searchPath(root, destValue, rootToDest);
        
        string res = "";
        int cnt = 0;
        while(cnt < rootToStart.size() && cnt < rootToDest.size() && rootToStart[cnt] == rootToDest[cnt]) cnt++;
        for(int i = 0; i < rootToStart.size() - cnt; i++){
            res += "U";
        }
        for(int i = cnt-1 ; i < rootToDestChar.size(); i++){
            res += rootToDestChar[i];
        }
        return res;
    }
};

'알고리즘' 카테고리의 다른 글

Number of Good Leaf Nodes Pairs (0)	2025.02.03
Delete Nodes And Return Forest (0)	2025.02.03
Create Binary Tree From Descriptions (0)	2025.02.03
Maximum Score From Removing Substrings (0)	2025.02.02
Reverse Substrings Between Each Pair of Parentheses (0)	2025.02.02

짬뽕얼큰하게

,

Create Binary Tree From Descriptions

알고리즘 2025. 2. 3. 07:24

Leetcode Problem:
Create Binary Tree From Descriptions

Summary

Constructing a binary tree from given descriptions of parent-child relationships.

Approach

We use a map to store the nodes of the binary tree, where the key is the node value and the value is a pointer to the node
We also use another map to store the parent of each node
We iterate through the descriptions and create the nodes and their children accordingly
Finally, we find the root of the tree by following the parent map until we reach a node that has no parent.

Complexity

O(n), where n is the number of descriptions, because we make a single pass through the descriptions to create the nodes and their children.

Explain

The solution starts by creating two maps: `myMap` to store the nodes and `parentMap` to store the parent of each node
We then iterate through the descriptions and create the nodes and their children accordingly
If a node does not exist in `myMap`, we create it
We then set the left or right child of the parent node based on the value of `isLeft`
Finally, we find the root of the tree by following the parent map until we reach a node that has no parent
The time complexity is O(n) because we make a single pass through the descriptions to create the nodes and their children.

Solution Code:


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* createBinaryTree(vector>& descriptions) {
        map myMap;
        map parentMap;
        int root = descriptions[0][0];
        for(int i = 0 ; i < descriptions.size(); i++){
            int parent = descriptions[i][0];
            int child = descriptions[i][1];
            int isLeft = descriptions[i][2];
            parentMap[child] = parent;
            if (myMap.find(parent) == myMap.end()){
                myMap[parent] = new TreeNode(parent);
            }
            if (myMap.find(child) == myMap.end()){
                myMap[child] = new TreeNode(child);
            }
            if (isLeft == 1){
                myMap[parent]->left = myMap[child];
            } else {
                myMap[parent]->right = myMap[child];
            }
        }
        while(parentMap.find(root) != parentMap.end()){
            root = parentMap[root];
        }
        return myMap[root];
    }
};

'알고리즘' 카테고리의 다른 글

Delete Nodes And Return Forest (0)	2025.02.03
Step-By-Step Directions From a Binary Tree Node to Another (0)	2025.02.03
Maximum Score From Removing Substrings (0)	2025.02.02
Reverse Substrings Between Each Pair of Parentheses (0)	2025.02.02
Crawler Log Folder (0)	2025.02.02

짬뽕얼큰하게

,

일	월	화	수	목	금	토
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

'2025/02/03'에 해당되는 글 8건

Leetcode Problem: Longest Strictly Increasing or Strictly Decreasing Subarray

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Sort Array by Increasing Frequency

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Sort the People

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Build a Matrix With Conditions

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Number of Good Leaf Nodes Pairs

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Delete Nodes And Return Forest

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Step-By-Step Directions From a Binary Tree Node to Another

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

Leetcode Problem: Create Binary Tree From Descriptions

Summary

Approach

Complexity

Explain

Solution Code:

'알고리즘' 카테고리의 다른 글

공지사항

카테고리

태그목록

글 보관함

달력

링크

짬뽕얼큰하게

LATEST FROM OUR BLOG

LATEST COMMENTS

BLOG VISITORS

티스토리툴바

Leetcode Problem:
Longest Strictly Increasing or Strictly Decreasing Subarray

Leetcode Problem:
Sort Array by Increasing Frequency

Leetcode Problem:
Sort the People

Leetcode Problem:
Build a Matrix With Conditions

Leetcode Problem:
Number of Good Leaf Nodes Pairs

Leetcode Problem:
Delete Nodes And Return Forest

Leetcode Problem:
Step-By-Step Directions From a Binary Tree Node to Another

Leetcode Problem:
Create Binary Tree From Descriptions