Repository: skm2000/Dynamic-Programming
Branch: master
Commit: 0b46b8fcc947
Files: 92
Total size: 67.8 KB

Directory structure:
gitextract_p1x2cpzs/

├── .gitignore
├── 3_segment.cpp
├── Best_Time_To_Buy_And_Sell_Stock_.cpp
├── BitonicSequence.cpp
├── Box_Stacking_Problem.cpp
├── Circular_Kadene.cpp
├── Coin_Changing_1.cpp
├── Coin_Changing_2.cpp
├── Count_All_Increasing_Subsequences.cpp
├── Count_All_Pallindromic_Subsequence.cpp
├── Count_Distinct_Subsequences.cpp
├── Count_Number_of_hops.cpp
├── Count_Pallindromic_SubString_Of_String_gfg.cpp
├── Count_Subsets_of_given_Sum.cpp
├── Count_ways_to_N'th_Stair.cpp
├── Diameter_Of_Binary_Tree.cpp
├── Distinct_Occurences.cpp
├── Edit_Distance.cpp
├── Equal_Sum_Partition.cpp
├── Friends_Pairing_Problem.cpp
├── Get_Minimum_Squares.cpp
├── GoldMine_Problem.cpp
├── Jump_Game_3.cpp
├── Jump_Game_5.cpp
├── Kadane.cpp
├── Knapsack_0_1.cpp
├── Last_Stone_3.cpp
├── Longest_Common_Subsequence.cpp
├── Longest_Common_Substring.cpp
├── Longest_Consequetive_Subsequence.cpp
├── Longest_Decreasing_Subsequence.cpp
├── Longest_Increasing_Subsequence.cpp
├── Longest_Pallindromic_Subsequence.cpp
├── Longest_Pallindromic_Substring.cpp
├── Longest_Repeating_Subsequence.cpp
├── Matrix_Chain_Multiplication.cpp
├── Max_Path_Sum_in_Triangle.cpp
├── Max_path_sum.cpp
├── Maximize_the_cutting.cpp
├── Maximum_Dot_Product_Subsequence.cpp
├── Maximum_Path_Sum_in_Binary_tree.cpp
├── Maximum_Product_Increasing_Subsequence.cpp
├── Maximum_Size_Submatrix_Square.cpp
├── Maximum_Sum_Decreasing_Subsequence.cpp
├── Maximum_Sum_Dividing_Recurssive.cpp
├── Maximum_Sum_Increasing_Subsequence.cpp
├── Maximum_length_of_pairs.cpp
├── Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp
├── Minimum_Initial_Points_To_Reach_Destinaion.cpp
├── Minimum_Jumps_To_Reach_End.cpp
├── Minimum_Subset_Sum_Difference.cpp
├── Minm_Cost_To_Fill_Bag.cpp
├── Minm_Deletion_To_Make_Pallindrome.cpp
├── Minm_Insertion_Deletion_Convert.cpp
├── No_Of_Ways_To_Tile.cpp
├── Number_of_ways_to_decode_a_string.cpp
├── Optimal_Strategy_To_Play_A_Game.cpp
├── Path_In_A_Matrix.cpp
├── Print_Longest_Common_Subsequence.cpp
├── Procuct_of_array_except_self.cpp
├── README.md
├── Reach_a_given_score.cpp
├── Rod_Cutting.cpp
├── Russian_Doll_Envelope.cpp
├── Shortest_Common_Supersequence.cpp
├── SubsetSum.cpp
├── Tiling_Problem.cpp
├── Unbounded_Knapsack.cpp
├── Uncrossed_Lines.cpp
├── count_submatrices_with_all_ones.cpp
├── count_subsets_of_given_difference.cpp
├── flip_game_1.cpp
├── flip_game_2.cpp
├── jump_game_2..cpp
├── longest_alternating_subsequence.cpp
├── maximal_square.cpp
├── maximum_product_subarray.cpp
├── maximum_sum_submatrix.cpp
├── minm_number_of_taps_to_open_water.cpp
├── nim_game.cpp
├── nth_catlan_number.cpp
├── num_products.cpp
├── number_of_permutations_such_that_no_three_forms_increasing_sequence.cpp
├── number_of_valid_parenthesis.cpp
├── spoj/
│   ├── ABA12C - Buying Apples!.cpp
│   ├── ACODE - Alphacode.cpp
│   ├── AIBOHP - Aibohphobia.cpp
│   └── ANARC09A - Seinfeld.cpp
├── unique_paths_1.cpp
├── unique_paths_2.cpp
├── video_stiching.cpp
└── zerosAndOnes.cpp

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
a.out

================================================
FILE: 3_segment.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// question link
// https://codeforces.com/problemset/problem/987/C


int main() {
    #define int long long
    int n;
    cin>>n;
    vector<int>s(n + 1), rent(n + 1);
    for(int i = 1 ; i <= n ;i++) {
        cin>>s[i];
    }
    for(int i = 1 ; i <= n ;i ++) {
        cin>>rent[i];
    }

    vector<vector<int>>dp(n+1, vector<int>(4, INT_MAX));
    for(int i = 1 ; i <= n; i++) {
        dp[i][1] = rent[i];
    }

    for(int k = 2 ; k <= 3 ;k++) {
        for(int i = 1 ; i <= n; i ++) {
            for(int j =  1 ; j < i ; j++) {
                if(s[j] < s[i]) {
                    dp[i][k] = min(dp[i][k], dp[j][k-1] + rent[i]);
                }
            }
        }
    }

    int ans = INT_MAX;
    for(int i = 1 ; i <= n ;i++) {
        if(dp[i][3] != INT_MAX) {
            ans = min(ans, dp[i][3]);
        }
    }
    if(ans!=INT_MAX)
    cout<<ans<<"\n";
    else cout<<-1<<"\n";
}


================================================
FILE: Best_Time_To_Buy_And_Sell_Stock_.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

//A very beautiful problem with a tweak of Kadane's algorithm.

int best_time(vector<int>&arr,int n){
    vector<int>diff(n,0);
    for(int i=1;i<n;i++){
        diff[i] = arr[i] - arr[i-1];
    }
    int max_far=diff[0],max_curr=diff[0];
    for(int i=1;i<n;i++){
        max_curr = max(max_curr+diff[i],diff[i]);
        max_far = max(max_curr,max_far);
    }
    return max_far;
}

int main(){
    int n;
    cin>>n;
    vector<int>arr(n);
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    cout<<best_time(arr,n)<<"\n";
}

================================================
FILE: BitonicSequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int main() {
    int t;
    cin>>t;
    while(t--) {
        int n;
        cin>>n;
        vector<int>v(n+1,0);
        for(int i=0;i<n;i++) {
            cin>>v[i];
        }
        vector<int>Lis(n+1,1); 
        vector<int>Lds(n+1,1);
        // cal longest increasing sequence
        for(int i=0;i<n;i++) {
            for(int j = i-1;j>=0;j--) {
                if(v[j]<v[i]) {
                    Lis[i] = max(Lis[i],1+Lis[j]);
                }
            }
        }
        // cal longest decreasing sequence
        for(int i=n-1;i>=0;i--) {
            for(int j = i+1;j<n;j++) {
                if(v[j]<v[i]) {
                    Lds[i] = max(Lds[i],1+Lds[j]);
                }
            }
        }
        int max_len = 1;
        for(int i=0;i<n;i++) {
            max_len = max(Lis[i]+Lds[i]-1,max_len);
        }
        cout<<max_len<<"\n";
    }
}

================================================
FILE: Box_Stacking_Problem.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

struct Box{
    int h;
    int d;
    int w;
};

bool comparator(Box b1, Box b2){
    return (b1.d*b1.w)>(b2.d*b2.w);
}
int maxStackHeight(int h[],int d[],int w[],int n){
    struct Box ini[n];
    for(int i=0;i<n;i++){
        ini[i].h=h[i];
        ini[i].d=d[i];
        ini[i].w=w[i];
    }
    struct Box b[n];
    int ind=0;
    for(int i=0;i<n;i++){
        //Original
        b[i].h = ini[i].h;
        b[i].d = max(ini[i].d,ini[i].w);
        b[i].w = min(ini[i].d,ini[i].w);
        ind++;
        //First Rotation
        b[i].h = ini[i].d;
        b[i].d = max(ini[i].h,ini[i].w);
        b[i].w = min(ini[i].h,ini[i].w);
        ind++;
        //Second Rotation
        b[i].h = ini[i].w;
        b[i].d = max(ini[i].h,ini[i].d);
        b[i].w = min(ini[i].h,ini[i].d);
        ind++;
    }
    int n=3*n;
    sort(b,b+n,comparator);

    int msh[n];//maximum stack height array
    for(int i=0;i<n;i++){
        msh[i]=b[i].h;
    }
    for (int i = 1; i < n; i++ ) 
      for (int j = 0; j < i; j++ ) 
         if ( b[i].w < b[j].w && 
              b[i].d < b[j].d && 
              msh[i] < msh[j] + b[i].h 
            ) 
         { 
              msh[i] = msh[j] + b[i].h; 
         }
    int max = -1; 
   for ( int i = 0; i < n; i++ ) 
      if ( max < msh[i] ) 
         max = msh[i]; 
  
   return max;       
}

