Merge pull request #24 from zouwx2cs/master

add 122 cpp version(4ms)

Author: yanglbme

solution/001.Two Sum/Solution.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) 
+    {
+        vector<int> res ;
+        unordered_map<int, int> hash ;
+        
+        for (int i = 0; i < nums.size(); ++i)
+        {
+            int aim = target - nums[i] ;
+            int local = hash[aim] ; 
+            if (local != NULL)
+            {
+                res.push_back(local-1) ;
+                res.push_back(i) ;
+                return res ;
+            }
+            else
+                hash[nums[i]] = i+1 ;
+        }
+
+        return res ;
+    }
+};

solution/019.Remove Nth Node From End of List/Solution.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode *p, *q ;
+        q = head ;
+        p = head ;
+        
+        for (int i = 0; i < n; ++i)
+            q = q->next ;
+        
+        if (!q)
+        {
+            return head->next ;
+        }
+        
+        while (q->next)
+        {
+            q = q->next ;
+            p = p->next ;
+        }
+
+        p->next = p->next->next ;
+        return head ;
+    }
+};

solution/059.Spiral Matrix II/Solution.cpp

@@ -0,0 +1,65 @@
+class Solution {
+public:
+    vector<vector<int>> generateMatrix(int n) {
+        if (0 == n)
+            return vector<vector<int>>() ;
+        vector<vector<int>> res(n, vector<int>(n, 0)) ;
+        
+        int i = 0, j = 0 ;
+        
+        int dir = 0 ;
+        
+        int n2 = n*n ;
+        
+        for (int d = 1; d <= n2; ++d)
+        {
+            res[i][j] = d ;
+            //cout << d << endl ;
+            switch (dir)
+            {
+                case 0:
+                    ++j ;
+                    if (j >= n || res[i][j])
+                    {
+                        dir++ ;
+                        --j ;
+                        ++i ;
+                    }
+                    break ;
+                case 1:
+                    ++i ;
+                    if (i >= n || res[i][j])
+                    {
+                        dir++ ;
+                        --i ;
+                        --j ;
+                    }
+                    break ;
+                case 2:
+                    --j ;
+                    if (j < 0 || res[i][j])
+                    {
+                        dir++ ;
+                        ++j ;
+                        --i ;
+                    }
+                    break ;
+                case 3:
+                    --i ;
+                    if (i < 0 || res[i][j])
+                    {
+                        dir = 0 ;
+                        ++i ;
+                        ++j ;
+                    }
+                    
+                    break ;
+                default:
+                    break ;
+            }
+            
+        }
+        
+        return res ;
+    }
+};

solution/122.Best Time to Buy and Sell Stock II/Solution.cpp

@@ -0,0 +1,15 @@
+public:
+    int maxProfit(vector<int>& prices) 
+	{
+        if (0 == prices.size())
+            return 0 ;
+        int M = 0 ;
+        for (int i = 1; i < prices.size(); ++i)
+        {
+            int d = prices[i] - prices[i-1] ;
+            if (d > 0)
+                M += d ;
+        }
+        return M ;
+    }
+};

solution/581.Shortest Unsorted Continuous Subarray/Solution.cpp

@@ -0,0 +1,40 @@
+// i自左向右找到第一个逆序，
+// j自右向左找到第一个逆序
+// 找到nums[i, j]的上下界
+// ij向外扩展找到满足上下界的最小[i, j]
+class Solution {
+public:
+    int findUnsortedSubarray(vector<int>& nums) {
+        if (1 == nums.size())
+            return 0 ;
+        
+        int i = 0, j = nums.size()-1 ;
+        while (i < j && nums[i] <= nums[i+1])
+            ++i ;
+        if (i >= j)
+            return 0 ;
+        
+        while (nums[j-1] <= nums[j])
+            --j ;
+        
+        //cout << i << ' ' << j << endl ;
+        int m = nums[i] ;
+        int M = m ;
+        for (int k = i; k <= j; ++k)
+        {
+            if (m > nums[k])
+                m = nums[k] ;
+            if (M < nums[k])
+                M = nums[k] ;
+        }
+        //cout << m << ' ' << M << endl ;
+        
+        while (i >= 0 && m < nums[i])
+            --i ;
+        while (j < nums.size() && M > nums[j])
+            ++j ;
+        
+        //cout << i << ' ' << j << endl ;
+        return j-i-1 ;
+    }
+};