Array Leetcode :Medium

216. Combination Sum III

https://leetcode.com/problems/combination-sum-iii/

class Solution {
private:
    vector<vector<int>>res;
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<int>nums;
        combination(nums,k,n,1);
        return res;
    }
    void combination(vector<int> &nums,int k,int n,int t){
        if(k<=0 || n<=0){
            if(k==0 && n==0) res.push_back(nums);
            else return;
        }
        for(int i=t;i<=9;i++){
            nums.push_back(i);
            combination(nums,k-1,n-i,i+1);
            nums.pop_back();
        }
    }
};

209. Minimum Size Subarray Sum

https://leetcode.com/problems/minimum-size-subarray-sum/

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int len = nums.size(), start = 0, sum = 0;
        int minlen = len+1;
        for (int i = 0; i < len; i++) { 
            sum += nums[i]; 
            while (sum >= s) {
                minlen = min(minlen, i - start + 1);
                sum -= nums[start++];
            }
        }
        return minlen == len+1 ? 0 : minlen;
    }
};

18. 4Sum

https://leetcode.com/problems/4sum/

class Solution {
private:
    vector<vector<int>>res;
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int len = nums.size();
        sort(nums.begin(),nums.end());
        for(int i=0;i<len;i++){
            while(i>0&&nums[i]==nums[i-1]&&i<len) i++;
            for(int j=i+1;j<len;j++){
                while(j>i+1&&nums[j]==nums[j-1]&&j<len)j++;
                int k=j+1,l=len-1;
                while(k<l){
                    while(k>j+1 && nums[k]==nums[k-1] && k<l)k++;
                    while(l<len-1 && nums[l]==nums[l+1] && k<l)l--;
                    if(k==l)continue;
                    if(nums[i]+nums[j]+nums[k]+nums[l]==target){
                        res.push_back({nums[i],nums[j],nums[k],nums[l]});
                        k++;
                    }
                    else if(nums[i]+nums[j]+nums[k]+nums[l]>target)
                        l--;
                    else
                        k++;
                }
            }
        }
        return res;
    }
};

31. Next Permutation

https://leetcode.com/problems/next-permutation/

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

162. Find Peak Element

https://leetcode.com/problems/find-peak-element/

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int len = nums.size();
        int st = 0,en = len-1;
        while(st<en){
            int mid = (st+en)/2;
            if(nums[mid]>nums[mid+1]) en = mid;
            else st = mid+1;
        }
        return en;
    }
};

289. Game of Life
https://leetcode.com/problems/game-of-life/

class Solution {
public:
    void gameOfLife(vector<vector<int>>& board) {
        int m = board.size();
        if(m==0)return;
        int n = board[0].size();
        if(n==0)return;
        
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                renew(board,i,j);
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++){
                if(board[i][j]==1||board[i][j]==2) board[i][j]=1;
                else board[i][j]=0;
            }
    }
    void renew(vector<vector<int>>&board,int x,int y){
        int cnt=0,m=board.size(),n=board[0].size();
        for(int i=x-1;i<=x+1;i++)
            for(int j=y-1;j<=y+1;j++){
                if(i==x&&j==y)continue;
                if(i>=0&&i<m&&j>=0&&j<n){
                    if(board[i][j]%2==1)cnt++;
                }
            }
        if(board[x][y]%2==1){
            if(cnt<2||cnt>3)board[x][y]=3;
            else board[x][y]=1;
        }
        else{
            if(cnt==3) board[x][y]=2;
            else board[x][y]=0;
        }
    }
};

153. Find Minimum in Rotated Sorted Array

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/

class Solution {
public:
    int findMin(vector<int>& nums) {
        int len = nums.size();
        int l=0,r=len-1;
        while(l<=r){
            int m=(l+r)/2;
            if(nums[m]<nums[l]) r=m;
            else{
                if(m==l)
                    return nums[r]>nums[m]? nums[0]:nums[r];
                else l=m;
            }
        }
        return nums[l];
    }
};

152. Maximum Product Subarray
https://leetcode.com/problems/maximum-product-subarray/

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        assert (!nums.empty());
        int curMax = nums[0], curMin = nums[0], res = nums[0];
        for (int i = 1; i < nums.size(); ++i) {
            int mx = curMax,mn=curMin;
            curMax = max(max(mx * nums[i], mn * nums[i]), nums[i]);
            curMin = min(min(mx * nums[i], mn * nums[i]), nums[i]);
            res = max(res, curMax);
        }
        return res;
    }
};

268. Missing Number

https://leetcode.com/problems/missing-number/

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int len =nums.size();
        int left=0,right=len-1;
        while(left<=right){
            int mid = (left+right)/2;
            if(nums[mid]==mid)left=mid+1;
            else right=mid-1;
        }
        return left;
    }
};