================================================
FILE: Circular_Kadene.cpp
================================================
// A very beautiful explalation given in leetcode
// https://leetcode.com/problems/maximum-sum-circular-subarray/discuss/178422/One-Pass
#include<bits/stdc++.h>
using namespace std;

int  maxMoney(int arr[], int num)
{
    int max_far=arr[0],max_curr=arr[0],min_far=arr[0],min_curr=arr[0],total=arr[0];
    for(int i=1;i<num;i++){
        max_curr=max(max_curr+arr[i],arr[i]);
        max_far=max(max_curr,max_far);
        min_curr=min(min_curr+arr[i],arr[i]);
        min_far=min(min_far,min_curr);
        total+=arr[i];
    }
    if(max_far>0){
        return max(max_far,total-min_far);
    }
    else{
        return max_far;
    }
}

================================================
FILE: Coin_Changing_1.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Max_ways(int coins[],int size,int sum){
    int dp[size+1][sum+1];
    for(int i=0;i<=sum;i++){
        dp[0][i]=0;
    }
    for(int i=0;i<=size;i++){
        dp[i][0]=1;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum;j++){
            if(coins[i-1]<=j){
                dp[i][j] = dp[i-1][j] + dp[i][j-coins[i-1]];
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=size;i++){
        for(int j=0;j<=sum;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }

    return dp[size][sum];
}

int main() {
    int coins[] = {1, 2, 3}; 
    int size = sizeof(coins)/sizeof(coins[0]);
    int sum = 4;
    cout<<Max_ways(coins,size,sum)<<"\n"; 
}

================================================
FILE: Coin_Changing_2.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Minm_Coins(int coins[],int size,int sum) {
    int dp[size+1][sum+1];
    for(int i=0;i<=sum;i++){
        dp[0][i] = INT_MAX - 1;
    }
    for(int i=1;i<=size;i++){
        dp[i][0] = 0;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum;j++){
            if(coins[i-1]<=j){
                dp[i][j] = min(dp[i-1][j],1+dp[i][j-coins[i-1]]);
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    return dp[size][sum];
}
int main(){
    int coins[] = {1,6,5,2,8};
    int sum = 11;
    int size = sizeof(coins)/sizeof(coins[0]);
    cout<<Minm_Coins(coins,size,sum)<<"\n";
}

================================================
FILE: Count_All_Increasing_Subsequences.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
//O(n^2) solution
int Count_AIS(int a[],int size){
    int dp[size],ans=0;
    for(int i=0;i<size;i++){
        dp[i]=1;
    }
    for(int i=1;i<size;i++){
        for(int j=0;j<i;j++){
            if(a[i]>a[j]){
                dp[i]+=dp[j];
            }
        }
    }
    for(int i=0;i<size;i++){
        cout<<dp[i]<<" ";
    }
    cout<<"\n";
    for(int i=0;i<size;i++){
        ans+=dp[i];
    }
    return ans;
}

//O(n) solution : A beautiful solution
int AIS(int a[],int size){
    int count[10]={0},ans=0;
    for(int i=0;i<size;i++){
        for(int j=a[i]-1;j>=0;j--){//max 10 times
            count[a[i]]+=count[j];
        }
        count[a[i]]++;
    }
    for(int i=0;i<10;i++){
        ans+=count[i];
    }
    return ans;
}

int main(){
    int a[]={3,2,4,5,4};
    int size=sizeof(a)/sizeof(a[0]);
    cout<<Count_AIS(a,size)<<"\n";
    cout<<AIS(a,size)<<"\n";
}

================================================
FILE: Count_All_Pallindromic_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int CountLPS(string s){
    int n = s.length();
    int dp[n][n];
    memset(dp,0,sizeof(dp));
    for(int i=0;i<n;i++){
        dp[i][i] = 1;
    }
    for(int i=n-2;i>=0;i--){
        for(int j=i+1;j<n;j++){
            if(s[i] == s[j]){
                dp[i][j] = 1 + dp[i][j-1] + dp[i+1][j];
            }
            else{
                dp[i][j] = dp[i][j-1] + dp[i+1][j] - dp[i+1][j-1];
            }
        }
    }
    return dp[0][n-1];
}

int main(){
    string s = "abab";
    cout<<CountLPS(s)<<"\n";
}

================================================
FILE: Count_Distinct_Subsequences.cpp
================================================
#include<bits/stdc++.h>
#define MAX_CHAR 256
using namespace std;
int CDS(string s,int size){
    vector<int>last_char(MAX_CHAR,-1);
    int dp[size+1];
    dp[0]=1;
    for(int i=1;i<=size;i++){
        dp[i] = 2*dp[i-1];
        if(last_char[s[i-1]]!=-1){
            dp[i]=dp[i]-dp[last_char[s[i-1]]];
        }
        last_char[s[i-1]]=(i-1);
    }
    return dp[size];
}
int main(){
    string s="gfg";
    int size=s.length();
    cout<<CDS(s,size)<<"\n";
}

================================================
FILE: Count_Number_of_hops.cpp
================================================
#include<iostream>
using namespace std;
void solve(int n){
    int dp[n];
    dp[1]=1,dp[2]=2,dp[3]=4;
    for(int i=4;i<=n;i++){
        dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
    }
    cout<<dp[n]<<"\n";
}
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n;
	    cin>>n;
	    solve(n);
	}
	return 0;
}

================================================
FILE: Count_Pallindromic_SubString_Of_String_gfg.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int expandAroundCenter(string s,int left,int right){
    if(s.length()==0 || left>right) return 0;
    int ans=0;
    while(left>=0 && right<s.length() && s[left]==s[right]){
        ans++;
        left--;
        right++;
    }
    return ans;
}
int CountLPSubstring(string s){
    if(s.length()==0) return 0;
    int res=0;
    for(int i=0;i<s.length();i++){
        res+=expandAroundCenter(s,i,i);
        res+=expandAroundCenter(s,i,i+1);
    }
    return res;
}
int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        string s;
        cin>>s;
        cout<<CountLPSubstring(s)-n<<"\n";
    }
}

================================================
FILE: Count_Subsets_of_given_Sum.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int CountSubsets(int a[],int size,int sum) {
    int dp[size+1][sum+1];
    for(int i=0;i<=sum;i++){
        dp[0][i] = 0;
    }
    for(int i=0;i<=size;i++){
        dp[i][0]=1;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum;j++){
            if(a[i-1]<=j){
                dp[i][j] = dp[i-1][j] + dp[i-1][j-a[i-1]];
            }
            else {
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=size;i++){
        for(int j=0;j<=sum;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[size][sum];
}

int main() {
    int a[] = { 1, 2, 3, 3 }; 
    int size = 4;
    int sum = 6;
    cout<<CountSubsets(a,size,sum)<<"\n";
}

================================================
FILE: Count_ways_to_N'th_Stair.cpp
================================================
long long countWays(int m){
    long long dp[m+1]={0};
    dp[0]=1;
    for(int i=1;i<=m;i++) dp[i]+=dp[i-1];
    for(int i=2;i<=m;i++) dp[i]+=dp[i-2];
    return dp[m];
}


================================================
FILE: Diameter_Of_Binary_Tree.cpp
================================================
//Function Written only
int helper(Node* node,int &res){
    if(node==NULL) return 0;
    int left=helper(node->left,res);
    int right=helper(node->right,res);
    int tempAns=1+max(left,right);
    int ans=max(tempAns,1+left+right);
    res=max(res,ans);
    return tempAns;
}
int diameter(Node* node) {
    int res=INT_MIN;
    helper(node,res);
    return res;
}


================================================
FILE: Distinct_Occurences.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Count_All_Distinct_Occurences(string s1,string s2){
    int n=s1.length(),m=s2.length();
    if(m>n) return 0;
    int dp[n+1][m+1];
    for(int i=0;i<=m;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<=m;j++){
            if(s1[i-1]==s2[j-1]){
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=n;i++){
        for(int j=0;j<=m;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[n][m];
}
int main(){
    int t;
    cin>>t;
    while(t--){
        string s1,s2;
        cin>>s1>>s2;
        cout<<Count_All_Distinct_Occurences(s1,s2)<<"\n";
    }
}
//s1=banana
//s2=ban
//therefore count=3 ie 3 distinct susequence of s2 occurs in s1;

================================================
FILE: Edit_Distance.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Edit_Distance(string s1,string s2){
    int m = s1.length();
    int n = s2.length();
    int dp[m+1][n+1];
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0) dp[i][j] = j;
            else if(j==0) dp[i][j] = i;
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = dp[i-1][j-1];
            }
            else{
                dp[i][j] = 1 + min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));
            }
        }
    }
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[m][n];
}
int main(){
    string str1 = "sunday"; 
    string str2 = "saturday"; 
    cout<<Edit_Distance(str1,str2)<<"\n";
}

================================================
FILE: Equal_Sum_Partition.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

