Merge branch 'master' of github.com:doocs/leetcode

Author: yanglbme

solution/0012. Integer to Roman/Solution.java

@@ -7,3 +7,4 @@ public String intToRoman(int num) {
         return M[num / 1000] + C[(num % 1000) / 100] + X[(num % 100) / 10] + I[num % 10];
     }
 }
+

solution/0012.Integer to Roman/Solution.java

@@ -0,0 +1,40 @@
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        int len = nums.size();
+        vector<vector<int>> ans;
+        if(len < 4)return ans;
+        sort(nums.begin(),nums.end());
+        
+        int left;
+        int right;
+        int sum;
+        for(int i = 0;i<len;i++){
+            if(i> 0 && nums[i] == nums[i-1])continue;
+            for(int j = i + 1;j<len;j++){
+                if(j > i+1 && nums[j] == nums[j-1])continue;
+                
+                left = j+1;
+                right = len - 1;
+                
+                while(left < right){
+                    
+                    sum = nums[i] + nums[j] + nums[left] + nums[right];
+                    
+                    if(sum == target){
+                        vector<int> tmp{nums[i],nums[j],nums[left],nums[right]};
+                        ans.push_back(tmp);
+                        
+                        while(left < right && nums[left] == nums[left+1])left++;
+                        while(left < right && nums[right] == nums[right-1])right--;
+                        left++;
+                        right--;
+                    }
+                    else if(sum < target)left++;
+                    else if(sum > target)right--;
+                }       
+            }
+        }
+        return ans;
+    }
+};

solution/0018.4Sum/Solution.cpp

@@ -0,0 +1,14 @@
+#48ms
+class Solution(object):
+    def removeDuplicates(self, nums):
+        if not nums:
+            return 0
+        
+        newtail = 0
+        
+        for i in range(1, len(nums)):
+            if nums[i] != nums[newtail]:
+                newtail += 1
+                nums[newtail] = nums[i] #只要求字符串前段正确即可
+                
+        return newtail + 1   #要求返回新字符串长度   

solution/0022. Generate Parentheses/Solution.java renamed to solution/0022.Generate Parentheses/Solution.java

@@ -0,0 +1,15 @@
+#仿照0026思路-20ms
+class Solution(object):
+    def removeElement(self, nums, val):
+        if not nums:
+            return 0
+        
+        newtail = 0
+
+        for i in range(0, len(nums)):
+            if nums[i] != val:
+                nums[newtail] = nums[i]
+                newtail += 1
+                
+        return newtail 
+                 

solution/0026.Remove Duplicates from Sorted Array/Solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def strStr(self, haystack, needle):
+        """
+        :type haystack: str
+        :type needle: str
+        :rtype: int
+        """
+        for i in range(len(haystack)-len(needle)+1):
+            p = i
+            q = 0
+            while p < len(haystack) and q < len(needle) and haystack[p] == needle[q]:
+                p += 1
+                q += 1
+            
+            if q == len(needle):
+                return i
+        
+        return -1

solution/0027.Remove Element/Solution.py

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    void nextPermutation(vector<int> &nums) {
+	    int len = nums.size();
+
+	    if (len == 0)return;
+        int i,j;
+        for(i = len - 2;i>=0;i--){
+            if(nums[i+1] > nums[i]){
+                for(j = len - 1;j>i;j--){
+                    if(nums[j]>nums[i])break;
+                }   
+                swap(nums[i],nums[j]);
+                reverse(nums.begin()+i+1,nums.end());           
+                return;
+            }
+        }
+	    reverse(nums.begin(),nums.end());
+    }
+};

solution/0028.Implement strStr()/Solution.py

@@ -0,0 +1,17 @@
+class Solution {
+    public int search(int[] A, int target) {
+        if (A == null || A.length == 0) return -1;
+        int low = 0,high = A.length - 1;
+        while (low <= high) {
+            int mid = low + ((high - low) >> 1);
+            if (target < A[mid]) {
+                if (A[mid] >= A[high] && target < A[low]) low = mid + 1;
+                else high = mid - 1;
+            } else if (target > A[mid]) {
+                if (A[low] >= A[mid] && target > A[high]) high = mid - 1;
+                else low = mid + 1;
+            } else return mid;
+        }
+        return -1;
+    }
+}

solution/0031.Next Permutation/Solution.cpp

@@ -0,0 +1,30 @@
+class Solution {
+    public int[] searchRange(int[] nums, int target) {
+        int start = 0, end = nums.length - 1;
+        while (start <= end) {
+            int mid = start + (end - start) / 2;
+            if (nums[mid] < target) start = mid + 1;
+            else if (nums[mid] > target) end = mid - 1;
+            if (nums[mid] == target) {
+                return new int[]{findFirst(nums, start, mid, target),findEnd(nums, mid, end, target)};
+            }
+        }
+        return new int[]{-1,-1};
+    }
+    private int findFirst(int[] nums, int start, int end, int target) {
+        while (start < end) {
+            int temp = start + (end - start) / 2;
+            if (nums[temp] < target) start = temp + 1;
+            else if (nums[temp] == target) end = temp;
+        }
+        return start;
+    }
+    private int findEnd(int[] nums, int start, int end, int target) {
+        while (start < end) {
+            int temp = start + (end - start + 1) / 2;
+            if (nums[temp] > target) end = temp - 1;
+            else if (nums[temp] == target) start = temp;
+        }
+        return start;
+    }
+}