added more dp problems

Author: skm2000

Maximum_Dot_Product_Subsequence.cpp

@@ -15,6 +15,7 @@ int maxDotProduct(vector<int>& A, vector<int>& B,int size1,int size2) {
     return dp[size1-1][size2-1];
 }
 
+
 int main(){
     int size1,size2;
     cin>>size1>>size2;
@@ -27,4 +28,22 @@ int main(){
         cin>>B[i];
     }
     cout<<maxDotProduct(A,B,size1,size2)<<"\n";
-}
+}
+
+// another approach
+class Solution {
+public:
+    int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
+        int n = int(nums1.size()), m = int(nums2.size());
+        vector<vector<int>> dp(n + 1, vector<int>(m + 1, INT_MIN));
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= m; ++j) {
+                dp[i][j] = max(dp[i][j], dp[i - 1][j]);
+                dp[i][j] = max(dp[i][j], dp[i][j - 1]);
+                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);
+                dp[i][j] = max(dp[i][j], max(dp[i - 1][j - 1], 0) + nums1[i - 1] * nums2[j - 1]);
+            }
+        }
+        return dp[n][m];
+    }
+};

README.md

@@ -1,7 +1,7 @@
 # Dynamic-Programming
 A DP a day keeps the bug away.
 
-**Cointains Basic Dp Problems**<br><br>
+**Cointains Dp Problems**<br><br>
 
 **Parent Problem** : [*Kadane's Algorithm*](/Kadane.cpp)<br>
 1) [Best Time to Buy and sell Stock(Leetcode)](/Best_Time_To_Buy_And_Sell_Stock_.cpp)<br>
@@ -59,14 +59,24 @@ SubProblems :<br>
 5) [Maximum Product Increasing Subsequence](/Maximum_Product_Increasing_Subsequence.cpp).<br>
 6) [Minimum Jumps to reach end](/Minimum_Jumps_To_Reach_End.cpp).<br>
 7) [Box Stacking Problem](/Box_Stacking_Problem.cpp).<br>
-8) [Longest Bitonic Sequence](/BitonicSequence.cpp).<br><br>
+8) [Longest Bitonic Sequence](/BitonicSequence.cpp).<br>
+9) [Longest Alternating Subsequence](/longest_alternating_subsequence.cpp)<br>
+10) [Count All Increasing Subsequences](/Count_All_Increasing_Subsequences.cpp).<br>
 
 **Parent Problem** : *DP + Greedy*<br>
 1) [Jump Game-2(Leetcode)](/jump_game_2..cpp).<br>
 2) [Video Stiching(Leetcode)](/video_stiching.cpp).<br>
-3) [Minm number of taps to open water](/minm_number_of_taps_to_open_water.cpp)
-
-**Parent Problem** : [*Count Distinct SubSequences*](/Count_Distinct_Subsequences.cpp)<br>
+3) [Minm number of taps to open water](/minm_number_of_taps_to_open_water.cpp).<br>
+
+**Parent Problem** : *Game(DP) + minimax*<br>
+1) [Nim Game](/nim_game.cpp).<br>
+2) [Flip Game-1](/flip_game.cpp).<br>
+3) [Flip Game-2](/flip_game2.cpp).<br>
+4) [Get Minimum Squares](/Get_Minimum_Squares.cpp).<br>
+5) [Optimal Strategy to play a Game](/Optimal_Strategy_To_Play_A_Game.cpp).<br>
+6) [Stone Game-3](/Last_Stone_3.cpp)<br>
+7) [Jump Game-3(Leetcode)](/Jump_Game_3.cpp)<br>
+8) [Jump Game-5(Leetcode)](/Jump_Game_5.cpp)<br>
 
 **Parent Problem** : *Dp on Grids*<br>
 1) [Maximum Size Submatrix Square](/Maximum_Size_Submatrix_Square.cpp).<br>
@@ -76,28 +86,26 @@ SubProblems :<br>
 5) [Path in a Matrix](/Max_path_sum.cpp)<br>
 6) [Maximal Square(Leetcode)](/maximal_square.cpp)<br>
 7) [Count Submatrices with all ones(Leetcode)](/count_submatrices_with_all_ones.cpp)<br>
-8) [Maximum Sum Submatrix](/maximum_sum_submatrix.cpp)
+8) [Maximum Sum Submatrix](/maximum_sum_submatrix.cpp)<br>
+9) [Unique Path-1](/unique_paths_1.cpp)<br>
+10) [Unique Path-2](/unique_paths_2.cpp)<br>
+
 
 **Parent Problem** : [*Matrix Chain Multiplication*](/Matrix_Chain_Multiplication.cpp)<br>
 