bool EqualSubsetSum(int a[],int size) {
    int sum=0;
    for(int i=0;i<size;i++){
        sum+=a[i];
    }
    if(sum%2!=0) return false;
    bool dp[size+1][sum/2+1];
    for(int i=0;i<=sum/2;i++){
        dp[0][i] = false;
    }
    for(int i=0;i<=size;i++){
        dp[i][0]=true;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum/2;j++){
            if(a[i-1]<=j){
                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    return dp[size][sum/2];
}

int main() {

    int a[] = {3, 1, 1, 2, 2, 1};  
    int size = sizeof(a) / sizeof(a[0]);
    cout<<EqualSubsetSum(a,size)<<"\n";

}

================================================
FILE: Friends_Pairing_Problem.cpp
================================================
#include<iostream>
#define m 1000000007
using namespace std;
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n;
	    cin>>n;
	    long long int dp[n+1];
	    for(int i=0;i<=n;i++){
	        if(i<=2) dp[i]=i;
	        else{
	            dp[i]=((dp[i-1]%m)+((i-1)%m*(dp[i-2]%m))%m)%m;
	        }
	    }
	    cout<<dp[n]<<"\n";
	}
	return 0;
}

================================================
FILE: Get_Minimum_Squares.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int getMinimumSquares(int n){
    int dp[n+1];
    dp[0]=0;
    dp[1]=1;
    dp[2]=2;
    dp[3]=3;
    for(int i=4;i<=n;i++){
        dp[i]=i;//marking with the maximum
        for(int p=1;p<=ceil(sqrt(i));p++){//maximum it can go is ceil(sqrt(n)
            int temp=p*p;
            if(temp>i) break;
            dp[i]=min(dp[i],1+dp[i-temp]);
        }
    }
    return dp[n];
}
int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        cout<<getMinimumSquares(n)<<"\n";
    }
}

================================================
FILE: GoldMine_Problem.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int main(){
    int t;
    cin>>t;
    while(t--){
        int m,n;
        cin>>n>>m;
        int gold[n][m];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                cin>>gold[i][j];
            }
        }
        int dp[n][m];
        int right,right_up,right_down;
        memset(dp,0,sizeof(dp));
        for(int i=m-1;i>=0;i--){
            for(int j=0;j<n;j++){
                right = (i==m-1)?0:dp[j][i+1];
                right_up=(i==m-1 || j==0)?0:dp[j-1][i+1];
                right_down=(i==m-1 || j==n-1)?0:dp[j+1][i+1];
                dp[j][i]=gold[j][i]+max(right,max(right_up,right_down));
            }
        }
        int ans=dp[0][0];
        for(int i=1;i<n;i++){
            ans=max(ans,dp[i][0]);
        }
        cout<<ans<<"\n";
    }
}

================================================
FILE: Jump_Game_3.cpp
================================================
class Solution {
public:
    bool canReach(vector<int>& arr, int start) {
        int N = arr.size();
        vector<int> tab(N, 0);
        return help(arr, start, tab, N);
    }
    bool help(vector<int>& arr, int start, vector<int>& tab, int N) {
        if ((start < 0 || start > N - 1) || tab[start] == 1) {
            return false;
        }
        if (arr[start] == 0) {
            return true;
        }
        tab[start] = 1;
        if (help(arr, start-arr[start], tab, N)) {
            return true;
        }
        if (help(arr, start+arr[start], tab, N)) {
            return true;
        }
        return false;
    }
};


================================================
FILE: Jump_Game_5.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
//LEETCODE QUESTION

int dp[1001];
int helper(vector<int>& arr,int d,int i){
        if(dp[i]!=-1) return dp[i];
        int ans=1,n=arr.size();
        //right
        for(int j=i+1;j<=min(n-1,i+d)&&arr[i]>arr[j];j++)ans=max(ans,1+helper(arr,d,j));
        //left
        for(int j=i-1;j>=max(0,i-d)&&arr[i]>arr[j];j--)ans=max(ans,1+helper(arr,d,j));
        return dp[i]=ans;
}
int maxJumps(vector<int>& arr, int d) {
        int ans=1;
        for(int i=0;i<arr.size();i++)dp[i]=-1;
        for(int i=0;i<arr.size();i++)ans=max(ans,helper(arr,d,i));
        return ans;
}

================================================
FILE: Kadane.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Kadane(int a[],int size){
    int max_cur=a[0],max_far=a[0];
    for(int i=1;i<size;i++){
        max_cur=max(max_cur+a[i],a[i]);
        max_far=max(max_cur,max_far);
    }
    return max_far;
}

int main(){
    int a[]={8 ,-8 ,9 ,-9 ,10 ,-11 ,12};
    int size=sizeof(a)/sizeof(a[0]);
    cout<<Kadane(a,size)<<"\n";
}

================================================
FILE: Knapsack_0_1.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int knapsack(int wt[],int val[],int W,int size){
    int dp[size+1][W+1];
    for(int i=0;i<=size;i++){
        for(int j=0;j<=W;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(wt[i-1]<=j){
                dp[i][j] = max(dp[i-1][j],val[i-1] + dp[i-1][j-wt[i-1]]);
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    return dp[size][W];
}

int main() {
    
    int val[] = {60, 100, 120}; 
    int wt[] = {10, 20, 30}; 
    int  W = 50; 
    int size = sizeof(val)/sizeof(val[0]); 
    cout<<knapsack(wt,val,W,size)<<"\n";

}

================================================
FILE: Last_Stone_3.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
//Leetcode Question

//Recurssion base soln
int helper(vector<int>& s,int i){
        if(i>=s.size()) return 0;
        else{
            int ans=INT_MIN;
            ans=max(ans,s[i]-helper(s,i+1));
            if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));
            if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-helper(s,i+3));
            return ans;
        }
    }
string stoneGameIII(vector<int>& s) {
    int ans=helper(s,0);
    if(ans<0) return "Bob";
    else if(ans==0) return "Tie";
    return "Alice";
}
//Memonization based soln
int dp[500001];
int helper(vector<int>&s,int i){
    if(i>=s.size()) return 0;
    if(dp[i]!=-1) return dp[i];
    else{
        int ans=INT_MIN;
        ans=max(ans,s[i]-helper(s,i+1));
        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));
        if(i+2<s.size()) ans=max(ans,dp[i]+dp[i+1]+dp[i+2]-helper(s,i+3));
        return dp[i]=ans;
    }
}
string stoneGameIII(vector<int>& s) {
    for(int i=0;i<s.size();i++)dp[i]=-1;
    int ans=helper(s,0);
    if(ans<0) return "Bob";
    else if(ans==0) return "Tie";
    return "Alice";
}
//Bottom Up approach
string stoneGameIII(vector<int>& s) {
    int n=s.size();
    vector<int>dp(n+1,0);
    int i=n-1;
    while(i>=0){
        int ans=INT_MIN;
        ans=max(ans,s[i]-dp[i+1]);
        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-dp[i+2]);
        if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-dp[i+3]);
        dp[i]=ans;
    }
    int ans=dp[0];
    if(ans<0) return "Bob";
    else if(ans==0) return "Tie";
    return "Alice";
}

int main(){
    //take input
}

================================================
FILE: Longest_Common_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int Lcs(string s1,string s2){
    int m = s1.length(),n = s2.length();
    int dp[m+1][n+1];
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0) dp[i][j]=0;
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = 1 + dp[i-1][j-1];
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[m][n];
}

int main(){
    string s1 = "abcdgl";
    string s2 = "abedfhl";
    cout<<Lcs(s1,s2)<<"\n";
}

================================================
FILE: Longest_Common_Substring.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int LCSub(string s1,string s2){
    int m = s1.length(),n = s2.length();
    int dp[m+1][n+1],res=0;
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = 1 + dp[i-1][j-1];
                res = max(res,dp[i][j]);
            }
            else{
                dp[i][j] = 0;
            }
        }
    }
    return res;
}
int main(){
    string s1 = "abcdgl";
    string s2 = "abedgl";
    cout<<LCSub(s1,s2)<<"\n";
}



================================================
FILE: Longest_Consequetive_Subsequence.cpp
================================================
#include<iostream>
using namespace std;
int main()
 {
     int t;
     cin>>t;
     while(t--){
         int n;
         cin>>n;
         int m[100001]={0};
         int a[n];
         for(int i=0;i<n;i++) cin>>a[i];
         for(int i=0;i<n;i++){
             m[a[i]]++;
	    }
	    int count=0,res=-1;
	    for(int i=0;i<100001;i++){
	        if(m[i]>=1)count++;
	        else count=0;
	       res=max(res,count);
	    }
	    cout<<res<<"\n";
    }
	return 0;
}

================================================
FILE: Longest_Decreasing_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int LDS(int a[],int size){
    int dp[size+1],res=1;
    for(int i=0;i<size;i++){
        dp[i] = 1;
    }
    for(int i=size-1;i>=0;i--){
        for(int j=0;j<i;j++){
            if(a[i]>a[j]){
                dp[i] = max(dp[i],1+dp[j]);
            }
        }
        res = max(res,dp[i]);
    }
    return res;
}
int main(){
    int a[] = {10,9,2,5,3,7,101,18};
    int size = sizeof(a)/sizeof(a[0]);
    cout<<LDS(a,size)<<"\n";
}

================================================
FILE: Longest_Increasing_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int LIS(int a[],int size){
    int dp[size+1],res=1;
    for(int i=0;i<size;i++){
        dp[i] = 1;
    }
    for(int i=0;i<size;i++){
        for(int j=0;j<i;j++){
            if(a[i]>a[j]){
                dp[i] = max(dp[i],1+dp[j]);
            }
        }
        res = max(res,dp[i]);
    }
    return res;
}
int main(){
    int a[] = {10,9,2,5,3,7,101,18};
    int size = sizeof(a)/sizeof(a[0]);
    reverse(a,a+size);
    cout<<LIS(a,size)<<"\n";
}

