671 - 675

Author: Mia Xia

671. Second Minimum Node in a Binary Tree.js

@@ -0,0 +1,45 @@
+// Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.val) always holds.
+// Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' value in the whole tree.
+// If no such second minimum value exists, output -1 instead.
+
+// Example 1:
+// Input: 
+//     2
+//    / \
+//   2   5
+//      / \
+//     5   7
+// Output: 5
+// Explanation: The smallest value is 2, the second smallest value is 5.
+ 
+// Example 2:
+// Input: 
+//     2
+//    / \
+//   2   2
+// Output: -1
+// Explanation: The smallest value is 2, but there isn't any second smallest value.
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var findSecondMinimumValue = (root) => {
+    let valSet = new Set();
+    const helper = node => {
+        if (!valSet.has(node.val)) valSet.add(node.val);
+        if (node.left) helper(node.left);
+        if (node.right) helper(node.right);
+    };
+    helper(root);
+    valSet = Array.from(valSet).sort((a, b) => a - b).sort();
+    if (valSet.length > 1) return valSet[1];
+    else return -1;
+};

672. Bulb Switcher II.js

@@ -0,0 +1,115 @@
+// There is a room with n lights which are turned on initially and 4 buttons on the wall. After performing exactly m unknown operations towards buttons, you need to return how many different kinds of status of the n lights could be.
+// Suppose n lights are labeled as number [1, 2, 3 ..., n], function of these 4 buttons are given below:
+// Flip all the lights.
+// Flip lights with even numbers.
+// Flip lights with odd numbers.
+// Flip lights with (3k + 1) numbers, k = 0, 1, 2, ...
+ 
+// Example 1:
+// Input: n = 1, m = 1.
+// Output: 2
+// Explanation: Status can be: [on], [off]
+ 
+// Example 2:
+// Input: n = 2, m = 1.
+// Output: 3
+// Explanation: Status can be: [on, off], [off, on], [off, off]
+ 
+// Example 3:
+// Input: n = 3, m = 1.
+// Output: 4
+// Explanation: Status can be: [off, on, off], [on, off, on], [off, off, off], [off, on, on].
+ 
+// Note: n and m both fit in range [0, 1000].
+
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+var flipAll = (lights) => {
+    var newLights = lights.slice();
+    for (let i = 0; i < newLights.length; i++) {
+        if (newLights[i] === 1) newLights[i] = 0;
+        else newLights[i] = 1;
+    }
+    return newLights;
+};
+
+var flipEven = (lights) => {
+    var newLights = lights.slice();
+    for (let i = 0; i < newLights.length; i++) {
+        if ((i + 1) % 2 === 0) {
+            if (newLights[i] === 1) newLights[i] = 0;
+            else newLights[i] = 1;
+        }
+    }
+    return newLights;
+};
+
+var flipOdd = (lights) =>{
+    var newLights = lights.slice();
+    for (let i = 0; i < newLights.length; i++) {
+        if ((i + 1) % 2 !== 0) {
+            if (newLights[i] === 1) newLights[i] = 0;
+            else newLights[i] = 1;
+        }
+    }
+    return newLights;
+};
+
+var flipNumber = (lights) => {
+    var newLights = lights.slice();
+    for (let i = 0; i < newLights.length; i++) {
+        if ((i + 1) % 3 === 1) {
+            if (newLights[i] === 1) newLights[i] = 0;
+            else newLights[i] = 1;
+        }
+    }
+    return newLights;
+};
+
+var deleteDuplicatedCase = (cases) => {
+    var newCases = cases.slice();
+    for (let i = 0; i < newCases.length; i++) {
+        for (let j = i + 1; j < newCases.length; j++) {
+            let isSame = true;
+            for (let index = 0; index < newCases[i].length; index++) {
+                if (newCases[i][index] !== newCases[j][index]) {
+                    isSame = false;
+                }
+            }
+            if (isSame) {
+                newCases.splice(j, 1);
+                j--;
+            }
+        }
+    }
+    return newCases;
+};
+
+var flipLights = (n, m) => {
+    var lights = []
+    var cases = []
+    if (m === 0) return 1;
+    for (let i = 0; i < n; i++) lights.push(1);
+    for (let i = 0; i < m; i++) {
+        const casesLength = cases.length
+        if (i === 0) {
+            cases.push(flipAll(lights));
+            cases.push(flipEven(lights));
+            cases.push(flipOdd(lights));
+            cases.push(flipNumber(lights));
+        } else {
+            for (let j = 0; j < casesLength; j++) {
+                cases.push(flipAll(cases[j]));
+                cases.push(flipEven(cases[j]));
+                cases.push(flipOdd(cases[j]));
+                cases.push(flipNumber(cases[j]));
+            }
+        }
+        cases.splice(0, casesLength)
+        cases = deleteDuplicatedCase(cases).slice();
+    }
+    return cases.length;
+};

673. Number of Longest Increasing Subsequence.js

