Update

Author: applewjg

PartitionList.h

@@ -1,7 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       Apr 9, 2013
- Update:     Jul 30, 2013
+ Update:     Oct 7, 2014
  Problem:    Partition List
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_86
@@ -26,6 +26,26 @@
 class Solution {
 public:
     ListNode *partition(ListNode *head, int x) {
+        ListNode leftdummy(-1);
+        ListNode rightdummy(-1);
+        ListNode * lhead = &leftdummy;
+        ListNode * rhead = &rightdummy;
+        
+        for(ListNode*cur = head; cur; cur=cur->next){
+            if(cur->val<x){
+                lhead->next = cur;
+                lhead = lhead->next;
+            }else{
+                rhead->next = cur;
+                rhead = rhead->next;
+            }
+        }
+        lhead->next = rightdummy.next;
+        rhead->next = nullptr;
+        return leftdummy.next;
+    }
+
+    ListNode *partition_1(ListNode *head, int x) {
         ListNode dummy(0), *ins = &dummy, *cur = &dummy;
         dummy.next = head;
         while (cur->next) 
@@ -53,4 +73,4 @@ class Solution {
         }
         return dummy.next;
     }
-};
+};

TrappingRainWater.h

@@ -1,6 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       May 25, 2013
+ Update:     Oct 07, 2014
  Problem:    Trapping Rain Water
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_42
@@ -17,27 +18,19 @@ class Solution {
 public:
     int trap(int A[], int n) {
         if (n == 0) return 0;
-        int left[n];
-        int right[n];
-
-        int lmax = A[0];
-        for (int i = 0; i < n; ++i)
-        {
-            lmax = max(lmax, A[i]);
-            left[i] = lmax;
-        }
-
-        int rmax = A[n-1];
-        for (int i = n - 1; i >= 0; --i)
-        {
-            rmax = max(rmax, A[i]);
-            right[i] = rmax;
+        vector<int> maxLeft(n,0);
+        vector<int> maxRight(n,0);
+        maxLeft[0] = A[0];
+        maxRight[n - 1] = A[n - 1];
+        for (int i = 1; i < n; ++i) {
+            maxLeft[i] = max(maxLeft[i - 1], A[i]);
+            maxRight[n - 1 - i] = max(maxRight[n - i], A[n - 1 - i]);
         }
-
+        
         int res = 0;
-        for (int i = 0; i < n; ++i)
-            res += min(left[i], right[i]) - A[i];
-
+        for (int i = 1; i < n; ++i) {
+            res += min(maxLeft[i], maxRight[i]) - A[i];
+        }
         return res;
     }
 };

UniqueBinarySearchTrees.h

@@ -1,6 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       Jul 10, 2013
+ Update:     Oct 07, 2014
  Problem:    Unique Binary Search Trees
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_96
@@ -20,6 +21,9 @@
 class Solution {
 public:
     int numTrees(int n) {
+        return numTrees_2(n);
+    }
+    int numTrees_1(int n) {
         int dp[n+1];
         memset(dp, 0, sizeof(dp));
         dp[0] = 1;
@@ -28,4 +32,13 @@ class Solution {
                 dp[i] += dp[j] * dp[i-j-1];
         return dp[n];
     }
-};
+    int numTrees_2(int n) {
+        if (n < 0) return 0;
+        vector<int> dp(n+1, 0);
+        dp[0] = 1; dp[1] = 1;
+        for(int i = 2;i <= n; ++i){
+            dp[i] = dp[i-1] * (4 * i - 2)/(i + 1);
+        }
+        return dp[n];        
+    }
+};