================================================
FILE: Longest_Pallindromic_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

//used bottom-up aproach(but similar to lcs)
int longestPalindromeSubseq(string s) {
        int n=s.length();
        int dp[n+1][n+1];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j)dp[i][j]=1;
                else if(j<i)dp[i][j]=0;
            }
        }
        for(int i=n-2;i>=0;i--){
            for(int j=i+1;j<n;j++){
                    if(s[i]==s[j]){
                        dp[i][j]=2+dp[i+1][j-1];
                    }
                    else{
                        dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
                    }
            }
        }
    return dp[0][n-1];
}

int main(){
    string s = "bbbab";
    cout<<longestPalindromeSubseq(s)<<"\n";
}

================================================
FILE: Longest_Pallindromic_Substring.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int expandAroundCenter(string s,int left,int right){
    if(s.length()==0 || left>right) return 0;
    while(left>=0 && right<s.length() && s[left]==s[right]){
        left--;
        right++;
    }
    return right-left-1;
}
string LPSubstring(string s){
    if(s.length()==0) return "";
    int start=0,end=0;
    for(int i=0;i<s.length();i++){
        int len1=expandAroundCenter(s,i,i);
        int len2=expandAroundCenter(s,i,i+1);
        int len=max(len1,len2);
        if(len>end-start){
            start=i-(len-1)/2;
            end=i+len/2;
        }
    }
    return s.substr(start,end-start+1);
}
int main(){
    string s = "helppreanadkada";
    cout<<LPSubstring(s)<<"\n";
}

================================================
FILE: Longest_Repeating_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int LRS(string s){
    int n = s.length();
    int dp[n+1][n+1];
    for(int i=0;i<=n;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(s[i-1] == s[j-1] && i!=j){
                dp[i][j] = 1 + dp[i-1][j-1];
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    return dp[n][n];
}

int main() {
    string s = "aabebcdd";
    cout<<LRS(s)<<"\n";
}

================================================
FILE: Matrix_Chain_Multiplication.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int dp[5][5];
int MCM(int a[],int i,int j){
    if(i>=j) return 0;
    if(dp[i][j] != -1) return dp[i][j];
    int ans = INT_MAX,temp_ans;
    for(int k=i;k<j;k++){
        temp_ans = MCM(a,i,k) + MCM(a,k+1,j) + a[i-1]*a[k]*a[j];
        ans = min(ans,temp_ans);
    }
    return ans;
}

int main(){
    int a[] = {1, 2, 3, 4, 3}; 
    int size = sizeof(a)/sizeof(a[0]);
    memset(dp,-1,sizeof(dp));
    cout<<MCM(a,1,size-1);
}

================================================
FILE: Max_Path_Sum_in_Triangle.cpp
================================================
#include<bits/stdc++.h>
#define N 4
using namespace std;

int Max_Sum_Tri(int t[][N],int m,int n){
    for(int i=m-2;i>=0;i--){
        for(int j=0;j<=i;j++){
            t[i][j] = max(t[i+1][j],t[i+1][j+1])+t[i][j]; 
        }
    }
    return t[0][0];
}

int main(){
    int t[N][N] = { {3,0,0,0},
                    {7,4,0,0},
                    {2,4,6,0},
                    {8,5,9,3} };
    cout<<Max_Sum_Tri(t,4,4)<<"\n";                   
}



================================================
FILE: Max_path_sum.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
vector<int>v(100,0);
vector<int>dp(100,0);
vector<int>adj[100];
int largest_sum(int child,int parent) {
    dp[child] = v[child];
    int max_val = 0;
    for(auto ch : adj[child]) {
        if(ch==parent)continue;

        largest_sum(ch,child);
        max_val = max(max_val, dp[ch]);
    }
    return dp[child] += max_val;
}
int main() {
    int n;
    cin>>n;
    cout<<"Enter the nodes value\n";
    for(int i=1;i<=n;i++) {
        cin>>v[i];
    }        
    for(int i=0;i<n-1;i++) {
        int a,b;
        cin>>a>>b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    cout<<largest_sum(1,-1)<<"\n";
}

================================================
FILE: Maximize_the_cutting.cpp
================================================
#include<iostream>
using namespace std;
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n,x,y,z;
	    cin>>n;
        cin>>x>>y>>z;
	    int dp[n+1];
        for(int i=0;i<=n;i++) dp[i]=-1;
	    dp[0]=0;
	    for(int i=0;i<=n;i++){
            if(dp[i]==-1) continue;
	        if(i+x<=n){
	            dp[i+x]=max(dp[i+x],dp[i]+1);
	        }
	        if(i+y<=n){
	            dp[i+y]=max(dp[i+y],dp[i]+1);
	        }
	        if(i+z<=n){
	            dp[i+z]=max(dp[i+z],dp[i]+1);
	        }
	    }
        for(int i=0;i<=n;i++){
            cout<<dp[i]<<" ";
        }
        cout<<"\n";
	    cout<<dp[n]<<"\n";
	}
	return 0;
}

================================================
FILE: Maximum_Dot_Product_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;


int maxDotProduct(vector<int>& A, vector<int>& B,int size1,int size2) {
        vector<vector<int>>dp(size1,vector<int>(size2));
        for(int i=0;i<size1;i++){
            for(int j=0;j<size2;j++){
                dp[i][j]=A[i]*B[j];
                if(i>=1 && j>=1) dp[i][j] = dp[i][j]+max(dp[i-1][j-1],0);
                if(i>=1) dp[i][j] = max(dp[i][j],dp[i-1][j]);
                if(j>=1) dp[i][j] = max(dp[i][j],dp[i][j-1]);
            }
        }
    return dp[size1-1][size2-1];
}


int main(){
    int size1,size2;
    cin>>size1>>size2;
    vector<int>A(size1);
    vector<int>B(size2);
    for(int i=0;i<size1;i++){
        cin>>A[i];
    }
    for(int i=0;i<size2;i++){
        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];
    }
};

================================================
FILE: Maximum_Path_Sum_in_Binary_tree.cpp
================================================
//Only function Written
class Solution {
    int maxToRoot(TreeNode *root, int &re) {
        if (!root) return 0;
        int l = maxToRoot(root->left, re);
        int r = maxToRoot(root->right, re);
        if (l < 0) l = 0;
        if (r < 0) r = 0;
        re=max(re,l+r+root->val);
        return root->val += max(l, r);
    }
public:
    int maxPathSum(TreeNode *root) {
        int re = -2147483648;
        maxToRoot(root, re);
        return re;
    }
};

================================================
FILE: Maximum_Product_Increasing_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int MPIS(int a[],int size){
    int dp[size];
    for(int i=0;i<size;i++){
        dp[i] = a[i];
    }
    for(int i=1;i<size;i++){
        for(int j=0;j<i;j++){
            if(a[i]>a[j] && dp[i]<(a[i]*dp[j])){
                dp[i] = a[i]*dp[j];
            }
        }
    }
    int max = dp[0];
    for(int i=1;i<size;i++){
        if(dp[i]>max){
            max = dp[i];
        }
    }
    return max;
}

int main(){
    int a[] = { 3, 100, 4, 5, 150, 6 };  
    int size = sizeof(a)/sizeof(a[0]);
    cout<<MPIS(a,size)<<"\n";  
}

================================================
FILE: Maximum_Size_Submatrix_Square.cpp
================================================
#include<bits/stdc++.h>
#define r 6
#define c 5
using namespace std;
int Max_Square(int M[r][c]){
    int dp[r][c],ans=0;
    for(int i=0;i<c;i++){
        dp[0][i] = M[0][i];
    }
    for(int i=0;i<r;i++){
        dp[i][0] = M[i][0];
    }
    for(int i=1;i<r;i++){
        for(int j=1;j<c;j++){
            if(M[i][j] == 1){
                dp[i][j] = min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1])) + 1;
            }
            else dp[i][j] = dp[i-1][j-1];
            ans = max(ans,dp[i][j]);
        }
    }
    for(int i=0;i<r;i++){
        for(int j=0;j<c;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return ans;
}

int main(){
    int M[r][c] = {{0, 1, 1, 0, 1},  
                    {1, 1, 0, 1, 0},  
                    {0, 1, 1, 1, 0},  
                    {1, 1, 1, 1, 0},  
                    {1, 1, 1, 1, 1},  
                    {0, 0, 0, 0, 0}};
    cout<<Max_Square(M)<<"\n";                
}

================================================
FILE: Maximum_Sum_Decreasing_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int MSDS(int a[],int size){
    int dp[size];
    for(int i=0;i<size;i++){
        dp[i] = a[i];
    }
    for(int i=1;i<size;i++){
        for(int j=0;j<i;j++){
            if(a[i]>a[j] && dp[i]<a[i]+dp[j]){
                dp[i] = a[i]+dp[j];
            }
        }
    }
    int max = dp[0];
    for(int i=1;i<size;i++){
        if(dp[i]>max){
            max = dp[i];
        }
    }
    return max;
}

int main(){
    int a[] = {1, 101, 2, 3, 100, 4, 5};  
    int size = sizeof(a)/sizeof(a[0]);
    reverse(a,a+size);
    cout<<MSDS(a,size)<<"\n";  
}

================================================
FILE: Maximum_Sum_Dividing_Recurssive.cpp
================================================
#include<iostream>
using namespace std;
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n;
	    cin>>n;
	    int dp[n+1];
	    dp[0]=0,dp[1]=1;
	    for(int i=2;i<=n;i++){
	        dp[i]=max(dp[i/2]+dp[i/3]+dp[i/4],i);
	    }
	    cout<<dp[n]<<"\n";
	}
	return 0;
}