+**Parent Problem** : [*Count Distinct SubSequences*](/Count_Distinct_Subsequences.cpp)<br>
+
 **Parent Problem** : *Dp on Trees*<br>
 1) [Max Path Sum](/Max_path_sum.cpp)<br>
 2) [Maximum Path Sum in a Tree from Any node to any other node](/Maximum_Path_Sum_in_Binary_tree.cpp)<br>
 3) [Diameter of a Binary Tree](/Diameter_Of_Binary_Tree.cpp)<br>
 
 **Others**
-1) [Get Minimum Squares](/Get_Minimum_Squares.cpp).<br>
-2) [Count All Increasing Subsequences](/Count_All_Increasing_Subsequences.cpp).<br>
-3) [Longest Consequetive Subsequences](/Longest_Consequetive_Subsequence.cpp).<br>
-4) [Optimal Strategy to play a Game](/Optimal_Strategy_To_Play_A_Game.cpp).<br>
-5) [Zeroes And Ones](/zerosAndOnes.cpp)
-6) [Longest Pallidromic SubString](/Longest_Pallindromic_Substring.cpp).<br>
-7) [Count Pallindromic substring of string](/Count_Pallindromic_SubString_Of_String_gfg.cpp)<br>
-8) [Product of array except self](/Count_Pallindromic_SubString_Of_String_gfg.cpp)
-9) [Jump Game-3(Leetcode)](/Jump_Game_3.cpp)<br>
-10) [Jump Game-5(Leetcode)](/Jump_Game_5.cpp)<br>
-11) [Stone Game-3](/Last_Stone_3.cpp)<br>
-12) [Num Products](#)<br>
+1) [Longest Consequetive Subsequences](/Longest_Consequetive_Subsequence.cpp).<br> 
+2) [Zeroes And Ones](/zerosAndOnes.cpp)
+3) [Longest Pallidromic SubString](/Longest_Pallindromic_Substring.cpp).<br>
+4) [Count Pallindromic substring of string](/Count_Pallindromic_SubString_Of_String_gfg.cpp)<br>
+5) [Product of array except self](/Count_Pallindromic_SubString_Of_String_gfg.cpp)
 
 Happy Coding!!
 

count_subsets_of_given_difference.cpp

@@ -0,0 +1,41 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// given an array a difference of subset.find the count of that difference
+// approach ----------------> s1 + s2 = sum(arr) --eqn1 && s1-s2 = diff(given) ---eqn2;
+// solve eqn1 & eqn2 find s1 . s1 = (sum+diff)/2
+// therefore the problem reduces to count number of subset of with sum s1
+
+int count(vector<int> &nums,int sum) {
+    int n = nums.size();
+    vector<vector<int>>dp(n+1,vector<int>(sum+1,0));
+    for(int i=0;i<=sum;i++){
+        dp[0][i] = 0;
+    }
+    for(int i=0;i<=n;i++){
+        dp[i][0] = 1;
+    }
+    for(int i=1;i<=n;i++){
+        for(int j=1;j<=sum;j++){
+            if(nums[i-1] <= j){
+                dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]];
+            }
+            else{
+                dp[i][j] = dp[i-1][j];
+            }
+        }
+    }
+    return dp[n][sum];
+}
+
+int main() {
+    int n,diff,sum=0;
+    cin>>n>>diff;
+    vector<int>nums(n);
+    for(int i=0;i<n;i++){
+        cin>>nums[i];
+        sum += nums[i];
+    }
+    int s1 = (sum+diff)/2;
+    cout<<count(nums,s1);
+}

flip_game_1.cpp

@@ -0,0 +1,21 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// problem : https://www.lintcode.com/problem/flip-game/
+
+class Solution {
+public:
+    vector<string> generatePossibleNextMoves(string &s) {
+        // write your code here
+        int n=s.length();
+        vector<string>ans;
+        for(int i=0;i<n-1;i++){
+            if(s[i] == '+' && s[i+1] == '+'){
+                s[i] = s[i+1] = '-';
+                ans.push_back(s);
+                s[i] = s[i+1] = '+';
+            }
+        }
+        return ans;
+    }
+};

flip_game_2.cpp