122. Best Time to Buy and Sell Stock II

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int Profit=0,len=prices.size();
        for(int i=1;i<len;i++){
            if(prices[i]>prices[i-1])Profit+=prices[i]-prices[i-1];
        }
        return Profit;
    }
};

120. Triangle
https://leetcode.com/problems/triangle/

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int m = triangle.size(),minum = INT_MAX;
        for(int i=0;i<m;i++){
            int n = triangle[i].size();
            for(int j=0;j<n;j++){
                if(i!=0){
                    if(j==0) triangle[i][j]+=triangle[i-1][j];
                    else if(j==n-1) triangle[i][j]+=triangle[i-1][j-1];
                    else triangle[i][j]+=min(triangle[i-1][j-1],triangle[i-1][j]);
                }
                if(i==m-1) minum = min(minum,triangle[i][j]);
            }
        }
        return minum;
    }
};

34. Search for a Range

https://leetcode.com/problems/search-for-a-range/

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int len = nums.size();
        int l = 0,r = len-1;
        while(l<=r){
            int m = (l+r)/2;
            if(nums[m]<target) l = m+1;
            else if(nums[m]>target) r = m-1;
            else{
                int s=m,e=m;
                while(s>=1&&nums[s-1]==nums[m])s--;
                while(e+1<len&&nums[e+1]==nums[m])e++;
                vector<int>re = {s,e};
                return re;
            }
        }
        vector<int>re = {-1,-1};
        return re;
    }
};

35. Search Insert Position

https://leetcode.com/problems/search-insert-position/

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int len = nums.size();
        int l = 0 , r = len-1;
        while(l<=r){
            int m = (l+r)/2;
            if(nums[m]<target) l = m+1;
            else if(nums[m]>target) r = m-1;
            else return m;
        }
        return l;
    }
};

106. Construct Binary Tree from Inorder and Postorder Traversal

https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int len = inorder.size();
        return helper(inorder,postorder,0,len-1,0,len-1);
    }
    TreeNode* helper(vector<int>& inorder,vector<int>& postorder,int i,int j,int ii,int jj)
    {
        if(i >j || ii >jj)
            return NULL;
        int mid = postorder[jj];
        auto f = find(inorder.begin() + i,inorder.begin() + j+1,mid);
        int dis = f - inorder.begin() - i;
        TreeNode* root = new TreeNode(mid);
        root -> left = helper(inorder,postorder,i,i + dis-1,ii,ii + dis-1);
        root -> right = helper(inorder,postorder,i + dis + 1,j,ii + dis,jj - 1);
        return root;
    }
};

105. Construct Binary Tree from Preorder and Inorder Traversal

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int len = preorder.size();
        return helper(preorder,inorder,0,len,0,len);
    }
    TreeNode* helper(vector<int>& preorder, vector<int>& inorder,int i,int j, int ii,int jj){
        if(i>=j||ii>=jj)return NULL;
        int mid = preorder[i];
        auto f = find(inorder.begin()+ii,inorder.begin()+jj,mid);
        int dis = f-inorder.begin()-ii;
        TreeNode* root = new TreeNode(mid);
        root->left = helper(preorder,inorder,i+1,i+dis+1,ii,ii+dis);
        root->right = helper(preorder,inorder,i+dis+1,j,ii+dis+1,jj);
        return root;
    }
};

90. Subsets II

https://leetcode.com/problems/subsets-ii/

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> res = {{}};
        int len = nums.size();
        sort(nums.begin(),nums.end());
        for(int i=0; i<len;){
            int count = 0; // num of elements are the same
            while(count + i<len && nums[count+i]==nums[i])  count++;
            int pren = res.size();
            for(int k=0; k<pren; k++){
                vector<int> re = res[k];
                for(int j=0; j<count; j++){
                    re.push_back(nums[i]);
                    res.push_back(re);
                }
            }
            i += count;
        }
        return res;
    }
};

39. Combination Sum

https://leetcode.com/problems/combination-sum/

class Solution {
private:
    vector<vector<int>>res;
    void helper(vector<int>can,vector<int>&re,int target,int sum,int t){
        if(t>=can.size()||target<sum) return;
        if(target==sum){
            res.push_back(re);
            return;
        }
        else{
            re.push_back(can[t]);
            helper(can,re,target,sum+can[t],t);
            re.pop_back();
            helper(can,re,target,sum,t+1);
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int>re;
        sort(candidates.begin(),candidates.end());
        helper(candidates,re,target,0,0);
        return res;
    }
};

11. Container With Most Water

https://leetcode.com/problems/container-with-most-water/

class Solution {
public:
    int maxArea(vector<int>& height) {
        int contain=0,len=height.size();
        int left=0,right=len-1;
        while(left<right){
            int con=min(height[left],height[right])*(right-left);
            contain = contain>con? contain:con;
            if(height[left]>height[right]) right--;
            else left++;
        }
        return contain;
    }
};