================================================
FILE: Maximum_Sum_Increasing_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int MSIS(int a[],int size){
    int dp[size];
    for(int i=0;i<size;i++){
        dp[i] = a[i];
    }
    for(int i=1;i<size;i++){
        for(int j=0;j<i;j++){
            if(a[i]>a[j] && dp[i]<a[i]+dp[j]){
                dp[i] = a[i]+dp[j];
            }
        }
    }
    int max = dp[0];
    for(int i=1;i<size;i++){
        if(dp[i]>max){
            max = dp[i];
        }
    }
    return max;
}

int main(){
    int a[] = {1, 101, 2, 3, 100, 4, 5};  
    int size = sizeof(a)/sizeof(a[0]);
    cout<<MSIS(a,size)<<"\n";  
}

================================================
FILE: Maximum_length_of_pairs.cpp
================================================
int findLongestChain(vector<vector<int>>& pairs) {
        int n=pairs.size();
        int dp[n+1],res=1;
        sort(pairs.begin(),pairs.end());
        for(int i=0;i<n;i++){
            dp[i]=1;
        }
        for(int i=1;i<n;i++){
            for(int j=0;j<i;j++){
                if(pairs[i][0]>pairs[j][1]){
                    dp[i]=max(dp[i],1+dp[j]);
                }
            }
            res=max(res,dp[i]);
        }
        if(n==0)return 0;
        else return res;
    }

================================================
FILE: Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int minimumDeleteSum(string s1, string s2) {
        int m=s1.length(),n=s2.length();
        int dp[m+1][n+1];
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                dp[i][j]=0;
            }
        }
        for(int i=1;i<=m;i++){
            dp[i][0]=dp[i-1][0]+s1[i-1];
        }
        for(int j=1;j<=n;j++){
            dp[0][j]=dp[0][j-1]+s2[j-1];
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(s1[i-1]==s2[j-1]){
                    dp[i][j]=dp[i-1][j-1];
                }
                else{
                    dp[i][j]=min(dp[i-1][j]+s1[i-1],dp[i][j-1]+s2[j-1]);
                }
            }
        }
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                cout<<dp[i][j]<<" ";
            }
            cout<<"\n";
        }
        return dp[m][n];
}
int main(){
    string s1="eat";
    string s2="sea";
    minimumDeleteSum(s1,s2);
}

================================================
FILE: Minimum_Initial_Points_To_Reach_Destinaion.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

const int maxm=100000;
int a[3][3];
int r=3,c=3;
//One of the best problems come across.
int MinmIniPoints(int a[][3]){
    int dp[r+1];
    for(int i=0;i<=r;i++){
        dp[i]=INT_MAX;
    }
    dp[r-1]=1;
    for(int j=c-1;j>=0;j--){
        for(int i=r-1;i>=0;i--){
            dp[i]=min(dp[i],dp[i+1])-a[i][j];
            dp[i]=max(1,dp[i]);
        }
    }
    return dp[0];
}
int main(){
    int a[3][3] = { {-2,-3,3}, 
                      {-5,-10,1}, 
                      {10,30,-5} 
                    };
    cout<<MinmIniPoints(a);                  
}

================================================
FILE: Minimum_Jumps_To_Reach_End.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

//o(n^2)
int Min_Jumps(int a[],int size){
    int dp[size];
    dp[0] = 0;
    for(int i=1;i<size;i++){
        dp[i] = INT_MAX;
        for(int j=0;j<i;j++){
            if(i<=j+a[j] && dp[j]!=INT_MAX){
                dp[i] = min(dp[i],1+dp[j]);
            }
        }
    }
    return dp[size-1];
}

//O(n)
int minJumps(int a[],int n){
    if(n<=1) return 0;
    if(a[0]==0) return -1;
    int maxReach=a[0];
    int step=a[0];
    int jump=1;
    int i=1;
    for(int i=1;i<n;i++){
        if(i == n-1) return jump;
        maxReach=max(maxReach,i+a[i]);
        step--;
        if(step == 0){
            jump++;
            if(i>=maxReach) return -1;
            step=maxReach-i;
        }
    }
    return -1;
}

int main(){
    int a[] = { 1, 3, 6, 1, 0, 9 }; 
    int size = sizeof(a) / sizeof(a[0]);
    cout<<Min_Jumps(a,size)<<"\n"; 
}


================================================
FILE: Minimum_Subset_Sum_Difference.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int Minm_SubsetSum_Diff(int a[],int size){
    int sum = 0;
    for(int i=0;i<size;i++){
        sum += a[i];
    }
    int dp[size+1][sum+1];
    for(int i=0;i<=sum;i++){
        dp[0][i] = 0;
    }
    for(int i=0;i<=size;i++){
        dp[i][0] = 1;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum;j++){
            if(a[i-1]<=j){
                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    int diff;
    for(int i=sum/2;i>=0;i--){
        if(dp[size][i]==1){
            diff = sum-2*i;
            break;
        }
    }
    return diff;
}
int main(){
    int a[] = {3, 1, 4, 2, 2, 1}; 
    int size = sizeof(a)/sizeof(a[0]);
    cout<<Minm_SubsetSum_Diff(a,size)<<"\n"; 
}

================================================
FILE: Minm_Cost_To_Fill_Bag.cpp
================================================
//A very very good variation of Unbounded Knapsack.#include<iostream>
#include<bits/stdc++.h>
#define INF 1000000
using namespace std;

int minm_Cost(int cost[],int n,int W){
    vector<int>val,wt;
    int size=0;
    for(int i=0;i<n;i++){
        if(cost[i]!=-1){
            val.push_back(cost[i]);
            wt.push_back(i+1);
            size++;
        }
    }
    cout<<size<<"\n";
    n=size;
    cout<<n<<"\n";
    int dp[n+1][W+1];
    // fill 0th row with infinity 
    for (int i=0; i<=W; i++) 
        dp[0][i] = INF; 
  
    // fill 0'th column with 0 
    for (int i=1; i<=n; i++) 
        dp[i][0] = 0; 
        
    for(int i=1;i<=n;i++){
        for(int j=1;j<=W;j++){
            if(wt[i-1]<=j){
                dp[i][j] = min(dp[i-1][j],val[i-1] + dp[i][j-wt[i-1]]);
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=n;i++){
        for(int j=0;j<=W;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return (dp[n][W]==INF)? -1: dp[n][W]; 
}
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n,W;
	    cin>>n>>W;
	    int cost[n];
	    for(int i=0;i<n;i++){
	        cin>>cost[i];
	    }
	    cout<<minm_Cost(cost,n,W)<<"\n";
	}
	return 0;
}

================================================
FILE: Minm_Deletion_To_Make_Pallindrome.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int DelPallin(string s){
    int n = s.length(),lps;
    int dp[n+1][n+1];
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i==j) dp[i][j] = 1;
            else if(j<i) dp[i][j] = 0;
        }
    }
    for(int i=n-2;i>=0;i--){
        for(int j=i+1;j<n;j++){
            if(s[i] == s[j]){
                dp[i][j] = 2 + dp[i+1][j-1];
            }
            else{
                dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
            }
        }
    }
    lps = dp[0][n-1];
    return n-lps;
}
int main() {
    string s = "aebcbda";
    cout<<DelPallin(s)<<"\n";
}

================================================
FILE: Minm_Insertion_Deletion_Convert.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Idconvert(string s1,string s2){
    int m = s1.length(),n=s2.length(),lcs;
    int dp[m+1][n+1];
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = 1 + dp[i-1][j-1];
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    lcs = dp[m][n];
    cout<<"Minimum Insertions : "<<m-lcs<<"\n";
    cout<<"Minimum Deletions : "<<n-lcs<<"\n";
    return m+n-(2*lcs);
}

int main() {
    string s1 = "heap";
    string s2 = "pea";
    cout<<Idconvert(s1,s2)<<"\n";
}

================================================
FILE: No_Of_Ways_To_Tile.cpp
================================================
#include<iostream>
using namespace std;
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int n;
	    cin>>n;
	    long long int dp[n+1];
	    dp[0]=0;
	    for(int i=1;i<=n;i++){
	        if(i<=3) dp[i]=1;
	        else if (i==4) dp[i]=2;
	        else dp[i] = dp[i-1]+dp[i-4];
	    }
	    cout<<dp[n]<<"\n";
	}
	return 0;
}

