Commit

Author: rachitvk

Leetcode/BestTimeToBuyAndSellStock1.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        
+        if(prices.size() == 0)
+            return 0;
+        
+        int ans = 0;
+        
+        int mn=prices[0];
+        
+        for(int i=1;i<prices.size();i++){
+            ans = max(ans,prices[i]-mn);
+            mn = min(mn,prices[i]);
+        }
+        
+        return ans;
+        
+    }
+};

Leetcode/BestTimeToBuyAndSellStockWithTransactionFee.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices, int fee) {
+        
+           
+        int cash = 0 , hold = -prices[0];
+        
+        for(int i=1;i<prices.size();i++){
+            cash = max(cash,hold+prices[i]-fee);
+            hold = max(hold,cash-prices[i]);
+        }
+        
+        return cash;
+        
+    }
+};

Leetcode/ClimbingStairs.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        
+        if(n==1)
+            return 1;
+        
+        int second = 1;
+        int first = 2;
+        
+        for(int i=n-2;i>=1;i--){
+            int temp = first + second;
+            second = first;
+            first = temp;
+        }
+        
+        return first;
+        
+    }
+};

Leetcode/DivisorGame.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool divisorGame(int N) {
+        bool dp[N+1]={false};
+        
+        
+        for(int i=2;i<=N;i++){
+            bool flag=0;
+            for(int j=1;j<=sqrt(i);j++){
+                if(i%j==0 && dp[i-j]==0){
+                    flag=true;
+                }
+            }
+            dp[i]=flag;
+        }
+        
+        return dp[N];
+        
+    }
+};

Leetcode/HouseRobber.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        
+        
+        int n = nums.size();
+        
+        if(n == 0)
+            return 0;
+        
+        vector<int>dp(n+1,0);
+        
+        dp[0] = 0;
+        dp[1] = nums[0];
+        
+        for(int i=2;i<=nums.size();i++){
+            dp[i] = max(nums[i-1]+dp[i-2],dp[i-1]); 
+        }
+        
+        return dp[n];
+        
+    }
+};

Leetcode/IntegerBreak.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    
+    int integerBreak(int n) {
+        
+        if( n == 1)return 1;
+        
+        if( n == 2)return 1;
+        
+        if( n == 3)return 2;
+        
+        if( n == 4)return 4;
+        
+        if(n == 5) return 6;
+        
+        if(n == 6) return 9;
+        
+        
+        if(n%3 == 1) return pow(3,n/3-1)*4;
+        
+        if(n%3 == 2) return pow(3,n/3)*2;
+        
+        return pow(3,n/3);
+        
+        
+    }
+};

Leetcode/MaxLengthOfPairChain.cpp

@@ -0,0 +1,38 @@
+class Solution {
+    
+   
+public:   
+    
+    static bool comp(vector<int>& a, vector<int>& b){
+        return a[0] < b[0];
+    }
+    
+    int findLongestChain(vector<vector<int>>& pairs) {
+        
+        int n = pairs.size();
+        
+        int dp[n+1] = {0};
+        
+        if(n == 0)
+            return 0;
+        
+        sort(pairs.begin(),pairs.end(),comp);
+         
+        for(int i=0;i<n;i++){
+            for(int j=i-1;j>=0;j--){
+                if(pairs[i][0] > pairs[j][1]){
+                    dp[i] = max(dp[i],dp[j]);
+                }
+            }
+            
+            dp[i]++;
+        }
+        
+        int ans = 0;
+        
+        for(int i=0;i<n;i++)
+            ans = max(ans,dp[i]);
+        
+        return ans;
+    }
+};

Leetcode/MaximumSubarray.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        
+        int ans = nums[0];
+        int sum;
+        
+        if(ans < 0)
+            sum = 0;
+        else
+            sum = ans;
+        
+        for(int i=1;i<nums.size();i++){
+            if(sum+nums[i]<0){
+                ans = max(ans,sum+nums[i]);
+                sum = 0;
+            }else{
+                ans = max(ans,sum+nums[i]);
+                sum+=nums[i];
+            }
+        }
+        
+        return ans;
+        
+    }
+};

Leetcode/MinCostClimbingStairs.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int minCostClimbingStairs(vector<int>& cost) {
+        
+        int n=cost.size();
+        vector<int>dp(n,0);
+        
+        for(int i=n-1;i>=0;i--){
+            if(i+1 >= n || i+2 >= n)
+                dp[i] = cost[i];
+            else
+                dp[i] = cost[i] + min(dp[i+1],dp[i+2]);
+        }
+        
+        return min(dp[0],dp[1]);
+        
+    }
+};

Leetcode/RangeSumQuery.cpp

@@ -0,0 +1,27 @@
+class NumArray {
+public:
+
+    
+    vector<int>sum;
+    
+    NumArray(vector<int>& nums) {
+       
+       for(int i=0;i<=nums.size();i++)
+           sum.push_back(0);
+       
+       for(int i = 0 ; i < nums.size(); i++) {
+           sum[i+1]+= sum[i]+nums[i]; 
+       }
+        
+    }
+    
+    int sumRange(int i, int j) {
+        return sum[j+1]-sum[i];
+    }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray* obj = new NumArray(nums);
+ * int param_1 = obj->sumRange(i,j);
+ */