Merge branch 'master' of https://github.com/siryang/leetcode

Author: siryang

README.md

@@ -5,6 +5,9 @@ LeetCode C++ Solutions
 
 | Title | Solution | Add Date | Difficulty |
 | ----- | -------- | -------- | ---------- |
+|[Read N Characters Given Read4](https://oj.leetcode.com/problems/read-n-characters-given-read4/) :books: | [C++](./src/readNCharactersGivenRead4/readNCharactersGivenRead4.cpp)|2014/11/19|Easy|
+|[Binary Tree Upside Down](https://oj.leetcode.com/problems/binary-tree-upside-down/) :books: | [C++](./src/binaryTreeUpsideDown/binaryTreeUpsideDown.cpp)|2014/11/16|Medium|
+|[Min Stack](https://oj.leetcode.com/problems/min-stack/)| [C++](./src/minStack/minStack.cpp)|2014/11/09|Easy|
 |[Find Minimum in Rotated Sorted Array II](https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/)| [C++](./src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.II.cpp)|2014/10/20|Hard|
 |[Find Minimum in Rotated Sorted Array](https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array/)| [C++](./src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp)|2014/10/15|Medium|
 |[Maximum Product Subarray](https://oj.leetcode.com/problems/maximum-product-subarray/)| [C++](./src/maximumProductSubarray/maximumProductSubarray.cpp)|2014/9/23|Medium|

scripts/README.md

@@ -0,0 +1,7 @@
+Some Scripts
+============
+
+`basic.sh` - use to insert the basic comment at the beginning of the srouce file
+
+`problem.sh` - grab the problem descriptions from oj.leetcode.com and add it into the soure file.
+

scripts/basic.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+time=`stat -c %x $2 | awk '{print \$1}'`
+
+sed -i '1i\'"// Source : $1" $2
+sed -i '2i\'"// Author : Hao Chen" $2
+sed -i '3i\'"// Date   : $time\n" $2

scripts/problem.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+grep Source $1 | sed -e "s/\/\/ Source : //g" | xargs -I'{}' xidel {} -q -e "css('div.question-content')"  | grep -v '                ' |sed '/^$/N;/^\n$/D'  |sed 's/^/* /' | sed "1i/*$(printf '%.0s*' {0..80}) \n* " | sed "\$a $(printf '%.0s*' {0..80})*/\n" > /tmp/tmp.txt; sed -i '4 r /tmp/tmp.txt' $1 

src/addTwoNumbers/addTwoNumbers.cpp

@@ -26,7 +26,7 @@ class Solution {
 public:
     ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
         int x=0, y=0, z=0;
-        ListNode *h=NULL, *t=NULL;
+        ListNode *h=NULL, **t=&h;
 
         while (l1!=NULL || l2!=NULL){
             x = getValueAndMoveNext(&l1);
@@ -35,20 +35,15 @@ class Solution {
             z = z + x + y;
 
             ListNode *node = new ListNode(z%10);
-            if (h == NULL){
-                h = t = node;
-            }else{
-                t->next = node;
-                t = node;
-            }
+            *t = node;
+            t = (&node->next);
 
             z = z/10;
         }
 
-        while (z > 0) {
+        if (z > 0) {
             ListNode *node = new ListNode(z%10);
-            t->next = node;
-            z = z/10;
+            *t = node;
         }
 
         return h;

src/anagrams/anagrams.cpp

@@ -14,16 +14,17 @@ class Solution {
 public:
     vector<string> anagrams(vector<string> &strs) {
         vector<string> result;
-        map<string, string> m;
+        map<string, int> m;
         for(int i=0; i<strs.size(); i++){
             string word = strs[i];
-            sort(word.begin(), word.end());
+            //sort it can easy to check they are anagrams or not
+            sort(word.begin(), word.end());  
             if (m.find(word)==m.end()){
-                m[word] = strs[i];
+                m[word] = i;
             }else{
-                if (m[word]!="#"){
-                    result.push_back(m[word]);
-                    m[word]="#";
+                if (m[word]>=0){
+                    result.push_back(strs[m[word]]);
+                    m[word]=-1;
                 }
                 result.push_back(strs[i]);
             }

src/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.cpp

@@ -58,7 +58,7 @@ int maxPathSum(TreeNode *root, int& maxSum ) {
 }
 
 int maxPathSum(TreeNode *root) {
-    #define INT_MIN     -2147483648
+    #define INT_MIN     (-2147483647 - 1)
     int maxSum = INT_MIN;
     maxPathSum(root, maxSum);
     return maxSum;

src/binaryTreeUpsideDown/binaryTreeUpsideDown.cpp

@@ -0,0 +1,69 @@
+// Source : https://oj.leetcode.com/problems/binary-tree-upside-down/
+// Author : Hao Chen
+// Date   : 2014-11-17
+
+/********************************************************************************** 
+* Given a binary tree where all the right nodes are either leaf nodes with 
+* a sibling (a left node that shares the same parent node) or empty, 
+* 
+* Flip it upside down and turn it into a tree where the original right nodes turned into left leaf nodes. 
+* Return the new root.
+* 
+* For example:
+* Given a binary tree {1,2,3,4,5},
+*     1
+*    / \
+*   2   3
+*  / \
+* 4   5
+* return the root of the binary tree [4,5,2,#,#,3,1].
+*    4
+*   / \
+*  5   2
+*     / \
+*    3   1  
+* confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ. 
+* 
+**********************************************************************************/
+
+
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *upsideDownBinaryTree(TreeNode *root) {
+        //using a dummy node to help to store the new tree      
+        TreeNode dummy(0);
+        TreeNode *head =  &dummy, *left=NULL, *right=NULL;
+
+        while ( root!=NULL ) {
+            //find the right & left
+            left = root->right;
+            right = root;
+            
+            //move root the next
+            root = root->left;
+            
+            //replace the right with current root
+            right->left = head->left;
+            right->right = head->right;
+            
+            //move the dummy to the root
+            dummy.right = right;
+            dummy.left = left;
+            
+            //reset the head to the root
+            head = &dummy;
+    
+        }
+        
+        return head->right;
+    }
+};

src/distinctSubsequences/distinctSubsequences.cpp

@@ -91,12 +91,12 @@ int numDistinct1(string S, string T) {
 //=====================
 //
 //  The idea here is an optimization of above idea 
-//  (It might be difficult to understand if you don't know the above idea)
+//  (It might be difficult to understand if you don't understand the above idea)
 //
 //    For example:
 //
 //      S = "abbbc"  T="abb"
-//      posMap = { [a]={0}, [b]={1,2} }
+//      posMap = { [a]={0}, [b]={2,1} } <- the map of T's every char.
 //      numOfSubSeq = {1, 0, 0, 0 }
 //
 //      S[0] is 'a', pos is 0,  numOfSubSeq = {1, 0+1, 0, 0};

src/firstMissingPositive/firstMissingPositive.cpp

@@ -14,15 +14,47 @@
 * 
 *               
 **********************************************************************************/
-
+#include <stdlib.h>
+#include <time.h>
 #include <iostream>
 #include <map>
 using namespace std;
 
 #define INT_MAX      2147483647
 
 /*
- *    The idea is simple:
+ *  Idea:
+ * 
+ *    We can move the num to the place whcih the index is the num. 
+ *   
+ *    for example,  (considering the array is zero-based.
+ *       1 => A[0], 2 => A[1], 3=>A[2]
+ *   
+ *    Then, we can go through the array check the i+1 == A[i], if not ,just return i+1;
+ *   
+ *    This solution comes from StackOverflow.com
+ *    http://stackoverflow.com/questions/1586858/find-the-smallest-integer-not-in-a-list
+*/
+int firstMissingPositive_move(int A[], int n) {
+    if (n<=0) return 1;
+    int num;
+    for(int i=0; i<n; i++) {
+        num = A[i];
+        while (num>0 && num<n && A[num-1]!=num) {
+            swap(A[i], A[num-1]);
+            num = A[i];
+        }
+    }
+    for (int i=0; i<n; i++){
+        if (i+1 != A[i]){
+            return i+1;
+        }
+    }
+    return n+1;
+}
+
+/*
+ *    The idea is simple: 
  *
  *    1) put all of number into a map.
  *    2) for each number a[i] in array, remove its continous number in the map
@@ -36,8 +68,10 @@ using namespace std;
  *
  *    However, we missed 1, so, we have to add dummy number 0 whatever.
  *
+ *    NOTE: this solution is not constant space slution!!!!
+ *
  */
-int firstMissingPositive(int A[], int n) {
+int firstMissingPositive_map(int A[], int n) {
     map<int, int> cache;
     for(int i=0; i<n; i++){
         cache[A[i]] = i;
@@ -51,13 +85,13 @@ int firstMissingPositive(int A[], int n) {
     int miss = INT_MAX;
     int x;
     for (int i=-1; i<n && cache.size()>0; i++){
-        
+
         if (i == -1){
             x = 0; //checking dummy
         }else{
             x = A[i];
         } 
-    
+
         if ( cache.find(x)==cache.end() ){
             continue;
         }
@@ -78,32 +112,66 @@ int firstMissingPositive(int A[], int n) {
             miss = num;
         }
     }
-    
+
 
     return miss;
 }
 
+int firstMissingPositive(int A[], int n) {
+    srand(time(0));
+    if (rand()%2){
+        return firstMissingPositive_move(A, n);
+    }
+    return firstMissingPositive_map(A, n);
+}
+
+
+void printArray(int a[], int n){
+    cout << "[ ";
+    for(int i=0; i<n-1; i++) {
+        cout << a[i] << ", ";
+    }
+    cout << a[n-1] << " ]";
+}
+
+void Test(int a[], int n, int expected) {
+    printArray(a, n);
+    int ret = firstMissingPositive(a, n);
+    cout << "\t   missed = " << ret << "  " << (ret==expected?"passed!":"failed!") << endl;
+    //printArray(a, n);
+    //cout <<endl;
+}
+
 int main()
 {
-    #define TEST(a) cout << firstMissingPositive(a, sizeof(a)/sizeof(int)) << endl
+#define TEST(a, e) Test(a, sizeof(a)/sizeof(int), e) 
+
+    int a0[]={1};
+    TEST(a0, 2);
 
     int a1[]={1,2,0};
-    TEST(a1);
+    TEST(a1, 3);
 
     int a2[]={3,4,-1,1};
-    TEST(a2);
+    TEST(a2, 2);
 
     int a3[]={1000,-1};
-    TEST(a3);
+    TEST(a3, 1);
 
     int a4[]={1000, 200};
-    TEST(a4);
+    TEST(a4, 1);
 
-    int a5[]={2,5,4,3,-1};
-    TEST(a5);
+    int a5[]={2,5,3,-1};
+    TEST(a5, 1);
 
     int a6[]={1, 100};
-    TEST(a6);
+    TEST(a6, 2);
+
+    int a7[]={7,8,9,11};
+    TEST(a7, 1);
+
+    int a8[]={4,3,2,1};
+    TEST(a8, 5);
 
     return 0;
 }