================================================
FILE: Number_of_ways_to_decode_a_string.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// similar to fibonacci
int countWays(string s){
    int n = s.length();
    int dp[n+1];
    for(int i=0;i<n;i++) dp[i] = 0;
    dp[0] = 1;
    dp[1] = 1;
    for(int i=2;i<=n;i++){
        if(s[i-1] > '0'){
            dp[i] = dp[i-1];
        }
        if(s[i-2] == '1' || (s[i-2] == '2' && s[i-1] <= '7')){
            dp[i] += dp[i-2];
        }
    }
    return dp[n];
}


int main(){
    string s;
    cin>>s;
    cout<<countWays(s)<<"\n";
}

================================================
FILE: Optimal_Strategy_To_Play_A_Game.cpp
================================================
#include<bits/stdc++.h>
#define N 5
using namespace std;

int dp[N][N];

int OptimalStrategy(int coins[],int i,int j){
    //Base Cases
    if(i==j)  return coins[i];
    if(i==j+1) return max(coins[i],coins[j]);
    if(dp[i][j]==0){
        //Taking from the start
        int start = coins[i] + min(OptimalStrategy(coins,i+2,j),OptimalStrategy(coins,i+1,j-1));
        //Taking from end
        int end = coins[j] + min(OptimalStrategy(coins,i,j-2),OptimalStrategy(coins,i+1,j-1));
        //maximum of both
        dp[i][j] = max(start,end);
    }
    return dp[i][j];
}

int main(){

}

================================================
FILE: Path_In_A_Matrix.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int cost[1000][1000];
void solve(int n,int cost[][1000]){
    int dp[n][n];
    memset(dp,0,sizeof(dp));
    for(int i=n-1;i>=0;i--){
        for(int j=n-1;j>=0;j--){
            int down=(i==n-1)?0:dp[i+1][j];
            int down_left=(i==n-1 || j==0)?0:dp[i+1][j-1];
            int down_right=(i==n-1 || j==n-1)?0:dp[i+1][j+1];
            dp[i][j]= cost[i][j]+max(down,max(down_right,down_left));
        }
    }
    int ans=dp[0][0];
    for(int i=1;i<n;i++){
        ans=max(ans,dp[0][i]);
    }
    cout<<ans<<"\n";
}
int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cin>>cost[i][j];
            }
        }
        solve(n,cost);
    }
}

================================================
FILE: Print_Longest_Common_Subsequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
string PrintLcs(string s1,string s2){
    int m = s1.length(),n = s2.length();
    int dp[m+1][n+1];
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0) dp[i][j]=0;
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = 1 + dp[i-1][j-1];
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    int i=m,j=n;
    string ans="";
    while(i>0 && j>0){
        if(s1[i-1] == s2[j-1]){
            ans.push_back(s1[i-1]);
            i--;
            j--;
        }
        else if(dp[i][j-1]>dp[i-1][j]){
            j--;
        }
        else{
            i--;
        }
    }
    reverse(ans.begin(),ans.end());
    return ans;
}

int main(){
    string s1 = "abcdgl";
    string s2 = "abedfhl";
    cout<<PrintLcs(s1,s2)<<"\n";
}

================================================
FILE: Procuct_of_array_except_self.cpp
================================================
https://leetcode.com/explore/featured/card/30-day-leetcoding-challenge/530/week-3/3300/

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int>left(n+1,1);
        vector<int>right(n+1,1);
        left[0] = nums[0];
        right[n-1] = nums[n - 1 ];
        for(int i = 1;i<n;i++) {
            left[i] = left[i - 1 ] * nums[i];
        }
        for(int i = n - 2;i >= 0 ; i--) {
            right[i] = right[i+1] * nums[i];
        }
        vector<int>ans(n);
        for(int i = 0;i<n;i++) {
            if(i == 0) {
                ans[i] = right[i + 1];
            }
            if ( i == n-1 ) {
                ans[i] = left[i - 1];
            }
            if(i > 0 and i< n -1 ) {
                ans[i] = left[i - 1] * right[i + 1];
            }
            
        }
        return ans;
    }
};

================================================
FILE: README.md
================================================
# Dynamic-Programming
A DP a day keeps the bug away.

**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>
2) [Circular Kadane](/Circular_Kadene.cpp)<br>

**Parent Problem** : *Fibonacci*.<br>
SubProblems :<br>
1) [Reach a given Score](/Reach_a_given_score.cpp).<br>
2) [Count number of hops](/Count_Number_of_hops.cpp).<br>
3) [Count ways to reach n-th stair](/Count_ways_to_N'th_Stair.cpp).<br>
4) [Count Number of Ways to Tile](/No_Of_Ways_To_Tile.cpp).<br>
5) [Tiling Problem-General](/Tiling_Problem.cpp).<br>
6) [Maximum Sum Dividing](/Maximum_Sum_Dividing_Recurssive.cpp).<br>
7) [Friends Pairing Problem](/Friends_Pairing_Problem.cpp)<br>
8) [Maximize the Cutting](/Maximize_the_cutting.cpp)<br>
9) [Number of Ways to Decode a String](/Number_of_ways_to_decode_a_string.cpp)

**Parent Problem** : [*0/1 KnapSack Problem*](/Knapsack_0_1.cpp)<br>
SubProblems :<br>
1) [SubSet Sum](/SubsetSum.cpp).<br>
2) [Equal Sum Partition](/Equal_Sum_Partition.cpp).<br>
3) [Count of SubSet Sum]().<br>
4) [Minimum SubSet Sum Difference](/Minimum_Subset_Sum_Difference.cpp).<br>
5) [Count SubSets of given Sum](/Count_Subsets_of_given_Sum.cpp).<br><br>

**Parent Problem** : [*Unbounded KnapSack*](/Unbounded_Knapsack.cpp)<br>
SubProblems :<br>
1) [Coin Changing Problem 1(No of ways)](/Coin_Changing_1.cpp).<br>
2) [Coin Changing Problem 2(Minimum no of coins)](/Coin_Changing_2.cpp).<br>
3) [Rod Cutting Problem](/Rod_Cutting.cpp).<br>
4) [Minimum Cost to Fill Bag](/Minm_Cost_To_Fill_Bag.cpp).<br><br>

**Parent Problem** : [*Longest Common SubSequence*](/Longest_Common_Subsequence.cpp)<br>
SubProblems :<br>
1) [Longest Common SubString](/Longest_Common_Substring.cpp).<br>
2) [Shortest Common SuperSequence](/Shortest_Common_Supersequence.cpp).<br>
3) [Print LCS](/Print_Longest_Common_Subsequence.cpp).<br>
4) [Minimum Insertions And Deletion to Convert a String](/Minm_Insertion_Deletion_Convert.cpp).<br>
5) [Longest Repeating SubSequence](/Longest_Repeating_Subsequence.cpp).<br>
6) [Longest Pallindromic SubSequence](/Longest_Pallindromic_Subsequence.cpp).<br>
7) [Edit Distance](/Edit_Distance.cpp).<br>
8) [Count All Pallindromic SubSequence](/Count_All_Pallindromic_Subsequence.cpp).<br>
9) [Minimum Deletion to make string pallindrome](/Minm_Deletion_To_Make_Pallindrome.cpp).<br>
10) [Count Distinct Occcurences](/Distinct_Occurences.cpp).<br>
11) [Maximum length of pairs](/Maximum_length_of_pairs.cpp).<br>
12) [Minimum Ascii Sum deletion To Make two Strings equal](/Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp).<br>
13) [Maximum Dot Product of Subsequences(Leetcode)](/Maximum_Dot_Product_Subsequence.cpp).<br>
14) [Uncrossed Lines(LeetCode)](/Uncrossed_Lines.cpp).<br><br>

