add more solutions

Author: chihungyu1116

123 Best Time to Buy and Sell Stock III.js

@@ -0,0 +1,41 @@
+// Say you have an array for which the ith element is the price of a given stock on day i.
+
+// Design an algorithm to find the maximum profit. You may complete at most two transactions.
+
+// Note:
+// You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+
+// http://www.cnblogs.com/springfor/p/3877068.html
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    // Calculate MaxProfit from 0 to x and MaxProfit from x + 1 to len - 1;
+    var profitFromZeroToX = [];
+    var profitFromXToEnd = [];
+    var min = prices[0];
+
+    // get max profit from 0 to x
+    for(var x = 1; x < prices.length; x++) {
+        var price = prices[x];
+        min = Math.min(price, min);
+        profitFromZeroToX[x] = Math.max(profitFromZeroToX[x - 1] || 0, price - min);
+    }
+    // get max profit from i + 1 to end
+    var max = prices[prices.length - 1];
+    for(x = prices.length - 2; x >= 0; x--) {
+        price = prices[x];
+        max = Math.max(price, max);
+        profitFromXToEnd[x] = Math.max(profitFromXToEnd[x + 1] || 0, max - price);
+    }
+    
+    var maxProfit = 0;
+    for(x = 0; x < prices.length; x++) {
+        var maxProfitSeperateAtX = (profitFromZeroToX[x] || 0) + (profitFromXToEnd[x] || 0);
+        maxProfit = Math.max(maxProfitSeperateAtX, maxProfit);
+    }
+    
+    return maxProfit;
+};

126 Word Ladder II.js

@@ -0,0 +1,30 @@
+// Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:
+
+// Only one letter can be changed at a time
+// Each intermediate word must exist in the word list
+// For example,
+
+// Given:
+// beginWord = "hit"
+// endWord = "cog"
+// wordList = ["hot","dot","dog","lot","log"]
+// Return
+//   [
+//     ["hit","hot","dot","dog","cog"],
+//     ["hit","hot","lot","log","cog"]
+//   ]
+// Note:
+// All words have the same length.
+// All words contain only lowercase alphabetic characters.
+
+/**
+ * @param {string} beginWord
+ * @param {string} endWord
+ * @param {Set} wordList
+ *   Note: wordList is a Set object, see:
+ *   https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+ * @return {string[][]}
+ */
+var findLadders = function(beginWord, endWord, wordList) {
+    
+};

127 Word Ladder.js

@@ -1,57 +1,68 @@
+// Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
+
+// Only one letter can be changed at a time
+// Each intermediate word must exist in the word list
+// For example,
+
+// Given:
+// beginWord = "hit"
+// endWord = "cog"
+// wordList = ["hot","dot","dog","lot","log"]
+// As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+// return its length 5.
+
+// Note:
+// Return 0 if there is no such transformation sequence.
+// All words have the same length.
+// All words contain only lowercase alphabetic characters.
+// Amazon LinkedIn Snapchat Facebook Yelp
+
+
 // Leetcode 127
 // Language: Javascript
 // Problem: https://leetcode.com/problems/word-ladder/
 // Author: Chihung Yu
+
 /**
  * @param {string} beginWord
  * @param {string} endWord
- * @param {set<string>} wordDict
+ * @param {Set} wordList
+ *   Note: wordList is a Set object, see:
+ *   https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
  * @return {number}
  */