@@ -0,0 +1,30 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// problem : https://www.lintcode.com/problem/flip-game-ii/
+// very good question
+
+class Solution {
+public:
+    bool canWin(string &s) {
+        // write your code here
+        if(s.length()<2) return false;
+        return flipGame(s);
+    }
+    
+    bool flipGame(string &s){
+        for(int i=0;i<s.length()-1;i++){
+            if(s[i]=='+' && s[i+1]=='+'){
+                // find the next state of the string and see if the other player can win
+                // with the next state
+                string nextState = s.substr(0,i)+"--"+s.substr(i+2);
+                // if the player can't win with the next state, i will win the flipGame
+                // and hence return true
+                if(!flipGame(nextState)){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+};

longest_alternating_subsequence.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// problem : https://leetcode.com/problems/wiggle-subsequence
+
+// O(n^2) time and o(n) space
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int n=nums.size();
+        if(n == 0) return 0;
+//     up[i] refers to the length of the longest wiggle subsequence obtained so far considering ith element   
+        vector<int>up(n,1),down(n,1);
+        for(int i=1;i<n;i++){
+            for(int j=0;j<i;j++){
+                if(nums[i] > nums[j]){
+                    up[i] = max(up[i],1+down[j]);
+                }
+                else if(nums[i] < nums[j]){
+                    down[i] = max(down[i],1+up[j]);
+                }
+            }
+        }
+        return max(up[n-1],down[n-1]);
+    }
+};
+
+
+// O(n) time and O(n) space
+
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int n=nums.size();
+        if(n == 0) return 0;
+//     up[i] refers to the length of the longest wiggle subsequence obtained so far considering ith element   
+        vector<int>up(n,1),down(n,1);
+        for(int i=1;i<n;i++){
+            if(nums[i] > nums[i-1]){
+                up[i] = 1+down[i-1];
+                down[i] = down[i-1];
+            }
+            else if(nums[i] < nums[i-1]){
+                down[i] = 1+up[i-1];
+                up[i] = up[i-1];
+            }
+            else{
+                down[i] = down[i-1];
+                up[i] = up[i-1];
+            }
+        }
+        return max(up[n-1],down[n-1]);
+    }
+};
+
+
+
+// O(n) ime and O(1) space
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int n=nums.size();
+        if(n == 0) return 0;
+        int up=1,down=1;
+        for(int i=1;i<n;i++){
+            if(nums[i] > nums[i-1]){
+                up = down+1;
+            }
+            else if(nums[i] < nums[i-1]){
+                down = up+1;
+            }
+        }
+        return max(up,down);
+    }
+};

nim_game.cpp

@@ -0,0 +1,28 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// problem : https://leetcode.com/problems/nim-game
+
+//  n > 10^9 won't work, O(n) solution
+class Solution {
+public:
+    bool canWinNim(int n) {
+        if(n <= 3) return true;
+        bool dp[n+1];
+        dp[0]=false;
+        dp[1]=true,dp[2]=true,dp[3]=true;
+        for(int i=4;i<=n;i++){
+            dp[i] = !(dp[i-1] && dp[i-2] && dp[i-3]);
+        }
+        return dp[n];
+    }
+};
+
+//  O(1) solution
+
+class Solution {
+public:
+    bool canWinNim(int n) {
+        return !(n%4 == 0);
+    }
+};

unique_paths_1.cpp

@@ -0,0 +1,17 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// problem: https://leetcode.com/problems/unique-paths/
+
+class Solution {
+public:
+    int uniquePaths(int m, int n) {
+        vector<vector<int>>dp(m,vector<int>(n,1));
+        for(int i=1;i<m;i++){
+            for(int j=1;j<n;j++){
+                dp[i][j]=dp[i-1][j]+dp[i][j-1];
+            }
+        }
+        return dp[m-1][n-1];
+    }
+};

unique_paths_2.cpp

@@ -0,0 +1,41 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// problem : https://leetcode.com/problems/unique-paths-ii
+
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int n=obstacleGrid.size(),m=obstacleGrid[0].size();
+        vector<vector<int>>dp(n,vector<int>(m,1));
+        int f=0;
+        for(int i=0;i<n;i++){
+            if(obstacleGrid[i][0] == 1){
+                f = 1;
+            }
+            if(f == 1){
+                dp[i][0] = 0;
+            }
+        }
+        f=0;
+        for(int i=0;i<m;i++){
+            if(obstacleGrid[0][i] == 1){
+                f = 1;
+            }
+            if(f == 1){
+                dp[0][i] = 0;
+            }
+        }
+        for(int i=1;i<n;i++){
+            for(int j=1;j<m;j++){
+                if(obstacleGrid[i][j] == 0){
+                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                }
+                else{
+                    dp[i][j] = 0;
+                }
+            }
+        }
+        return dp[n-1][m-1];
+    }
+};