**Parent Problem** : [*Longest Increasing Subsequence*](/Longest_Increasing_Subsequence.cpp)<br>
1) [Russian Doll Envelope(Leetcode)](/Russian_Doll_Envelope.cpp).<br>
2) [Longest Decreasing SubSequence](/Longest_Decreasing_Subsequence.cpp).<br>
3) [Maximum Sum Increasing SubSequence](/Maximum_Sum_Increasing_Subsequence.cpp).<br>
4) [Maximum Sum Decreasing SubSequence](/Maximum_Sum_Decreasing_Subsequence.cpp).<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>
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).<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>
2) [Maximum Path Sum in Triangle](/Max_Path_Sum_in_Triangle.cpp).<br>
3) [Minimum Initial Points to Reach Destination](/Minimum_Initial_Points_To_Reach_Destinaion.cpp).<br>
4) [GoldMine Problem](/GoldMine_Problem.cpp)<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)<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) [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!!





================================================
FILE: Reach_a_given_score.cpp
================================================
#include<iostream>
using namespace std;
void solve(int sum){
    int dp[sum+1]={0};
    dp[0]=1;
    for(int i=3;i<=sum;i++) dp[i]+=dp[i-3];
    for(int i=5;i<=sum;i++) dp[i]+=dp[i-5];
    for(int i=10;i<=sum;i++) dp[i]+=dp[i-10];
    
    cout<<dp[sum]<<"\n";
}
int main()
 {
	int t;
	cin>>t;
	while(t--){
	    int sum;
	    cin>>sum;
	    solve(sum);
	}
	return 0;
}

//similar to coin changing

================================================
FILE: Rod_Cutting.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int rodCutting(int cost[],int len[],int size) {
    int dp[size+1][size+1];
    for(int i=0;i<=size;i++){
        for(int j=0;j<=size;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(len[i-1]<=j){
                dp[i][j] = max(dp[i-1][j],cost[i-1] + dp[i][j-len[i-1]]);
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=size;i++){
        for(int j=0;j<=size;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[size][size];
}

int main() {
    int len[] = {1, 2, 3, 4, 5, 6, 7, 8};
    int cost[] = {1, 5, 8, 9, 10, 17, 17, 20};
    int size = sizeof(cost)/sizeof(cost[0]);
    cout<<rodCutting(cost,len,size);
}


================================================
FILE: Russian_Doll_Envelope.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// Problem Statement : https://leetcode.com/problems/russian-doll-envelopes/

//Similar to LIS with a tweak.
int maxEnvelopes(vector<vector<int>>& envelopes) {
    sort(envelopes.begin(),envelopes.end());
    int n=envelopes.size(),res=1;
    vector<int>dp(n,1);
    for(int i=1;i<n;i++){
        for(int j=0;j<i;j++){
            if(envelopes[i][0]>envelopes[j][0] && envelopes[i][1]>envelopes[j][1]){
                dp[i] = max(dp[i],1+dp[j]);
            }
        }
        res = max(res,dp[i]);
    }
    if(n==0) return 0;
    else return res;
}




================================================
FILE: Shortest_Common_Supersequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int Scs(string s1,string s2){
    int m = s1.length(),n=s2.length(),lcs;
    int dp[m+1][n+1];
    for(int i=0;i<=m;i++){
        for(int j=0;j<=n;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(s1[i-1] == s2[j-1]){
                dp[i][j] = 1 + dp[i-1][j-1];
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    lcs = dp[m][n];
    return m+n-lcs;
}
int main(){
    string s1 = "abcdgl";
    string s2 = "abedfhl";
    cout<<Scs(s1,s2)<<"\n";
}

================================================
FILE: SubsetSum.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
bool SubsetSum(int a[],int size,int sum) {
    bool dp[size+1][sum+1];
    for(int i=0;i<=sum;i++){
        dp[0][i] = false;
    }
    for(int i=0;i<=size;i++){
        dp[i][0]=true;
    }
    for(int i=1;i<=size;i++){
        for(int j=1;j<=sum;j++){
            if(a[i-1] <= j) {
                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];
            }
            else {
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    return dp[size][sum];
}

int main() {
    int a[] = {3, 34, 4, 12, 5, 2}; 
    int sum = 1; 
    int size = sizeof(a)/sizeof a[0];
    cout<<SubsetSum(a,size,sum)<<"\n";
}

================================================
FILE: Tiling_Problem.cpp
================================================
#include <bits/stdc++.h> 
using namespace std;
 
int CountWays(int n, int m) 
{ 
    int dp[n + 1]; 
    dp[0] = 0; 
    for (int i = 1; i <= n; i++) { 
        if (i > m) 
            dp[i] = dp[i - 1] + dp[i - m]; 
        else if (i < m) 
            dp[i] = 1; 
        else
            dp[i] = 2; 
    } 
    return dp[n]; 
}
int main() 
{ 
    int n = 7, m = 4; 
    cout << "Number of ways = "
         << CountWays(n, m); 
    return 0; 
} 

================================================
FILE: Unbounded_Knapsack.cpp
================================================
#include<bits/stdc++.h>
using namespace std;
int knapsack(int wt[],int val[],int W,int size){
    int dp[size+1][W+1];
    for(int i=0;i<=size;i++){
        for(int j=0;j<=W;j++){
            if(i==0 || j==0){
                dp[i][j] = 0;
            }
            else if(wt[i-1]<=j){
                dp[i][j] = max(dp[i-1][j],val[i-1] + dp[i][j-wt[i-1]]);
            }
            else{
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    for(int i=0;i<=size;i++){
        for(int j=0;j<=W;j++){
            cout<<dp[i][j]<<" ";
        }
        cout<<"\n";
    }
    return dp[size][W];
}

int main() {
    
    int wt[] = {1, 3, 2}; 
    int val[] = {50, 10, 15}; 
    int  W = 10; 
    int size = sizeof(val)/sizeof(val[0]); 
    cout<<knapsack(wt,val,W,size)<<"\n";

}

================================================
FILE: Uncrossed_Lines.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

int maxUncrossedLines(vector<int>& A, vector<int>& B,int n,int m) {
    vector<vector<int>>dp(m+1,vector<int>(n+1,0));
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            if(A[i-1]==B[j-1]){
                dp[i][j] = 1+dp[i-1][j-1];
            }
            else{
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
    return dp[m][n];
}


int main(){
    int m,n;
    cin>>m>>n;
    vector<int>A(m),B(n);
    for(int i=0;i<m;i++){
        cin>>A[i];
    }
    for(int i=0;i<n;i++){
        cin>>B[i];
    }
    cout<<maxUncrossedLines(A,B,m,n)<<"\n";
}

================================================
FILE: count_submatrices_with_all_ones.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// problem : https://leetcode.com/problems/count-square-submatrices-with-all-ones

class Solution {
public:
    int countSquares(vector<vector<int>>& m) {
        if(m.empty()) return 0;
        int sum=0;
        int dp[m.size()][m[0].size()];
        for(int i=0;i<m.size();i++) dp[i][0] = m[i][0];
        for(int i=0;i<m[0].size();i++) dp[0][i] = m[0][i];
        for(int i=1;i<m.size();i++){
            for(int j=1;j<m[0].size();j++){
                if(m[i][j] == 1) dp[i][j] = 1+min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));
                else dp[i][j] = 0;
            }
        }
        for(int i=0;i<m.size();i++){
            for(int j=0;j<m[0].size();j++){
                sum+=dp[i][j];
            }
        }
        return sum;
    }
};

================================================
FILE: count_subsets_of_given_difference.cpp
================================================
#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);
}

================================================
FILE: flip_game_1.cpp
================================================
#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;
    }
};

================================================
FILE: flip_game_2.cpp
================================================
#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;
    }
};

================================================
FILE: jump_game_2..cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// problem : https://leetcode.com/problems/jump-game-ii/
// dp+greedy(range-based)

class Solution {
public:
    int jump(vector<int>& nums) {
       int pos=0,des=0,jump=0;
        for(int i=0;i<nums.size()-1;i++){ //nums.size()-1 is done coz we dont need the last index
            des = max(des,i+nums[i]);
            if(pos == i){
                pos = des;
                jump++;
            }
        }
        return jump;
    }
};

================================================
FILE: longest_alternating_subsequence.cpp
================================================
#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);
    }
};

================================================
FILE: maximal_square.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// problem : https://leetcode.com/problems/maximal-square/

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.empty()) return 0;
        int res=0;
        vector<vector<int>>m(matrix.size(),vector<int>(matrix[0].size()));
        for(int i=0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
                if(matrix[i][j] == '0') m[i][j]=0;
                else {
                    m[i][j] = 1;
                    res = 1;
                }
            }
        }
        int dp[m.size()][m[0].size()];
        for(int i=0;i<matrix.size();i++) dp[i][0] = m[i][0];
        for(int i=0;i<matrix[0].size();i++) dp[0][i] = m[0][i];
        for(int i=1;i<m.size();i++){
            for(int j=1;j<m[0].size();j++){
                if(m[i][j] == 1) dp[i][j] = 1+min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));
                else dp[i][j] = 0;
                res = max(res,dp[i][j]);
            }
        }
        return res*res;
    }
};

================================================
FILE: maximum_product_subarray.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// problem : https://leetcode.com/problems/maximum-product-subarray/

class Solution {
public:
    int maxProduct(vector<int>& nums) {
//         almost similar to kadane
        int n=nums.size(),maxPro=1,minPro=1,best=INT_MIN;
        for(int i=0;i<n;i++){
            if(nums[i]<0){
                swap(maxPro,minPro);
            }
            maxPro = max(maxPro*nums[i],nums[i]);
            minPro = min(minPro*nums[i],nums[i]);
            best = max(best,maxPro);
        }
        return best;
    }
};

================================================
FILE: maximum_sum_submatrix.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// problem : https://www.interviewbit.com/problems/maximum-sum-square-submatrix/
// very beautiful question

int Solution::solve(vector<vector<int> > &A, int B) {
    int r = A.size(),c=A[0].size();
    vector<vector<int>>dp(r+1,vector<int>(c+1,0));
    for(int i=1;i<dp.size();i++){
        for(int j=1;j<dp[0].size();j++){
            dp[i][j] = A[i-1][j-1] + dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1];
        }
    }
    for(int i=1;i<dp.size();i++){
        for(int j=1;j<dp[0].size();j++){
            int sum = INT_MIN;
            if(i-B >=0 && j-B >= 0){
                sum = max(sum,dp[i][j]-dp[i-B][j]-dp[i][j-B]+dp[i-B][j-B]);
            }
        }
    }
    return sum;
}


================================================
FILE: minm_number_of_taps_to_open_water.cpp
================================================
#include <bits/stdc++.h>
using namespace std;

// problem : https://leetcode.com/problems/minimum-number-of-taps-to-open-to-water-a-garden/