- 
-String.prototype.replaceAt = function(i, c){
-    return this.substring(0,i) + c + this.substring(i+1);
-};
- 
-var ladderLength = function(beginWord, endWord, wordDict) {
-    if(beginWord === null || endWord === null || beginWord.length !== endWord.length || beginWord.length === 0 || endWord.length === 0){
-        return 0;
-    }  
-    
-    var queue = [];
-    queue.push(beginWord);
+var ladderLength = function(beginWord, endWord, wordList) {
     var visited = new Set();
-    visited.add(beginWord);
-    
+    var queue = [];
     var level = 1;
-    var curLvlCnt = 1;
-    var nextLvlCnt = 0;
+    var letters = 'abcdefghijklmnopqrstuvwxyz';
+    queue.push(beginWord);
+    visited.add(beginWord);    
 
-    while(queue.length !== 0){
-        var cur = queue.shift();
-        curLvlCnt--;
+    while(queue.length > 0) {
 
-        for(var i = 0; i < cur.length; i++){
-            for(var j = 0; j < 26; j++){
-                var char = String.fromCharCode('a'.charCodeAt(0) + j);
-                var word = cur.replaceAt(i,char);
-                
-                if(word === endWord){
-                    return level + 1;
-                }
-                if(wordDict.has(word) && !visited.has(word)){
-                    nextLvlCnt++;
-                    queue.push(word);
-                    visited.add(word);
+        var len = queue.length;
+        
+        for(var i = 0; i < len; i++) {
+            var word = queue.shift();
+            
+            for(var j = 0; j < word.length; j++) {
+                for(var k = 0; k < letters.length; k++) {
+                    var newWord = word.substring(0, j) + letters[k] + word.substring(j + 1);
+                    
+                    if(newWord === endWord) {
+                        return level + 1;
+                    }
+                    if(wordList.has(newWord) && !visited.has(newWord)) {
+                        queue.push(newWord);
+                        visited.add(newWord);
+                    }
                 }
             }
         }
-        if(curLvlCnt === 0){
-            curLvlCnt = nextLvlCnt;
-            nextLvlCnt = 0;
-            level++;
-        }
+        
+        level++;
     }
+    
     return 0;
-};
-
+};

133 Clone Graph.js

@@ -1,3 +1,26 @@
+// Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.
+
+
+// OJ's undirected graph serialization:
+// Nodes are labeled uniquely.
+
+// We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.
+// As an example, consider the serialized graph {0,1,2#1,2#2,2}.
+
+// The graph has a total of three nodes, and therefore contains three parts as separated by #.
+
+// First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
+// Second node is labeled as 1. Connect node 1 to node 2.
+// Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.
+// Visually, the graph looks like the following:
+
+//        1
+//       / \
+//      /   \
+//     0 --- 2
+//          / \
+//          \_/
+
 /**
  * Definition for undirected graph.
  * function UndirectedGraphNode(label) {

138 Copy List With Random Pointer.js

@@ -0,0 +1,46 @@
+// A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.
+
+// Return a deep copy of the list.
+
+// Hide Company Tags Amazon Microsoft Bloomberg Uber
+// Show Tags
+// Show Similar Problems
+
+
+/**
+ * Definition for singly-linked list with a random pointer.
+ * function RandomListNode(label) {
+ *     this.label = label;
+ *     this.next = this.random = null;
+ * }
+ */
+
+/**
+ * @param {RandomListNode} head
+ * @return {RandomListNode}
+ */
+var copyRandomList = function(head) {
+  var hashMap = {};
+  var newHead = new RandomListNode(0);
+  newHead.next = copyList(head);
+  
+  function copyList(node)   {
+    if(node === null) {
+        return node;
+    }
+      
+    if(hashMap[node.label]) {
+        return hashMap[node.label];
+    }
+    
+    var newNode = new RandomListNode(node.label);
+    hashMap[node.label] = newNode;
+    
+    newNode.next = copyList(node.next);
+    newNode.random = copyList(node.random);
+    
+    return newNode;
+  }
+  
+  return newHead.next;
+};

146 LRU Cache.js

@@ -1,7 +1,3 @@
-// Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
-
-// get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
-// set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
 class Node {
     constructor(key, val) {
         this.key = key;
@@ -18,7 +14,7 @@ var LRUCache = function(capacity) {
     this.map = new Map();
     this.head = null;
     this.tail = null;
-    this.size = capacity;
+    this.capacity = capacity;
     this.curSize = 0;
 };
 
@@ -27,12 +23,11 @@ var LRUCache = function(capacity) {
  * @returns {number}
  */
 LRUCache.prototype.get = function(key) {
-    if (!this.map.get(key)) {
+    let node = this.map.get(key);
+    if (!node) {
         return -1;
     }
 
-    let node = this.map.get(key);
-    
     if (node === this.head) {
         return node.val;
     }
@@ -70,7 +65,7 @@ LRUCache.prototype.set = function(key, value) {
     }
 
     this.head = newNode;
-    this.curSize++;
+    // this.curSize++;
 
     // update
     if (this.map.get(key)) {
@@ -84,11 +79,9 @@ LRUCache.prototype.set = function(key, value) {
             oldNode.prev.next = oldNode.next;
             oldNode.next.prev = oldNode.prev;
         }
-        
-        this.curSize--;
-        
     } else {
-        if (this.curSize > this.size) {
+        this.curSize++
+        if (this.curSize > this.capacity) {
             //delete tail
             this.map.delete(this.tail.key);
             this.tail = this.tail.prev;

148 Sort List.js

@@ -1,3 +1,5 @@
+// Sort a linked list in O(n log n) time using constant space complexity.
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {
@@ -28,13 +30,18 @@ var sortList = function(head) {
     return newHead;
 
     function sort(len) {
+        // there will be no case of len = 0 which is caused by 1/2
         if(len === 1) {
             var temp = head;
-            head = head.next;
+            // !!! important: moving pointer to the next
+            // e.g. 1->2->3->4
+            // head-> 1
+            // now head will be point to 2
+            head = head.next; 
             temp.next = null;
             return temp;
         }
-        
+        // there will be no case of len = 0 which is caused by 1/2
         var leftHead = sort(parseInt(len/2));
         var rightHead = sort(len - parseInt(len/2));
         var newHead = merge(leftHead, rightHead);

186 Reverse Words in a String II.js

@@ -0,0 +1,37 @@
+// Given an input string, reverse the string word by word. A word is defined as a sequence of non-space characters.
+
+// The input string does not contain leading or trailing spaces and the words are always separated by a single space.
+
+// For example,
+// Given s = "the sky is blue",
+// return "blue is sky the".
+
+// Could you do it in-place without allocating extra space?
+
+/**
+ * @param {character[]} str
+ * @return {void} Do not return anything, modify the string in-place instead.
+ */
+var reverseWords = function(str) {
+    var arr = str;
+    
+    reverse(arr, 0, arr.length - 1);
+    var last = 0;
+  
+    for(var i = 0; i <= arr.length; i++) {
+        if(arr[i] === ' ' || i === arr.length) {
+            reverse(arr, last, i - 1);
+            last = i + 1;
+        }
+    }
+    
+    function reverse(arr, beg, end) {
+        while(beg < end) {
+            var tmp = str[beg];
+            str[beg] = str[end];
+            str[end] = tmp;
+            beg++;
+            end--;
+        }    
+    }  
+};