@@ -0,0 +1,48 @@
+// Given an unsorted array of integers, find the number of longest increasing subsequence.
+
+// Example 1:
+// Input: [1,3,5,4,7]
+// Output: 2
+// Explanation: The two longest increasing subsequence are [1, 3, 4, 7] and [1, 3, 5, 7].
+
+// Example 2:
+// Input: [2,2,2,2,2]
+// Output: 5
+// Explanation: The length of longest continuous increasing subsequence is 1, and there are 5 subsequences' length is 1, so output 5.
+// Note: Length of the given array will be not exceed 2000 and the answer is guaranteed to be fit in 32-bit signed int.
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findNumberOfLIS = (nums) => {
+    if (!nums || nums.length === 0) return 0;
+    if (nums.length === 1) return 1;
+    
+    const N = nums.length;
+    const len = new Array(N);
+    const cnt = new Array(N);
+    let maxLen = 0, ans = 0;
+    
+    for (let i = 0; i < N; i++){
+        len[i] = 1;
+        cnt[i] = 1;
+        for (let j = 0; j < i; j++){
+            if (nums[j] < nums[i]){
+                if (len[j] + 1 > len[i]){
+                    len[i] = len[j] + 1;
+                    cnt[i] = cnt[j];
+                } else if (len[j] + 1 === len[i]){
+                    cnt[i] += cnt[j];
+                }
+            }
+        }
+        if (len[i] === maxLen){
+            ans += cnt[i];
+        } else if (len[i] > maxLen){
+            maxLen = len[i];
+            ans = cnt[i];
+        }  
+    }
+    return ans;
+};

674. Longest Continuous Increasing Subsequence.js

@@ -0,0 +1,36 @@
+// Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).
+
+// Example 1:
+// Input: [1,3,5,4,7]
+// Output: 3
+// Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. 
+// Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. 
+
+// Example 2:
+// Input: [2,2,2,2,2]
+// Output: 1
+// Explanation: The longest continuous increasing subsequence is [2], its length is 1. 
+// Note: Length of the array will not exceed 10,000.
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findLengthOfLCIS = (nums) => {
+    let left = 0, right = 1, limit = nums.length - 1, max = 0, result = [];
+    if (limit < 1) return nums.length;
+  
+    while (left < right && right <= limit) {
+      if (nums[left] < nums[right]) {
+        let active = true;
+        max++
+      } else {
+        result.push(max);
+        max = 0;
+      }
+      left++;
+      right++;
+    }
+    result.push(max);
+    return Math.max(...result) + 1
+  }

675. Cut Off Trees for Golf Event.js

@@ -0,0 +1,124 @@
+// You are asked to cut off trees in a forest for a golf event. The forest is represented as a non-negative 2D map, in this map:
+// 0 represents the obstacle can't be reached.
+// 1 represents the ground can be walked through.
+// The place with number bigger than 1 represents a tree can be walked through, and this positive number represents the tree's height.
+// You are asked to cut off all the trees in this forest in the order of tree's height - always cut off the tree with lowest height first. And after cutting, the original place has the tree will become a grass (value 1).
+// You will start from the point (0, 0) and you should output the minimum steps you need to walk to cut off all the trees. If you can't cut off all the trees, output -1 in that situation.
+// You are guaranteed that no two trees have the same height and there is at least one tree needs to be cut off.
+
+// Example 1:
+// Input: 
+// [
+//  [1,2,3],
+//  [0,0,4],
+//  [7,6,5]
+// ]
+// Output: 6
+ 
+// Example 2:
+// Input: 
+// [
+//  [1,2,3],
+//  [0,0,0],
+//  [7,6,5]
+// ]
+// Output: -1
+ 
+// Example 3:
+// Input: 
+// [
+//  [2,3,4],
+//  [0,0,5],
+//  [8,7,6]
+// ]
+// Output: 6
+// Explanation: You started from the point (0,0) and you can cut off the tree in (0,0) directly without walking.
+
+// Hint: size of the given matrix will not exceed 50x50.
+
+/**
+ * @param {number[][]} forest
+ * @return {number}
+ */
+var Tree = function(height, row, col) {
+    return {
+        height, 
+        location: new Location(row, col)
+    };
+}
+
+var Location = function(row, col) {
+    return {
+        row,
+        col
+    }
+}
+var ListNode = function(val) {
+    return {
+        val,
+        next: null
+    }
+}
+
+var cutOffTree = (forest) => {
+    const height = forest.length;
+    const width = forest[0].length;
+    const trees = [];
+    
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            if (forest[row][col] > 1) {
+                trees.push(new Tree(forest[row][col], row, col));
+            }
+        }
+    }
+    trees.sort((a, b) => b.height - a.height);
+    
+    let location = new Location(0, 0);
+    let distance = 0;
+    
+    while (trees.length) {
+        let tree = trees.pop();
+        let travelled = findTree(forest, tree, location);
+        if (travelled >= 0) {
+            distance += travelled;
+            location = tree.location;
+        } else {
+            return -1;
+        }
+    }
+    return distance;
+};
+
+var findTree = (forest, tree, location) => {
+    const visited = {};
+    const height = forest.length;
+    const width = forest[0].length;
+    
+    let head = new ListNode([location, 0]);
+    let tail = head;
+    
+    while (head) {
+        let [current, distance] = head.val;
+        if (current.row < 0 || current.col < 0 || current.row >= height || current.col >= width) {
+        } else if (forest[current.row][current.col] == 0) {
+        } else if (visited[`${current.row}.${current.col}`]) {
+        } else {
+            if (tree.location.row == current.row && tree.location.col == current.col) {
+                return distance;  
+            } else { 
+                tail.next = new ListNode([new Location(current.row - 1, current.col), distance + 1]);
+                tail = tail.next;
+                tail.next = new ListNode([new Location(current.row, current.col + 1), distance + 1]);
+                tail = tail.next;
+                tail.next = new ListNode([new Location(current.row + 1, current.col), distance + 1]);
+                tail = tail.next;
+                tail.next = new ListNode([new Location(current.row, current.col - 1), distance + 1]);
+                tail = tail.next;
+            }
+            visited[`${current.row}.${current.col}`] = true;
+        }
+        head = head.next;
+    }
+    return -1;
+}