class Solution {
public:
    int minTaps(int n, vector<int>& ranges) {
        int minm=0;
        int maxm=0;
        int open=0;
        while(maxm < n){
            for(int i=0;i<ranges.size();i++){
                int l = i-ranges[i];
                int r = i+ranges[i];
                if(l<=minm && r>maxm){
                    maxm = r;
                }
            }
            if(minm == maxm) return -1;
            minm = maxm;
            open++;
        }
        return open;
    }
};

================================================
FILE: nim_game.cpp
================================================
#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);
    }
};

================================================
FILE: nth_catlan_number.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// O(n^2) approach;
int nCatlan(int n) {
    vector<int>dp(n,0);
    dp[0] = dp[1] = 1;
    for(int i=2;i<=n;i++){
        for(int j=0;j<i;j++){
            dp[i] += dp[j]*dp[i-j-1];
        }
    }
    return dp[n];
}

// O(n) approach using binomial coefficient

// binomial coefficent
int binomial(int n,int r){
    int res=1;
    if(r > n-r) r = n-r;
    for(int i=0;i<r;i++){
        res *= (n-i);
        res /= (i+1);
    }
    return res;
}

// catlan using binomial coefficient
int catlan(int n){
    // C(n) = 1/n+1[(2*n)Cn]
    int b = binomial(2*n,n);
    return b/(n+1);
}


int main(){
    int n;
    cin >> n;
    cout<<nCatlan(n)<<"\n";
    cout<<catlan(n)<<"\n";
}

================================================
FILE: num_products.cpp
================================================
// https://codeforces.com/problemset/problem/1215/B

#include<bits/stdc++.h>
using namespace std;
vector<int>d[2005];
void divisors() {
    for(int i = 1 ; i <= 2005 ; i++) {
        if(i != 1)d[i].push_back(1);
        for(int j = 2 ; j * j <= i ; j++) {
            if(i % j == 0) {
                d[i].push_back(j);
                if(i/j != j) d[i].push_back(i/j);
            }
        }
    }
}

int main() {
    #define int long long
    int n;
    cin>>n;
    vector<int>a(n);
    for(int i = 0 ; i < n ;i++) {
        cin>>a[i];
    }
    int a1 = 0, a2 = 0, neg = 0, pos = 0;
    for(int i = 0; i < n ;i++) {
        if(a[i] < 0) {
            swap(pos, neg);
            neg++;
            a1 += pos;
            a2 += neg;
        } else {
            pos++;
            a1 += pos;
            a2 += neg;
        }
    }
    cout<<a2 <<" "<<a1<<"\n";
}


================================================
FILE: number_of_permutations_such_that_no_three_forms_increasing_sequence.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// O(n) approach using binomial coefficient

// binomial coefficent
int binomial(int n,int r){
    int res=1;
    if(r > n-r) r = n-r;
    for(int i=0;i<r;i++){
        res *= (n-i);
        res /= (i+1);
    }
    return res;
}

// catlan using binomial coefficient
int catlan(int n){
    // C(n) = 1/n+1[(2*n)Cn]
    int b = binomial(2*n,n);
    return b/(n+1);
}


int main(){
    int n;
    cin >> n;
    cout<<catlan(n);
}


================================================
FILE: number_of_valid_parenthesis.cpp
================================================
#include<bits/stdc++.h>
using namespace std;

// O(n) approach using binomial coefficient

// binomial coefficent
int binomial(int n,int r){
    int res=1;
    if(r > n-r) r = n-r;
    for(int i=0;i<r;i++){
        res *= (n-i);
        res /= (i+1);
    }
    return res;
}

// catlan using binomial coefficient
int catlan(int n){
    // C(n) = 1/n+1[(2*n)Cn]
    int b = binomial(2*n,n);
    return b/(n+1);
}


int main(){
    string s;
    cin >> s;
    int n = s.length();
    cout<<catlan(n/2);
}


================================================
FILE: spoj/ABA12C - Buying Apples!.cpp
================================================
#include <bits/stdc++.h>
using namespace std;

#define int long long int 

signed main(){
    int t;cin >> t;
    while( t--){
        int n , k; cin >> n >> k ;
        vector<int> prices(k); for ( int i = 0;  i < k ; i++ ) cin >> prices[i];
        vector<int> dp( 1001, INT_MAX);
        dp[0] = 0;
        for ( int i =0 ; i < k ; i ++ ){
            if  ( prices[i] == -1) continue;
            for ( int weight = i+1 ; weight <= k ; weight ++) {
                dp[ weight ] = min( dp[weight - i -  1] + prices[i] , dp[weight]);
            }
        }
        if ( dp[k] == INT_MAX){
            cout << -1 << "\n";
        }
        else cout << dp[k];
    }
}

================================================
FILE: spoj/ACODE - Alphacode.cpp
================================================
/*

HINT 

Testcases
25114
1111111111
3333333333
109
20201
1013
211003
100
21103
101230

Output
6
89
1
1
1
2
0
0
2


*/

#include <bits/stdc++.h>
using namespace std;
#define ll long long int
signed main()
{
    while (true)
    {
        string s;
        cin >> s;
        if (s == "0")break;
        int n = s.size();
        vector<int> dp(n + 1, 0);
        dp[n-1]=1;
        if ( n>=2){
            int x = (s[n-2] - '0') * 10 + s[n-1] - '0';
            if ( x >= 10 && x <= 26 ) dp[n-2] =1;
        }
        int np = 0;
        for (int i = n - 2; i >= 0; i--){
            if ( s[i+1] == '0' ) {
                if (s[i] == '0') np = 1;
                dp[i] += dp[i+2];
                continue;
            }
            dp[i] += dp[i + 1];
            int x = (s[i] - '0') * 10 + s[i + 1] - '0';
            if (x >= 10 && x <= 26 && s[i+2] != '0')
                dp[i] +=  dp[i + 2];
        }
        if ( np) cout << 0 << "\n";
        else cout << dp[0] << "\n";
    }
}

================================================
FILE: spoj/AIBOHP - Aibohphobia.cpp
================================================
#include <bits/stdc++.h>
using namespace std;
#define int long long int
int dp[6103][6103];
signed main(){
    int t; cin >> t;
    while( t--){
        string s;
        cin >> s; string t =s;
        reverse( t.begin() , t.end());
        memset( dp , 0 , sizeof(dp));
        int n = s.size();
        for ( int i = 1 ;i  <= n ; i++ ){
            for ( int j = 1 ; j <= n ; j++ ){
                if ( s[i-1] == t[j-1]) dp[i][j] =1 + dp[i-1][j-1] ;
                dp[i][j] = max( dp[i][j] ,max( dp[i-1][j] , dp[i][j-1]));
            }
        }
        cout << n - dp[n][n] << "\n";
    }
}

================================================
FILE: spoj/ANARC09A - Seinfeld.cpp
================================================
#include <bits/stdc++.h>
using namespace std;

#define int long long int

signed main(){
    
    for ( int t =1; ; t++){
        string s; cin >> s;
        if ( s[0] == '-') break;
        int open = 0 ;
        int ans =  0 ; 
        int n = s.size();
        for ( int i = 0 ; i < n ; i ++){
            if ( s[i] == '}'){
                if ( !open){
                    ans++;
                    open++;
                }
                else open--;
            }
            else open++;            
        }
        cout <<t << ". " <<   ans + open/2<< "\n";
    }
}

================================================
FILE: unique_paths_1.cpp
================================================
#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];
    }
};

================================================
FILE: unique_paths_2.cpp
================================================
#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];
    }
};

================================================
FILE: video_stiching.cpp
================================================
#include <bits/stdc++.h>
using namespace std;

// problem: https://leetcode.com/problems/video-stitching/

class Solution {
public:
    int videoStitching(vector<vector<int>>& clips, int T) {
        int minm=0;
        int maxm=0;
        int total = 0;
        while(maxm < T){
            for(int i=0;i<clips.size();i++){
                int l = clips[i][0];
                int r = clips[i][1];
                if(l<=minm && r>maxm){
                    maxm = r;
                }
            }
            if(minm == maxm) return -1;
            minm = maxm;
            total++;
        }
        return total;
    }
};

================================================
FILE: zerosAndOnes.cpp
================================================

// link https://leetcode.com/problems/ones-and-zeroes/
#include<bits/stdc++.h>
using namespace std;
class Solution {
    public:
    Solution(){}
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        int dp[len+1][m+1][n+1];
        memset(dp, 0, sizeof dp);
        
        for (int i=1;i<=len;i++){
                    int ones = count(strs[i-1].begin(), strs[i-1].end(), '1');
                    int zeros = strs[i-1].size()-ones;
            for (int j=0;j<=m;j++){
                for (int k=0;k<=n;k++){

                    int res = dp[i-1][j][k];
                    if (zeros<=j && ones<=k) 
                       res = max(res, dp[i-1][j-zeros][k-ones]+1);
                    dp[i][j][k] = res;
                }
            }
        }
        
        return dp[len][m][n];
        
    }
};
int main(){
    Solution s;
    int m,n;
    cout<<"Enter the max zeros ";
    cin>>m;
    cout<<"Enter the max ones ";
    cin>>n;
    int strings;
    cout<<"Eneter the no of words ";
    cin>>strings;
    vector<string>words;
    for(int i=0;i<strings;i++) {
        string str;
        cin>>str;
        words.push_back(str);
    }
    cout<<s.findMaxForm(words,m,n)<<"\n";
}