[
  {
    "path": ".gitignore",
    "content": "a.out"
  },
  {
    "path": "3_segment.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// question link\n// https://codeforces.com/problemset/problem/987/C\n\n\nint main() {\n    #define int long long\n    int n;\n    cin>>n;\n    vector<int>s(n + 1), rent(n + 1);\n    for(int i = 1 ; i <= n ;i++) {\n        cin>>s[i];\n    }\n    for(int i = 1 ; i <= n ;i ++) {\n        cin>>rent[i];\n    }\n\n    vector<vector<int>>dp(n+1, vector<int>(4, INT_MAX));\n    for(int i = 1 ; i <= n; i++) {\n        dp[i][1] = rent[i];\n    }\n\n    for(int k = 2 ; k <= 3 ;k++) {\n        for(int i = 1 ; i <= n; i ++) {\n            for(int j =  1 ; j < i ; j++) {\n                if(s[j] < s[i]) {\n                    dp[i][k] = min(dp[i][k], dp[j][k-1] + rent[i]);\n                }\n            }\n        }\n    }\n\n    int ans = INT_MAX;\n    for(int i = 1 ; i <= n ;i++) {\n        if(dp[i][3] != INT_MAX) {\n            ans = min(ans, dp[i][3]);\n        }\n    }\n    if(ans!=INT_MAX)\n    cout<<ans<<\"\\n\";\n    else cout<<-1<<\"\\n\";\n}\n"
  },
  {
    "path": "Best_Time_To_Buy_And_Sell_Stock_.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n//A very beautiful problem with a tweak of Kadane's algorithm.\n\nint best_time(vector<int>&arr,int n){\n    vector<int>diff(n,0);\n    for(int i=1;i<n;i++){\n        diff[i] = arr[i] - arr[i-1];\n    }\n    int max_far=diff[0],max_curr=diff[0];\n    for(int i=1;i<n;i++){\n        max_curr = max(max_curr+diff[i],diff[i]);\n        max_far = max(max_curr,max_far);\n    }\n    return max_far;\n}\n\nint main(){\n    int n;\n    cin>>n;\n    vector<int>arr(n);\n    for(int i=0;i<n;i++){\n        cin>>arr[i];\n    }\n    cout<<best_time(arr,n)<<\"\\n\";\n}"
  },
  {
    "path": "BitonicSequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint main() {\n    int t;\n    cin>>t;\n    while(t--) {\n        int n;\n        cin>>n;\n        vector<int>v(n+1,0);\n        for(int i=0;i<n;i++) {\n            cin>>v[i];\n        }\n        vector<int>Lis(n+1,1); \n        vector<int>Lds(n+1,1);\n        // cal longest increasing sequence\n        for(int i=0;i<n;i++) {\n            for(int j = i-1;j>=0;j--) {\n                if(v[j]<v[i]) {\n                    Lis[i] = max(Lis[i],1+Lis[j]);\n                }\n            }\n        }\n        // cal longest decreasing sequence\n        for(int i=n-1;i>=0;i--) {\n            for(int j = i+1;j<n;j++) {\n                if(v[j]<v[i]) {\n                    Lds[i] = max(Lds[i],1+Lds[j]);\n                }\n            }\n        }\n        int max_len = 1;\n        for(int i=0;i<n;i++) {\n            max_len = max(Lis[i]+Lds[i]-1,max_len);\n        }\n        cout<<max_len<<\"\\n\";\n    }\n}"
  },
  {
    "path": "Box_Stacking_Problem.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nstruct Box{\n    int h;\n    int d;\n    int w;\n};\n\nbool comparator(Box b1, Box b2){\n    return (b1.d*b1.w)>(b2.d*b2.w);\n}\nint maxStackHeight(int h[],int d[],int w[],int n){\n    struct Box ini[n];\n    for(int i=0;i<n;i++){\n        ini[i].h=h[i];\n        ini[i].d=d[i];\n        ini[i].w=w[i];\n    }\n    struct Box b[n];\n    int ind=0;\n    for(int i=0;i<n;i++){\n        //Original\n        b[i].h = ini[i].h;\n        b[i].d = max(ini[i].d,ini[i].w);\n        b[i].w = min(ini[i].d,ini[i].w);\n        ind++;\n        //First Rotation\n        b[i].h = ini[i].d;\n        b[i].d = max(ini[i].h,ini[i].w);\n        b[i].w = min(ini[i].h,ini[i].w);\n        ind++;\n        //Second Rotation\n        b[i].h = ini[i].w;\n        b[i].d = max(ini[i].h,ini[i].d);\n        b[i].w = min(ini[i].h,ini[i].d);\n        ind++;\n    }\n    int n=3*n;\n    sort(b,b+n,comparator);\n\n    int msh[n];//maximum stack height array\n    for(int i=0;i<n;i++){\n        msh[i]=b[i].h;\n    }\n    for (int i = 1; i < n; i++ ) \n      for (int j = 0; j < i; j++ ) \n         if ( b[i].w < b[j].w && \n              b[i].d < b[j].d && \n              msh[i] < msh[j] + b[i].h \n            ) \n         { \n              msh[i] = msh[j] + b[i].h; \n         }\n    int max = -1; \n   for ( int i = 0; i < n; i++ ) \n      if ( max < msh[i] ) \n         max = msh[i]; \n  \n   return max;       \n}"
  },
  {
    "path": "Circular_Kadene.cpp",
    "content": "// A very beautiful explalation given in leetcode\n// https://leetcode.com/problems/maximum-sum-circular-subarray/discuss/178422/One-Pass\n#include<bits/stdc++.h>\nusing namespace std;\n\nint  maxMoney(int arr[], int num)\n{\n    int max_far=arr[0],max_curr=arr[0],min_far=arr[0],min_curr=arr[0],total=arr[0];\n    for(int i=1;i<num;i++){\n        max_curr=max(max_curr+arr[i],arr[i]);\n        max_far=max(max_curr,max_far);\n        min_curr=min(min_curr+arr[i],arr[i]);\n        min_far=min(min_far,min_curr);\n        total+=arr[i];\n    }\n    if(max_far>0){\n        return max(max_far,total-min_far);\n    }\n    else{\n        return max_far;\n    }\n}"
  },
  {
    "path": "Coin_Changing_1.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Max_ways(int coins[],int size,int sum){\n    int dp[size+1][sum+1];\n    for(int i=0;i<=sum;i++){\n        dp[0][i]=0;\n    }\n    for(int i=0;i<=size;i++){\n        dp[i][0]=1;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum;j++){\n            if(coins[i-1]<=j){\n                dp[i][j] = dp[i-1][j] + dp[i][j-coins[i-1]];\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=sum;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n\n    return dp[size][sum];\n}\n\nint main() {\n    int coins[] = {1, 2, 3}; \n    int size = sizeof(coins)/sizeof(coins[0]);\n    int sum = 4;\n    cout<<Max_ways(coins,size,sum)<<\"\\n\"; \n}"
  },
  {
    "path": "Coin_Changing_2.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Minm_Coins(int coins[],int size,int sum) {\n    int dp[size+1][sum+1];\n    for(int i=0;i<=sum;i++){\n        dp[0][i] = INT_MAX - 1;\n    }\n    for(int i=1;i<=size;i++){\n        dp[i][0] = 0;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum;j++){\n            if(coins[i-1]<=j){\n                dp[i][j] = min(dp[i-1][j],1+dp[i][j-coins[i-1]]);\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    return dp[size][sum];\n}\nint main(){\n    int coins[] = {1,6,5,2,8};\n    int sum = 11;\n    int size = sizeof(coins)/sizeof(coins[0]);\n    cout<<Minm_Coins(coins,size,sum)<<\"\\n\";\n}"
  },
  {
    "path": "Count_All_Increasing_Subsequences.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n//O(n^2) solution\nint Count_AIS(int a[],int size){\n    int dp[size],ans=0;\n    for(int i=0;i<size;i++){\n        dp[i]=1;\n    }\n    for(int i=1;i<size;i++){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j]){\n                dp[i]+=dp[j];\n            }\n        }\n    }\n    for(int i=0;i<size;i++){\n        cout<<dp[i]<<\" \";\n    }\n    cout<<\"\\n\";\n    for(int i=0;i<size;i++){\n        ans+=dp[i];\n    }\n    return ans;\n}\n\n//O(n) solution : A beautiful solution\nint AIS(int a[],int size){\n    int count[10]={0},ans=0;\n    for(int i=0;i<size;i++){\n        for(int j=a[i]-1;j>=0;j--){//max 10 times\n            count[a[i]]+=count[j];\n        }\n        count[a[i]]++;\n    }\n    for(int i=0;i<10;i++){\n        ans+=count[i];\n    }\n    return ans;\n}\n\nint main(){\n    int a[]={3,2,4,5,4};\n    int size=sizeof(a)/sizeof(a[0]);\n    cout<<Count_AIS(a,size)<<\"\\n\";\n    cout<<AIS(a,size)<<\"\\n\";\n}"
  },
  {
    "path": "Count_All_Pallindromic_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint CountLPS(string s){\n    int n = s.length();\n    int dp[n][n];\n    memset(dp,0,sizeof(dp));\n    for(int i=0;i<n;i++){\n        dp[i][i] = 1;\n    }\n    for(int i=n-2;i>=0;i--){\n        for(int j=i+1;j<n;j++){\n            if(s[i] == s[j]){\n                dp[i][j] = 1 + dp[i][j-1] + dp[i+1][j];\n            }\n            else{\n                dp[i][j] = dp[i][j-1] + dp[i+1][j] - dp[i+1][j-1];\n            }\n        }\n    }\n    return dp[0][n-1];\n}\n\nint main(){\n    string s = \"abab\";\n    cout<<CountLPS(s)<<\"\\n\";\n}"
  },
  {
    "path": "Count_Distinct_Subsequences.cpp",
    "content": "#include<bits/stdc++.h>\n#define MAX_CHAR 256\nusing namespace std;\nint CDS(string s,int size){\n    vector<int>last_char(MAX_CHAR,-1);\n    int dp[size+1];\n    dp[0]=1;\n    for(int i=1;i<=size;i++){\n        dp[i] = 2*dp[i-1];\n        if(last_char[s[i-1]]!=-1){\n            dp[i]=dp[i]-dp[last_char[s[i-1]]];\n        }\n        last_char[s[i-1]]=(i-1);\n    }\n    return dp[size];\n}\nint main(){\n    string s=\"gfg\";\n    int size=s.length();\n    cout<<CDS(s,size)<<\"\\n\";\n}"
  },
  {
    "path": "Count_Number_of_hops.cpp",
    "content": "#include<iostream>\nusing namespace std;\nvoid solve(int n){\n    int dp[n];\n    dp[1]=1,dp[2]=2,dp[3]=4;\n    for(int i=4;i<=n;i++){\n        dp[i]=dp[i-1]+dp[i-2]+dp[i-3];\n    }\n    cout<<dp[n]<<\"\\n\";\n}\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n;\n\t    cin>>n;\n\t    solve(n);\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Count_Pallindromic_SubString_Of_String_gfg.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint expandAroundCenter(string s,int left,int right){\n    if(s.length()==0 || left>right) return 0;\n    int ans=0;\n    while(left>=0 && right<s.length() && s[left]==s[right]){\n        ans++;\n        left--;\n        right++;\n    }\n    return ans;\n}\nint CountLPSubstring(string s){\n    if(s.length()==0) return 0;\n    int res=0;\n    for(int i=0;i<s.length();i++){\n        res+=expandAroundCenter(s,i,i);\n        res+=expandAroundCenter(s,i,i+1);\n    }\n    return res;\n}\nint main(){\n    int t;\n    cin>>t;\n    while(t--){\n        int n;\n        cin>>n;\n        string s;\n        cin>>s;\n        cout<<CountLPSubstring(s)-n<<\"\\n\";\n    }\n}"
  },
  {
    "path": "Count_Subsets_of_given_Sum.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint CountSubsets(int a[],int size,int sum) {\n    int dp[size+1][sum+1];\n    for(int i=0;i<=sum;i++){\n        dp[0][i] = 0;\n    }\n    for(int i=0;i<=size;i++){\n        dp[i][0]=1;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum;j++){\n            if(a[i-1]<=j){\n                dp[i][j] = dp[i-1][j] + dp[i-1][j-a[i-1]];\n            }\n            else {\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=sum;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[size][sum];\n}\n\nint main() {\n    int a[] = { 1, 2, 3, 3 }; \n    int size = 4;\n    int sum = 6;\n    cout<<CountSubsets(a,size,sum)<<\"\\n\";\n}"
  },
  {
    "path": "Count_ways_to_N'th_Stair.cpp",
    "content": "long long countWays(int m){\n    long long dp[m+1]={0};\n    dp[0]=1;\n    for(int i=1;i<=m;i++) dp[i]+=dp[i-1];\n    for(int i=2;i<=m;i++) dp[i]+=dp[i-2];\n    return dp[m];\n}\n"
  },
  {
    "path": "Diameter_Of_Binary_Tree.cpp",
    "content": "//Function Written only\nint helper(Node* node,int &res){\n    if(node==NULL) return 0;\n    int left=helper(node->left,res);\n    int right=helper(node->right,res);\n    int tempAns=1+max(left,right);\n    int ans=max(tempAns,1+left+right);\n    res=max(res,ans);\n    return tempAns;\n}\nint diameter(Node* node) {\n    int res=INT_MIN;\n    helper(node,res);\n    return res;\n}\n"
  },
  {
    "path": "Distinct_Occurences.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Count_All_Distinct_Occurences(string s1,string s2){\n    int n=s1.length(),m=s2.length();\n    if(m>n) return 0;\n    int dp[n+1][m+1];\n    for(int i=0;i<=m;i++) dp[0][i]=0;\n    for(int i=0;i<=n;i++) dp[i][0]=1;\n    for(int i=1;i<=n;i++){\n        for(int j=1;j<=m;j++){\n            if(s1[i-1]==s2[j-1]){\n                dp[i][j] = dp[i-1][j-1] + dp[i-1][j];\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=n;i++){\n        for(int j=0;j<=m;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[n][m];\n}\nint main(){\n    int t;\n    cin>>t;\n    while(t--){\n        string s1,s2;\n        cin>>s1>>s2;\n        cout<<Count_All_Distinct_Occurences(s1,s2)<<\"\\n\";\n    }\n}\n//s1=banana\n//s2=ban\n//therefore count=3 ie 3 distinct susequence of s2 occurs in s1;"
  },
  {
    "path": "Edit_Distance.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Edit_Distance(string s1,string s2){\n    int m = s1.length();\n    int n = s2.length();\n    int dp[m+1][n+1];\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0) dp[i][j] = j;\n            else if(j==0) dp[i][j] = i;\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = 1 + min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));\n            }\n        }\n    }\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[m][n];\n}\nint main(){\n    string str1 = \"sunday\"; \n    string str2 = \"saturday\"; \n    cout<<Edit_Distance(str1,str2)<<\"\\n\";\n}"
  },
  {
    "path": "Equal_Sum_Partition.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nbool EqualSubsetSum(int a[],int size) {\n    int sum=0;\n    for(int i=0;i<size;i++){\n        sum+=a[i];\n    }\n    if(sum%2!=0) return false;\n    bool dp[size+1][sum/2+1];\n    for(int i=0;i<=sum/2;i++){\n        dp[0][i] = false;\n    }\n    for(int i=0;i<=size;i++){\n        dp[i][0]=true;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum/2;j++){\n            if(a[i-1]<=j){\n                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    return dp[size][sum/2];\n}\n\nint main() {\n\n    int a[] = {3, 1, 1, 2, 2, 1};  \n    int size = sizeof(a) / sizeof(a[0]);\n    cout<<EqualSubsetSum(a,size)<<\"\\n\";\n\n}"
  },
  {
    "path": "Friends_Pairing_Problem.cpp",
    "content": "#include<iostream>\n#define m 1000000007\nusing namespace std;\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n;\n\t    cin>>n;\n\t    long long int dp[n+1];\n\t    for(int i=0;i<=n;i++){\n\t        if(i<=2) dp[i]=i;\n\t        else{\n\t            dp[i]=((dp[i-1]%m)+((i-1)%m*(dp[i-2]%m))%m)%m;\n\t        }\n\t    }\n\t    cout<<dp[n]<<\"\\n\";\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Get_Minimum_Squares.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint getMinimumSquares(int n){\n    int dp[n+1];\n    dp[0]=0;\n    dp[1]=1;\n    dp[2]=2;\n    dp[3]=3;\n    for(int i=4;i<=n;i++){\n        dp[i]=i;//marking with the maximum\n        for(int p=1;p<=ceil(sqrt(i));p++){//maximum it can go is ceil(sqrt(n)\n            int temp=p*p;\n            if(temp>i) break;\n            dp[i]=min(dp[i],1+dp[i-temp]);\n        }\n    }\n    return dp[n];\n}\nint main(){\n    int t;\n    cin>>t;\n    while(t--){\n        int n;\n        cin>>n;\n        cout<<getMinimumSquares(n)<<\"\\n\";\n    }\n}"
  },
  {
    "path": "GoldMine_Problem.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint main(){\n    int t;\n    cin>>t;\n    while(t--){\n        int m,n;\n        cin>>n>>m;\n        int gold[n][m];\n        for(int i=0;i<n;i++){\n            for(int j=0;j<m;j++){\n                cin>>gold[i][j];\n            }\n        }\n        int dp[n][m];\n        int right,right_up,right_down;\n        memset(dp,0,sizeof(dp));\n        for(int i=m-1;i>=0;i--){\n            for(int j=0;j<n;j++){\n                right = (i==m-1)?0:dp[j][i+1];\n                right_up=(i==m-1 || j==0)?0:dp[j-1][i+1];\n                right_down=(i==m-1 || j==n-1)?0:dp[j+1][i+1];\n                dp[j][i]=gold[j][i]+max(right,max(right_up,right_down));\n            }\n        }\n        int ans=dp[0][0];\n        for(int i=1;i<n;i++){\n            ans=max(ans,dp[i][0]);\n        }\n        cout<<ans<<\"\\n\";\n    }\n}"
  },
  {
    "path": "Jump_Game_3.cpp",
    "content": "class Solution {\npublic:\n    bool canReach(vector<int>& arr, int start) {\n        int N = arr.size();\n        vector<int> tab(N, 0);\n        return help(arr, start, tab, N);\n    }\n    bool help(vector<int>& arr, int start, vector<int>& tab, int N) {\n        if ((start < 0 || start > N - 1) || tab[start] == 1) {\n            return false;\n        }\n        if (arr[start] == 0) {\n            return true;\n        }\n        tab[start] = 1;\n        if (help(arr, start-arr[start], tab, N)) {\n            return true;\n        }\n        if (help(arr, start+arr[start], tab, N)) {\n            return true;\n        }\n        return false;\n    }\n};\n"
  },
  {
    "path": "Jump_Game_5.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n//LEETCODE QUESTION\n\nint dp[1001];\nint helper(vector<int>& arr,int d,int i){\n        if(dp[i]!=-1) return dp[i];\n        int ans=1,n=arr.size();\n        //right\n        for(int j=i+1;j<=min(n-1,i+d)&&arr[i]>arr[j];j++)ans=max(ans,1+helper(arr,d,j));\n        //left\n        for(int j=i-1;j>=max(0,i-d)&&arr[i]>arr[j];j--)ans=max(ans,1+helper(arr,d,j));\n        return dp[i]=ans;\n}\nint maxJumps(vector<int>& arr, int d) {\n        int ans=1;\n        for(int i=0;i<arr.size();i++)dp[i]=-1;\n        for(int i=0;i<arr.size();i++)ans=max(ans,helper(arr,d,i));\n        return ans;\n}"
  },
  {
    "path": "Kadane.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Kadane(int a[],int size){\n    int max_cur=a[0],max_far=a[0];\n    for(int i=1;i<size;i++){\n        max_cur=max(max_cur+a[i],a[i]);\n        max_far=max(max_cur,max_far);\n    }\n    return max_far;\n}\n\nint main(){\n    int a[]={8 ,-8 ,9 ,-9 ,10 ,-11 ,12};\n    int size=sizeof(a)/sizeof(a[0]);\n    cout<<Kadane(a,size)<<\"\\n\";\n}"
  },
  {
    "path": "Knapsack_0_1.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint knapsack(int wt[],int val[],int W,int size){\n    int dp[size+1][W+1];\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=W;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(wt[i-1]<=j){\n                dp[i][j] = max(dp[i-1][j],val[i-1] + dp[i-1][j-wt[i-1]]);\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    return dp[size][W];\n}\n\nint main() {\n    \n    int val[] = {60, 100, 120}; \n    int wt[] = {10, 20, 30}; \n    int  W = 50; \n    int size = sizeof(val)/sizeof(val[0]); \n    cout<<knapsack(wt,val,W,size)<<\"\\n\";\n\n}"
  },
  {
    "path": "Last_Stone_3.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n//Leetcode Question\n\n//Recurssion base soln\nint helper(vector<int>& s,int i){\n        if(i>=s.size()) return 0;\n        else{\n            int ans=INT_MIN;\n            ans=max(ans,s[i]-helper(s,i+1));\n            if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));\n            if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-helper(s,i+3));\n            return ans;\n        }\n    }\nstring stoneGameIII(vector<int>& s) {\n    int ans=helper(s,0);\n    if(ans<0) return \"Bob\";\n    else if(ans==0) return \"Tie\";\n    return \"Alice\";\n}\n//Memonization based soln\nint dp[500001];\nint helper(vector<int>&s,int i){\n    if(i>=s.size()) return 0;\n    if(dp[i]!=-1) return dp[i];\n    else{\n        int ans=INT_MIN;\n        ans=max(ans,s[i]-helper(s,i+1));\n        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));\n        if(i+2<s.size()) ans=max(ans,dp[i]+dp[i+1]+dp[i+2]-helper(s,i+3));\n        return dp[i]=ans;\n    }\n}\nstring stoneGameIII(vector<int>& s) {\n    for(int i=0;i<s.size();i++)dp[i]=-1;\n    int ans=helper(s,0);\n    if(ans<0) return \"Bob\";\n    else if(ans==0) return \"Tie\";\n    return \"Alice\";\n}\n//Bottom Up approach\nstring stoneGameIII(vector<int>& s) {\n    int n=s.size();\n    vector<int>dp(n+1,0);\n    int i=n-1;\n    while(i>=0){\n        int ans=INT_MIN;\n        ans=max(ans,s[i]-dp[i+1]);\n        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-dp[i+2]);\n        if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-dp[i+3]);\n        dp[i]=ans;\n    }\n    int ans=dp[0];\n    if(ans<0) return \"Bob\";\n    else if(ans==0) return \"Tie\";\n    return \"Alice\";\n}\n\nint main(){\n    //take input\n}"
  },
  {
    "path": "Longest_Common_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint Lcs(string s1,string s2){\n    int m = s1.length(),n = s2.length();\n    int dp[m+1][n+1];\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0) dp[i][j]=0;\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = 1 + dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[m][n];\n}\n\nint main(){\n    string s1 = \"abcdgl\";\n    string s2 = \"abedfhl\";\n    cout<<Lcs(s1,s2)<<\"\\n\";\n}"
  },
  {
    "path": "Longest_Common_Substring.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint LCSub(string s1,string s2){\n    int m = s1.length(),n = s2.length();\n    int dp[m+1][n+1],res=0;\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = 1 + dp[i-1][j-1];\n                res = max(res,dp[i][j]);\n            }\n            else{\n                dp[i][j] = 0;\n            }\n        }\n    }\n    return res;\n}\nint main(){\n    string s1 = \"abcdgl\";\n    string s2 = \"abedgl\";\n    cout<<LCSub(s1,s2)<<\"\\n\";\n}\n\n"
  },
  {
    "path": "Longest_Consequetive_Subsequence.cpp",
    "content": "#include<iostream>\nusing namespace std;\nint main()\n {\n     int t;\n     cin>>t;\n     while(t--){\n         int n;\n         cin>>n;\n         int m[100001]={0};\n         int a[n];\n         for(int i=0;i<n;i++) cin>>a[i];\n         for(int i=0;i<n;i++){\n             m[a[i]]++;\n\t    }\n\t    int count=0,res=-1;\n\t    for(int i=0;i<100001;i++){\n\t        if(m[i]>=1)count++;\n\t        else count=0;\n\t       res=max(res,count);\n\t    }\n\t    cout<<res<<\"\\n\";\n    }\n\treturn 0;\n}"
  },
  {
    "path": "Longest_Decreasing_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint LDS(int a[],int size){\n    int dp[size+1],res=1;\n    for(int i=0;i<size;i++){\n        dp[i] = 1;\n    }\n    for(int i=size-1;i>=0;i--){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j]){\n                dp[i] = max(dp[i],1+dp[j]);\n            }\n        }\n        res = max(res,dp[i]);\n    }\n    return res;\n}\nint main(){\n    int a[] = {10,9,2,5,3,7,101,18};\n    int size = sizeof(a)/sizeof(a[0]);\n    cout<<LDS(a,size)<<\"\\n\";\n}"
  },
  {
    "path": "Longest_Increasing_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint LIS(int a[],int size){\n    int dp[size+1],res=1;\n    for(int i=0;i<size;i++){\n        dp[i] = 1;\n    }\n    for(int i=0;i<size;i++){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j]){\n                dp[i] = max(dp[i],1+dp[j]);\n            }\n        }\n        res = max(res,dp[i]);\n    }\n    return res;\n}\nint main(){\n    int a[] = {10,9,2,5,3,7,101,18};\n    int size = sizeof(a)/sizeof(a[0]);\n    reverse(a,a+size);\n    cout<<LIS(a,size)<<\"\\n\";\n}"
  },
  {
    "path": "Longest_Pallindromic_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n//used bottom-up aproach(but similar to lcs)\nint longestPalindromeSubseq(string s) {\n        int n=s.length();\n        int dp[n+1][n+1];\n        for(int i=0;i<n;i++){\n            for(int j=0;j<n;j++){\n                if(i==j)dp[i][j]=1;\n                else if(j<i)dp[i][j]=0;\n            }\n        }\n        for(int i=n-2;i>=0;i--){\n            for(int j=i+1;j<n;j++){\n                    if(s[i]==s[j]){\n                        dp[i][j]=2+dp[i+1][j-1];\n                    }\n                    else{\n                        dp[i][j]=max(dp[i][j-1],dp[i+1][j]);\n                    }\n            }\n        }\n    return dp[0][n-1];\n}\n\nint main(){\n    string s = \"bbbab\";\n    cout<<longestPalindromeSubseq(s)<<\"\\n\";\n}"
  },
  {
    "path": "Longest_Pallindromic_Substring.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint expandAroundCenter(string s,int left,int right){\n    if(s.length()==0 || left>right) return 0;\n    while(left>=0 && right<s.length() && s[left]==s[right]){\n        left--;\n        right++;\n    }\n    return right-left-1;\n}\nstring LPSubstring(string s){\n    if(s.length()==0) return \"\";\n    int start=0,end=0;\n    for(int i=0;i<s.length();i++){\n        int len1=expandAroundCenter(s,i,i);\n        int len2=expandAroundCenter(s,i,i+1);\n        int len=max(len1,len2);\n        if(len>end-start){\n            start=i-(len-1)/2;\n            end=i+len/2;\n        }\n    }\n    return s.substr(start,end-start+1);\n}\nint main(){\n    string s = \"helppreanadkada\";\n    cout<<LPSubstring(s)<<\"\\n\";\n}"
  },
  {
    "path": "Longest_Repeating_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint LRS(string s){\n    int n = s.length();\n    int dp[n+1][n+1];\n    for(int i=0;i<=n;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(s[i-1] == s[j-1] && i!=j){\n                dp[i][j] = 1 + dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    return dp[n][n];\n}\n\nint main() {\n    string s = \"aabebcdd\";\n    cout<<LRS(s)<<\"\\n\";\n}"
  },
  {
    "path": "Matrix_Chain_Multiplication.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint dp[5][5];\nint MCM(int a[],int i,int j){\n    if(i>=j) return 0;\n    if(dp[i][j] != -1) return dp[i][j];\n    int ans = INT_MAX,temp_ans;\n    for(int k=i;k<j;k++){\n        temp_ans = MCM(a,i,k) + MCM(a,k+1,j) + a[i-1]*a[k]*a[j];\n        ans = min(ans,temp_ans);\n    }\n    return ans;\n}\n\nint main(){\n    int a[] = {1, 2, 3, 4, 3}; \n    int size = sizeof(a)/sizeof(a[0]);\n    memset(dp,-1,sizeof(dp));\n    cout<<MCM(a,1,size-1);\n}"
  },
  {
    "path": "Max_Path_Sum_in_Triangle.cpp",
    "content": "#include<bits/stdc++.h>\n#define N 4\nusing namespace std;\n\nint Max_Sum_Tri(int t[][N],int m,int n){\n    for(int i=m-2;i>=0;i--){\n        for(int j=0;j<=i;j++){\n            t[i][j] = max(t[i+1][j],t[i+1][j+1])+t[i][j]; \n        }\n    }\n    return t[0][0];\n}\n\nint main(){\n    int t[N][N] = { {3,0,0,0},\n                    {7,4,0,0},\n                    {2,4,6,0},\n                    {8,5,9,3} };\n    cout<<Max_Sum_Tri(t,4,4)<<\"\\n\";                   \n}\n\n"
  },
  {
    "path": "Max_path_sum.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nvector<int>v(100,0);\nvector<int>dp(100,0);\nvector<int>adj[100];\nint largest_sum(int child,int parent) {\n    dp[child] = v[child];\n    int max_val = 0;\n    for(auto ch : adj[child]) {\n        if(ch==parent)continue;\n\n        largest_sum(ch,child);\n        max_val = max(max_val, dp[ch]);\n    }\n    return dp[child] += max_val;\n}\nint main() {\n    int n;\n    cin>>n;\n    cout<<\"Enter the nodes value\\n\";\n    for(int i=1;i<=n;i++) {\n        cin>>v[i];\n    }        \n    for(int i=0;i<n-1;i++) {\n        int a,b;\n        cin>>a>>b;\n        adj[a].push_back(b);\n        adj[b].push_back(a);\n    }\n    cout<<largest_sum(1,-1)<<\"\\n\";\n}"
  },
  {
    "path": "Maximize_the_cutting.cpp",
    "content": "#include<iostream>\nusing namespace std;\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n,x,y,z;\n\t    cin>>n;\n        cin>>x>>y>>z;\n\t    int dp[n+1];\n        for(int i=0;i<=n;i++) dp[i]=-1;\n\t    dp[0]=0;\n\t    for(int i=0;i<=n;i++){\n            if(dp[i]==-1) continue;\n\t        if(i+x<=n){\n\t            dp[i+x]=max(dp[i+x],dp[i]+1);\n\t        }\n\t        if(i+y<=n){\n\t            dp[i+y]=max(dp[i+y],dp[i]+1);\n\t        }\n\t        if(i+z<=n){\n\t            dp[i+z]=max(dp[i+z],dp[i]+1);\n\t        }\n\t    }\n        for(int i=0;i<=n;i++){\n            cout<<dp[i]<<\" \";\n        }\n        cout<<\"\\n\";\n\t    cout<<dp[n]<<\"\\n\";\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Maximum_Dot_Product_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n\nint maxDotProduct(vector<int>& A, vector<int>& B,int size1,int size2) {\n        vector<vector<int>>dp(size1,vector<int>(size2));\n        for(int i=0;i<size1;i++){\n            for(int j=0;j<size2;j++){\n                dp[i][j]=A[i]*B[j];\n                if(i>=1 && j>=1) dp[i][j] = dp[i][j]+max(dp[i-1][j-1],0);\n                if(i>=1) dp[i][j] = max(dp[i][j],dp[i-1][j]);\n                if(j>=1) dp[i][j] = max(dp[i][j],dp[i][j-1]);\n            }\n        }\n    return dp[size1-1][size2-1];\n}\n\n\nint main(){\n    int size1,size2;\n    cin>>size1>>size2;\n    vector<int>A(size1);\n    vector<int>B(size2);\n    for(int i=0;i<size1;i++){\n        cin>>A[i];\n    }\n    for(int i=0;i<size2;i++){\n        cin>>B[i];\n    }\n    cout<<maxDotProduct(A,B,size1,size2)<<\"\\n\";\n}\n\n// another approach\nclass Solution {\npublic:\n    int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {\n        int n = int(nums1.size()), m = int(nums2.size());\n        vector<vector<int>> dp(n + 1, vector<int>(m + 1, INT_MIN));\n        for (int i = 1; i <= n; ++i) {\n            for (int j = 1; j <= m; ++j) {\n                dp[i][j] = max(dp[i][j], dp[i - 1][j]);\n                dp[i][j] = max(dp[i][j], dp[i][j - 1]);\n                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);\n                dp[i][j] = max(dp[i][j], max(dp[i - 1][j - 1], 0) + nums1[i - 1] * nums2[j - 1]);\n            }\n        }\n        return dp[n][m];\n    }\n};"
  },
  {
    "path": "Maximum_Path_Sum_in_Binary_tree.cpp",
    "content": "//Only function Written\nclass Solution {\n    int maxToRoot(TreeNode *root, int &re) {\n        if (!root) return 0;\n        int l = maxToRoot(root->left, re);\n        int r = maxToRoot(root->right, re);\n        if (l < 0) l = 0;\n        if (r < 0) r = 0;\n        re=max(re,l+r+root->val);\n        return root->val += max(l, r);\n    }\npublic:\n    int maxPathSum(TreeNode *root) {\n        int re = -2147483648;\n        maxToRoot(root, re);\n        return re;\n    }\n};"
  },
  {
    "path": "Maximum_Product_Increasing_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint MPIS(int a[],int size){\n    int dp[size];\n    for(int i=0;i<size;i++){\n        dp[i] = a[i];\n    }\n    for(int i=1;i<size;i++){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j] && dp[i]<(a[i]*dp[j])){\n                dp[i] = a[i]*dp[j];\n            }\n        }\n    }\n    int max = dp[0];\n    for(int i=1;i<size;i++){\n        if(dp[i]>max){\n            max = dp[i];\n        }\n    }\n    return max;\n}\n\nint main(){\n    int a[] = { 3, 100, 4, 5, 150, 6 };  \n    int size = sizeof(a)/sizeof(a[0]);\n    cout<<MPIS(a,size)<<\"\\n\";  \n}"
  },
  {
    "path": "Maximum_Size_Submatrix_Square.cpp",
    "content": "#include<bits/stdc++.h>\n#define r 6\n#define c 5\nusing namespace std;\nint Max_Square(int M[r][c]){\n    int dp[r][c],ans=0;\n    for(int i=0;i<c;i++){\n        dp[0][i] = M[0][i];\n    }\n    for(int i=0;i<r;i++){\n        dp[i][0] = M[i][0];\n    }\n    for(int i=1;i<r;i++){\n        for(int j=1;j<c;j++){\n            if(M[i][j] == 1){\n                dp[i][j] = min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1])) + 1;\n            }\n            else dp[i][j] = dp[i-1][j-1];\n            ans = max(ans,dp[i][j]);\n        }\n    }\n    for(int i=0;i<r;i++){\n        for(int j=0;j<c;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return ans;\n}\n\nint main(){\n    int M[r][c] = {{0, 1, 1, 0, 1},  \n                    {1, 1, 0, 1, 0},  \n                    {0, 1, 1, 1, 0},  \n                    {1, 1, 1, 1, 0},  \n                    {1, 1, 1, 1, 1},  \n                    {0, 0, 0, 0, 0}};\n    cout<<Max_Square(M)<<\"\\n\";                \n}"
  },
  {
    "path": "Maximum_Sum_Decreasing_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint MSDS(int a[],int size){\n    int dp[size];\n    for(int i=0;i<size;i++){\n        dp[i] = a[i];\n    }\n    for(int i=1;i<size;i++){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j] && dp[i]<a[i]+dp[j]){\n                dp[i] = a[i]+dp[j];\n            }\n        }\n    }\n    int max = dp[0];\n    for(int i=1;i<size;i++){\n        if(dp[i]>max){\n            max = dp[i];\n        }\n    }\n    return max;\n}\n\nint main(){\n    int a[] = {1, 101, 2, 3, 100, 4, 5};  \n    int size = sizeof(a)/sizeof(a[0]);\n    reverse(a,a+size);\n    cout<<MSDS(a,size)<<\"\\n\";  \n}"
  },
  {
    "path": "Maximum_Sum_Dividing_Recurssive.cpp",
    "content": "#include<iostream>\nusing namespace std;\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n;\n\t    cin>>n;\n\t    int dp[n+1];\n\t    dp[0]=0,dp[1]=1;\n\t    for(int i=2;i<=n;i++){\n\t        dp[i]=max(dp[i/2]+dp[i/3]+dp[i/4],i);\n\t    }\n\t    cout<<dp[n]<<\"\\n\";\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Maximum_Sum_Increasing_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint MSIS(int a[],int size){\n    int dp[size];\n    for(int i=0;i<size;i++){\n        dp[i] = a[i];\n    }\n    for(int i=1;i<size;i++){\n        for(int j=0;j<i;j++){\n            if(a[i]>a[j] && dp[i]<a[i]+dp[j]){\n                dp[i] = a[i]+dp[j];\n            }\n        }\n    }\n    int max = dp[0];\n    for(int i=1;i<size;i++){\n        if(dp[i]>max){\n            max = dp[i];\n        }\n    }\n    return max;\n}\n\nint main(){\n    int a[] = {1, 101, 2, 3, 100, 4, 5};  \n    int size = sizeof(a)/sizeof(a[0]);\n    cout<<MSIS(a,size)<<\"\\n\";  \n}"
  },
  {
    "path": "Maximum_length_of_pairs.cpp",
    "content": "int findLongestChain(vector<vector<int>>& pairs) {\n        int n=pairs.size();\n        int dp[n+1],res=1;\n        sort(pairs.begin(),pairs.end());\n        for(int i=0;i<n;i++){\n            dp[i]=1;\n        }\n        for(int i=1;i<n;i++){\n            for(int j=0;j<i;j++){\n                if(pairs[i][0]>pairs[j][1]){\n                    dp[i]=max(dp[i],1+dp[j]);\n                }\n            }\n            res=max(res,dp[i]);\n        }\n        if(n==0)return 0;\n        else return res;\n    }"
  },
  {
    "path": "Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint minimumDeleteSum(string s1, string s2) {\n        int m=s1.length(),n=s2.length();\n        int dp[m+1][n+1];\n        for(int i=0;i<=m;i++){\n            for(int j=0;j<=n;j++){\n                dp[i][j]=0;\n            }\n        }\n        for(int i=1;i<=m;i++){\n            dp[i][0]=dp[i-1][0]+s1[i-1];\n        }\n        for(int j=1;j<=n;j++){\n            dp[0][j]=dp[0][j-1]+s2[j-1];\n        }\n        for(int i=1;i<=m;i++){\n            for(int j=1;j<=n;j++){\n                if(s1[i-1]==s2[j-1]){\n                    dp[i][j]=dp[i-1][j-1];\n                }\n                else{\n                    dp[i][j]=min(dp[i-1][j]+s1[i-1],dp[i][j-1]+s2[j-1]);\n                }\n            }\n        }\n        for(int i=0;i<=m;i++){\n            for(int j=0;j<=n;j++){\n                cout<<dp[i][j]<<\" \";\n            }\n            cout<<\"\\n\";\n        }\n        return dp[m][n];\n}\nint main(){\n    string s1=\"eat\";\n    string s2=\"sea\";\n    minimumDeleteSum(s1,s2);\n}"
  },
  {
    "path": "Minimum_Initial_Points_To_Reach_Destinaion.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nconst int maxm=100000;\nint a[3][3];\nint r=3,c=3;\n//One of the best problems come across.\nint MinmIniPoints(int a[][3]){\n    int dp[r+1];\n    for(int i=0;i<=r;i++){\n        dp[i]=INT_MAX;\n    }\n    dp[r-1]=1;\n    for(int j=c-1;j>=0;j--){\n        for(int i=r-1;i>=0;i--){\n            dp[i]=min(dp[i],dp[i+1])-a[i][j];\n            dp[i]=max(1,dp[i]);\n        }\n    }\n    return dp[0];\n}\nint main(){\n    int a[3][3] = { {-2,-3,3}, \n                      {-5,-10,1}, \n                      {10,30,-5} \n                    };\n    cout<<MinmIniPoints(a);                  \n}"
  },
  {
    "path": "Minimum_Jumps_To_Reach_End.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n//o(n^2)\nint Min_Jumps(int a[],int size){\n    int dp[size];\n    dp[0] = 0;\n    for(int i=1;i<size;i++){\n        dp[i] = INT_MAX;\n        for(int j=0;j<i;j++){\n            if(i<=j+a[j] && dp[j]!=INT_MAX){\n                dp[i] = min(dp[i],1+dp[j]);\n            }\n        }\n    }\n    return dp[size-1];\n}\n\n//O(n)\nint minJumps(int a[],int n){\n    if(n<=1) return 0;\n    if(a[0]==0) return -1;\n    int maxReach=a[0];\n    int step=a[0];\n    int jump=1;\n    int i=1;\n    for(int i=1;i<n;i++){\n        if(i == n-1) return jump;\n        maxReach=max(maxReach,i+a[i]);\n        step--;\n        if(step == 0){\n            jump++;\n            if(i>=maxReach) return -1;\n            step=maxReach-i;\n        }\n    }\n    return -1;\n}\n\nint main(){\n    int a[] = { 1, 3, 6, 1, 0, 9 }; \n    int size = sizeof(a) / sizeof(a[0]);\n    cout<<Min_Jumps(a,size)<<\"\\n\"; \n}\n"
  },
  {
    "path": "Minimum_Subset_Sum_Difference.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint Minm_SubsetSum_Diff(int a[],int size){\n    int sum = 0;\n    for(int i=0;i<size;i++){\n        sum += a[i];\n    }\n    int dp[size+1][sum+1];\n    for(int i=0;i<=sum;i++){\n        dp[0][i] = 0;\n    }\n    for(int i=0;i<=size;i++){\n        dp[i][0] = 1;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum;j++){\n            if(a[i-1]<=j){\n                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    int diff;\n    for(int i=sum/2;i>=0;i--){\n        if(dp[size][i]==1){\n            diff = sum-2*i;\n            break;\n        }\n    }\n    return diff;\n}\nint main(){\n    int a[] = {3, 1, 4, 2, 2, 1}; \n    int size = sizeof(a)/sizeof(a[0]);\n    cout<<Minm_SubsetSum_Diff(a,size)<<\"\\n\"; \n}"
  },
  {
    "path": "Minm_Cost_To_Fill_Bag.cpp",
    "content": "//A very very good variation of Unbounded Knapsack.#include<iostream>\n#include<bits/stdc++.h>\n#define INF 1000000\nusing namespace std;\n\nint minm_Cost(int cost[],int n,int W){\n    vector<int>val,wt;\n    int size=0;\n    for(int i=0;i<n;i++){\n        if(cost[i]!=-1){\n            val.push_back(cost[i]);\n            wt.push_back(i+1);\n            size++;\n        }\n    }\n    cout<<size<<\"\\n\";\n    n=size;\n    cout<<n<<\"\\n\";\n    int dp[n+1][W+1];\n    // fill 0th row with infinity \n    for (int i=0; i<=W; i++) \n        dp[0][i] = INF; \n  \n    // fill 0'th column with 0 \n    for (int i=1; i<=n; i++) \n        dp[i][0] = 0; \n        \n    for(int i=1;i<=n;i++){\n        for(int j=1;j<=W;j++){\n            if(wt[i-1]<=j){\n                dp[i][j] = min(dp[i-1][j],val[i-1] + dp[i][j-wt[i-1]]);\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=n;i++){\n        for(int j=0;j<=W;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return (dp[n][W]==INF)? -1: dp[n][W]; \n}\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n,W;\n\t    cin>>n>>W;\n\t    int cost[n];\n\t    for(int i=0;i<n;i++){\n\t        cin>>cost[i];\n\t    }\n\t    cout<<minm_Cost(cost,n,W)<<\"\\n\";\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Minm_Deletion_To_Make_Pallindrome.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint DelPallin(string s){\n    int n = s.length(),lps;\n    int dp[n+1][n+1];\n    for(int i=0;i<n;i++){\n        for(int j=0;j<n;j++){\n            if(i==j) dp[i][j] = 1;\n            else if(j<i) dp[i][j] = 0;\n        }\n    }\n    for(int i=n-2;i>=0;i--){\n        for(int j=i+1;j<n;j++){\n            if(s[i] == s[j]){\n                dp[i][j] = 2 + dp[i+1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i+1][j],dp[i][j-1]);\n            }\n        }\n    }\n    lps = dp[0][n-1];\n    return n-lps;\n}\nint main() {\n    string s = \"aebcbda\";\n    cout<<DelPallin(s)<<\"\\n\";\n}"
  },
  {
    "path": "Minm_Insertion_Deletion_Convert.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Idconvert(string s1,string s2){\n    int m = s1.length(),n=s2.length(),lcs;\n    int dp[m+1][n+1];\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = 1 + dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    lcs = dp[m][n];\n    cout<<\"Minimum Insertions : \"<<m-lcs<<\"\\n\";\n    cout<<\"Minimum Deletions : \"<<n-lcs<<\"\\n\";\n    return m+n-(2*lcs);\n}\n\nint main() {\n    string s1 = \"heap\";\n    string s2 = \"pea\";\n    cout<<Idconvert(s1,s2)<<\"\\n\";\n}"
  },
  {
    "path": "No_Of_Ways_To_Tile.cpp",
    "content": "#include<iostream>\nusing namespace std;\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int n;\n\t    cin>>n;\n\t    long long int dp[n+1];\n\t    dp[0]=0;\n\t    for(int i=1;i<=n;i++){\n\t        if(i<=3) dp[i]=1;\n\t        else if (i==4) dp[i]=2;\n\t        else dp[i] = dp[i-1]+dp[i-4];\n\t    }\n\t    cout<<dp[n]<<\"\\n\";\n\t}\n\treturn 0;\n}"
  },
  {
    "path": "Number_of_ways_to_decode_a_string.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// similar to fibonacci\nint countWays(string s){\n    int n = s.length();\n    int dp[n+1];\n    for(int i=0;i<n;i++) dp[i] = 0;\n    dp[0] = 1;\n    dp[1] = 1;\n    for(int i=2;i<=n;i++){\n        if(s[i-1] > '0'){\n            dp[i] = dp[i-1];\n        }\n        if(s[i-2] == '1' || (s[i-2] == '2' && s[i-1] <= '7')){\n            dp[i] += dp[i-2];\n        }\n    }\n    return dp[n];\n}\n\n\nint main(){\n    string s;\n    cin>>s;\n    cout<<countWays(s)<<\"\\n\";\n}"
  },
  {
    "path": "Optimal_Strategy_To_Play_A_Game.cpp",
    "content": "#include<bits/stdc++.h>\n#define N 5\nusing namespace std;\n\nint dp[N][N];\n\nint OptimalStrategy(int coins[],int i,int j){\n    //Base Cases\n    if(i==j)  return coins[i];\n    if(i==j+1) return max(coins[i],coins[j]);\n    if(dp[i][j]==0){\n        //Taking from the start\n        int start = coins[i] + min(OptimalStrategy(coins,i+2,j),OptimalStrategy(coins,i+1,j-1));\n        //Taking from end\n        int end = coins[j] + min(OptimalStrategy(coins,i,j-2),OptimalStrategy(coins,i+1,j-1));\n        //maximum of both\n        dp[i][j] = max(start,end);\n    }\n    return dp[i][j];\n}\n\nint main(){\n\n}"
  },
  {
    "path": "Path_In_A_Matrix.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint cost[1000][1000];\nvoid solve(int n,int cost[][1000]){\n    int dp[n][n];\n    memset(dp,0,sizeof(dp));\n    for(int i=n-1;i>=0;i--){\n        for(int j=n-1;j>=0;j--){\n            int down=(i==n-1)?0:dp[i+1][j];\n            int down_left=(i==n-1 || j==0)?0:dp[i+1][j-1];\n            int down_right=(i==n-1 || j==n-1)?0:dp[i+1][j+1];\n            dp[i][j]= cost[i][j]+max(down,max(down_right,down_left));\n        }\n    }\n    int ans=dp[0][0];\n    for(int i=1;i<n;i++){\n        ans=max(ans,dp[0][i]);\n    }\n    cout<<ans<<\"\\n\";\n}\nint main(){\n    int t;\n    cin>>t;\n    while(t--){\n        int n;\n        cin>>n;\n        for(int i=0;i<n;i++){\n            for(int j=0;j<n;j++){\n                cin>>cost[i][j];\n            }\n        }\n        solve(n,cost);\n    }\n}"
  },
  {
    "path": "Print_Longest_Common_Subsequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nstring PrintLcs(string s1,string s2){\n    int m = s1.length(),n = s2.length();\n    int dp[m+1][n+1];\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0) dp[i][j]=0;\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = 1 + dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    int i=m,j=n;\n    string ans=\"\";\n    while(i>0 && j>0){\n        if(s1[i-1] == s2[j-1]){\n            ans.push_back(s1[i-1]);\n            i--;\n            j--;\n        }\n        else if(dp[i][j-1]>dp[i-1][j]){\n            j--;\n        }\n        else{\n            i--;\n        }\n    }\n    reverse(ans.begin(),ans.end());\n    return ans;\n}\n\nint main(){\n    string s1 = \"abcdgl\";\n    string s2 = \"abedfhl\";\n    cout<<PrintLcs(s1,s2)<<\"\\n\";\n}"
  },
  {
    "path": "Procuct_of_array_except_self.cpp",
    "content": "https://leetcode.com/explore/featured/card/30-day-leetcoding-challenge/530/week-3/3300/\n\nclass Solution {\npublic:\n    vector<int> productExceptSelf(vector<int>& nums) {\n        int n = nums.size();\n        vector<int>left(n+1,1);\n        vector<int>right(n+1,1);\n        left[0] = nums[0];\n        right[n-1] = nums[n - 1 ];\n        for(int i = 1;i<n;i++) {\n            left[i] = left[i - 1 ] * nums[i];\n        }\n        for(int i = n - 2;i >= 0 ; i--) {\n            right[i] = right[i+1] * nums[i];\n        }\n        vector<int>ans(n);\n        for(int i = 0;i<n;i++) {\n            if(i == 0) {\n                ans[i] = right[i + 1];\n            }\n            if ( i == n-1 ) {\n                ans[i] = left[i - 1];\n            }\n            if(i > 0 and i< n -1 ) {\n                ans[i] = left[i - 1] * right[i + 1];\n            }\n            \n        }\n        return ans;\n    }\n};"
  },
  {
    "path": "README.md",
    "content": "# Dynamic-Programming\nA DP a day keeps the bug away.\n\n**Cointains Dp Problems**<br><br>\n\n**Parent Problem** : [*Kadane's Algorithm*](/Kadane.cpp)<br>\n1) [Best Time to Buy and sell Stock(Leetcode)](/Best_Time_To_Buy_And_Sell_Stock_.cpp)<br>\n2) [Circular Kadane](/Circular_Kadene.cpp)<br>\n\n**Parent Problem** : *Fibonacci*.<br>\nSubProblems :<br>\n1) [Reach a given Score](/Reach_a_given_score.cpp).<br>\n2) [Count number of hops](/Count_Number_of_hops.cpp).<br>\n3) [Count ways to reach n-th stair](/Count_ways_to_N'th_Stair.cpp).<br>\n4) [Count Number of Ways to Tile](/No_Of_Ways_To_Tile.cpp).<br>\n5) [Tiling Problem-General](/Tiling_Problem.cpp).<br>\n6) [Maximum Sum Dividing](/Maximum_Sum_Dividing_Recurssive.cpp).<br>\n7) [Friends Pairing Problem](/Friends_Pairing_Problem.cpp)<br>\n8) [Maximize the Cutting](/Maximize_the_cutting.cpp)<br>\n9) [Number of Ways to Decode a String](/Number_of_ways_to_decode_a_string.cpp)\n\n**Parent Problem** : [*0/1 KnapSack Problem*](/Knapsack_0_1.cpp)<br>\nSubProblems :<br>\n1) [SubSet Sum](/SubsetSum.cpp).<br>\n2) [Equal Sum Partition](/Equal_Sum_Partition.cpp).<br>\n3) [Count of SubSet Sum]().<br>\n4) [Minimum SubSet Sum Difference](/Minimum_Subset_Sum_Difference.cpp).<br>\n5) [Count SubSets of given Sum](/Count_Subsets_of_given_Sum.cpp).<br><br>\n\n**Parent Problem** : [*Unbounded KnapSack*](/Unbounded_Knapsack.cpp)<br>\nSubProblems :<br>\n1) [Coin Changing Problem 1(No of ways)](/Coin_Changing_1.cpp).<br>\n2) [Coin Changing Problem 2(Minimum no of coins)](/Coin_Changing_2.cpp).<br>\n3) [Rod Cutting Problem](/Rod_Cutting.cpp).<br>\n4) [Minimum Cost to Fill Bag](/Minm_Cost_To_Fill_Bag.cpp).<br><br>\n\n**Parent Problem** : [*Longest Common SubSequence*](/Longest_Common_Subsequence.cpp)<br>\nSubProblems :<br>\n1) [Longest Common SubString](/Longest_Common_Substring.cpp).<br>\n2) [Shortest Common SuperSequence](/Shortest_Common_Supersequence.cpp).<br>\n3) [Print LCS](/Print_Longest_Common_Subsequence.cpp).<br>\n4) [Minimum Insertions And Deletion to Convert a String](/Minm_Insertion_Deletion_Convert.cpp).<br>\n5) [Longest Repeating SubSequence](/Longest_Repeating_Subsequence.cpp).<br>\n6) [Longest Pallindromic SubSequence](/Longest_Pallindromic_Subsequence.cpp).<br>\n7) [Edit Distance](/Edit_Distance.cpp).<br>\n8) [Count All Pallindromic SubSequence](/Count_All_Pallindromic_Subsequence.cpp).<br>\n9) [Minimum Deletion to make string pallindrome](/Minm_Deletion_To_Make_Pallindrome.cpp).<br>\n10) [Count Distinct Occcurences](/Distinct_Occurences.cpp).<br>\n11) [Maximum length of pairs](/Maximum_length_of_pairs.cpp).<br>\n12) [Minimum Ascii Sum deletion To Make two Strings equal](/Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp).<br>\n13) [Maximum Dot Product of Subsequences(Leetcode)](/Maximum_Dot_Product_Subsequence.cpp).<br>\n14) [Uncrossed Lines(LeetCode)](/Uncrossed_Lines.cpp).<br><br>\n\n**Parent Problem** : [*Longest Increasing Subsequence*](/Longest_Increasing_Subsequence.cpp)<br>\n1) [Russian Doll Envelope(Leetcode)](/Russian_Doll_Envelope.cpp).<br>\n2) [Longest Decreasing SubSequence](/Longest_Decreasing_Subsequence.cpp).<br>\n3) [Maximum Sum Increasing SubSequence](/Maximum_Sum_Increasing_Subsequence.cpp).<br>\n4) [Maximum Sum Decreasing SubSequence](/Maximum_Sum_Decreasing_Subsequence.cpp).<br>\n5) [Maximum Product Increasing Subsequence](/Maximum_Product_Increasing_Subsequence.cpp).<br>\n6) [Minimum Jumps to reach end](/Minimum_Jumps_To_Reach_End.cpp).<br>\n7) [Box Stacking Problem](/Box_Stacking_Problem.cpp).<br>\n8) [Longest Bitonic Sequence](/BitonicSequence.cpp).<br>\n9) [Longest Alternating Subsequence](/longest_alternating_subsequence.cpp)<br>\n10) [Count All Increasing Subsequences](/Count_All_Increasing_Subsequences.cpp).<br>\n\n**Parent Problem** : *DP + Greedy*<br>\n1) [Jump Game-2(Leetcode)](/jump_game_2..cpp).<br>\n2) [Video Stiching(Leetcode)](/video_stiching.cpp).<br>\n3) [Minm number of taps to open water](/minm_number_of_taps_to_open_water.cpp).<br>\n\n**Parent Problem** : *Game(DP) + minimax*<br>\n1) [Nim Game](/nim_game.cpp).<br>\n2) [Flip Game-1](/flip_game.cpp).<br>\n3) [Flip Game-2](/flip_game2.cpp).<br>\n4) [Get Minimum Squares](/Get_Minimum_Squares.cpp).<br>\n5) [Optimal Strategy to play a Game](/Optimal_Strategy_To_Play_A_Game.cpp).<br>\n6) [Stone Game-3](/Last_Stone_3.cpp)<br>\n7) [Jump Game-3(Leetcode)](/Jump_Game_3.cpp)<br>\n8) [Jump Game-5(Leetcode)](/Jump_Game_5.cpp)<br>\n\n**Parent Problem** : *Dp on Grids*<br>\n1) [Maximum Size Submatrix Square](/Maximum_Size_Submatrix_Square.cpp).<br>\n2) [Maximum Path Sum in Triangle](/Max_Path_Sum_in_Triangle.cpp).<br>\n3) [Minimum Initial Points to Reach Destination](/Minimum_Initial_Points_To_Reach_Destinaion.cpp).<br>\n4) [GoldMine Problem](/GoldMine_Problem.cpp)<br>\n5) [Path in a Matrix](/Max_path_sum.cpp)<br>\n6) [Maximal Square(Leetcode)](/maximal_square.cpp)<br>\n7) [Count Submatrices with all ones(Leetcode)](/count_submatrices_with_all_ones.cpp)<br>\n8) [Maximum Sum Submatrix](/maximum_sum_submatrix.cpp)<br>\n9) [Unique Path-1](/unique_paths_1.cpp)<br>\n10) [Unique Path-2](/unique_paths_2.cpp)<br>\n\n\n**Parent Problem** : [*Matrix Chain Multiplication*](/Matrix_Chain_Multiplication.cpp)<br>\n\n**Parent Problem** : [*Count Distinct SubSequences*](/Count_Distinct_Subsequences.cpp)<br>\n\n**Parent Problem** : *Dp on Trees*<br>\n1) [Max Path Sum](/Max_path_sum.cpp)<br>\n2) [Maximum Path Sum in a Tree from Any node to any other node](/Maximum_Path_Sum_in_Binary_tree.cpp)<br>\n3) [Diameter of a Binary Tree](/Diameter_Of_Binary_Tree.cpp)<br>\n\n**Others**\n1) [Longest Consequetive Subsequences](/Longest_Consequetive_Subsequence.cpp).<br> \n2) [Zeroes And Ones](/zerosAndOnes.cpp)\n3) [Longest Pallidromic SubString](/Longest_Pallindromic_Substring.cpp).<br>\n4) [Count Pallindromic substring of string](/Count_Pallindromic_SubString_Of_String_gfg.cpp)<br>\n5) [Product of array except self](/Count_Pallindromic_SubString_Of_String_gfg.cpp)\n\nHappy Coding!!\n\n\n\n"
  },
  {
    "path": "Reach_a_given_score.cpp",
    "content": "#include<iostream>\nusing namespace std;\nvoid solve(int sum){\n    int dp[sum+1]={0};\n    dp[0]=1;\n    for(int i=3;i<=sum;i++) dp[i]+=dp[i-3];\n    for(int i=5;i<=sum;i++) dp[i]+=dp[i-5];\n    for(int i=10;i<=sum;i++) dp[i]+=dp[i-10];\n    \n    cout<<dp[sum]<<\"\\n\";\n}\nint main()\n {\n\tint t;\n\tcin>>t;\n\twhile(t--){\n\t    int sum;\n\t    cin>>sum;\n\t    solve(sum);\n\t}\n\treturn 0;\n}\n\n//similar to coin changing"
  },
  {
    "path": "Rod_Cutting.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint rodCutting(int cost[],int len[],int size) {\n    int dp[size+1][size+1];\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=size;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(len[i-1]<=j){\n                dp[i][j] = max(dp[i-1][j],cost[i-1] + dp[i][j-len[i-1]]);\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=size;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[size][size];\n}\n\nint main() {\n    int len[] = {1, 2, 3, 4, 5, 6, 7, 8};\n    int cost[] = {1, 5, 8, 9, 10, 17, 17, 20};\n    int size = sizeof(cost)/sizeof(cost[0]);\n    cout<<rodCutting(cost,len,size);\n}\n"
  },
  {
    "path": "Russian_Doll_Envelope.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// Problem Statement : https://leetcode.com/problems/russian-doll-envelopes/\n\n//Similar to LIS with a tweak.\nint maxEnvelopes(vector<vector<int>>& envelopes) {\n    sort(envelopes.begin(),envelopes.end());\n    int n=envelopes.size(),res=1;\n    vector<int>dp(n,1);\n    for(int i=1;i<n;i++){\n        for(int j=0;j<i;j++){\n            if(envelopes[i][0]>envelopes[j][0] && envelopes[i][1]>envelopes[j][1]){\n                dp[i] = max(dp[i],1+dp[j]);\n            }\n        }\n        res = max(res,dp[i]);\n    }\n    if(n==0) return 0;\n    else return res;\n}\n\n\n"
  },
  {
    "path": "Shortest_Common_Supersequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Scs(string s1,string s2){\n    int m = s1.length(),n=s2.length(),lcs;\n    int dp[m+1][n+1];\n    for(int i=0;i<=m;i++){\n        for(int j=0;j<=n;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(s1[i-1] == s2[j-1]){\n                dp[i][j] = 1 + dp[i-1][j-1];\n            }\n            else{\n                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    lcs = dp[m][n];\n    return m+n-lcs;\n}\nint main(){\n    string s1 = \"abcdgl\";\n    string s2 = \"abedfhl\";\n    cout<<Scs(s1,s2)<<\"\\n\";\n}"
  },
  {
    "path": "SubsetSum.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nbool SubsetSum(int a[],int size,int sum) {\n    bool dp[size+1][sum+1];\n    for(int i=0;i<=sum;i++){\n        dp[0][i] = false;\n    }\n    for(int i=0;i<=size;i++){\n        dp[i][0]=true;\n    }\n    for(int i=1;i<=size;i++){\n        for(int j=1;j<=sum;j++){\n            if(a[i-1] <= j) {\n                dp[i][j] = dp[i-1][j] || dp[i-1][j-a[i-1]];\n            }\n            else {\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    return dp[size][sum];\n}\n\nint main() {\n    int a[] = {3, 34, 4, 12, 5, 2}; \n    int sum = 1; \n    int size = sizeof(a)/sizeof a[0];\n    cout<<SubsetSum(a,size,sum)<<\"\\n\";\n}"
  },
  {
    "path": "Tiling_Problem.cpp",
    "content": "#include <bits/stdc++.h> \nusing namespace std;\n \nint CountWays(int n, int m) \n{ \n    int dp[n + 1]; \n    dp[0] = 0; \n    for (int i = 1; i <= n; i++) { \n        if (i > m) \n            dp[i] = dp[i - 1] + dp[i - m]; \n        else if (i < m) \n            dp[i] = 1; \n        else\n            dp[i] = 2; \n    } \n    return dp[n]; \n}\nint main() \n{ \n    int n = 7, m = 4; \n    cout << \"Number of ways = \"\n         << CountWays(n, m); \n    return 0; \n} "
  },
  {
    "path": "Unbounded_Knapsack.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\nint knapsack(int wt[],int val[],int W,int size){\n    int dp[size+1][W+1];\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=W;j++){\n            if(i==0 || j==0){\n                dp[i][j] = 0;\n            }\n            else if(wt[i-1]<=j){\n                dp[i][j] = max(dp[i-1][j],val[i-1] + dp[i][j-wt[i-1]]);\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    for(int i=0;i<=size;i++){\n        for(int j=0;j<=W;j++){\n            cout<<dp[i][j]<<\" \";\n        }\n        cout<<\"\\n\";\n    }\n    return dp[size][W];\n}\n\nint main() {\n    \n    int wt[] = {1, 3, 2}; \n    int val[] = {50, 10, 15}; \n    int  W = 10; \n    int size = sizeof(val)/sizeof(val[0]); \n    cout<<knapsack(wt,val,W,size)<<\"\\n\";\n\n}"
  },
  {
    "path": "Uncrossed_Lines.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\nint maxUncrossedLines(vector<int>& A, vector<int>& B,int n,int m) {\n    vector<vector<int>>dp(m+1,vector<int>(n+1,0));\n    for(int i=1;i<=m;i++){\n        for(int j=1;j<=n;j++){\n            if(A[i-1]==B[j-1]){\n                dp[i][j] = 1+dp[i-1][j-1];\n            }\n            else{\n                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);\n            }\n        }\n    }\n    return dp[m][n];\n}\n\n\nint main(){\n    int m,n;\n    cin>>m>>n;\n    vector<int>A(m),B(n);\n    for(int i=0;i<m;i++){\n        cin>>A[i];\n    }\n    for(int i=0;i<n;i++){\n        cin>>B[i];\n    }\n    cout<<maxUncrossedLines(A,B,m,n)<<\"\\n\";\n}"
  },
  {
    "path": "count_submatrices_with_all_ones.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/count-square-submatrices-with-all-ones\n\nclass Solution {\npublic:\n    int countSquares(vector<vector<int>>& m) {\n        if(m.empty()) return 0;\n        int sum=0;\n        int dp[m.size()][m[0].size()];\n        for(int i=0;i<m.size();i++) dp[i][0] = m[i][0];\n        for(int i=0;i<m[0].size();i++) dp[0][i] = m[0][i];\n        for(int i=1;i<m.size();i++){\n            for(int j=1;j<m[0].size();j++){\n                if(m[i][j] == 1) dp[i][j] = 1+min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));\n                else dp[i][j] = 0;\n            }\n        }\n        for(int i=0;i<m.size();i++){\n            for(int j=0;j<m[0].size();j++){\n                sum+=dp[i][j];\n            }\n        }\n        return sum;\n    }\n};"
  },
  {
    "path": "count_subsets_of_given_difference.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// given an array a difference of subset.find the count of that difference\n// approach ----------------> s1 + s2 = sum(arr) --eqn1 && s1-s2 = diff(given) ---eqn2;\n// solve eqn1 & eqn2 find s1 . s1 = (sum+diff)/2\n// therefore the problem reduces to count number of subset of with sum s1\n\nint count(vector<int> &nums,int sum) {\n    int n = nums.size();\n    vector<vector<int>>dp(n+1,vector<int>(sum+1,0));\n    for(int i=0;i<=sum;i++){\n        dp[0][i] = 0;\n    }\n    for(int i=0;i<=n;i++){\n        dp[i][0] = 1;\n    }\n    for(int i=1;i<=n;i++){\n        for(int j=1;j<=sum;j++){\n            if(nums[i-1] <= j){\n                dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]];\n            }\n            else{\n                dp[i][j] = dp[i-1][j];\n            }\n        }\n    }\n    return dp[n][sum];\n}\n\nint main() {\n    int n,diff,sum=0;\n    cin>>n>>diff;\n    vector<int>nums(n);\n    for(int i=0;i<n;i++){\n        cin>>nums[i];\n        sum += nums[i];\n    }\n    int s1 = (sum+diff)/2;\n    cout<<count(nums,s1);\n}"
  },
  {
    "path": "flip_game_1.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.lintcode.com/problem/flip-game/\n\nclass Solution {\npublic:\n    vector<string> generatePossibleNextMoves(string &s) {\n        // write your code here\n        int n=s.length();\n        vector<string>ans;\n        for(int i=0;i<n-1;i++){\n            if(s[i] == '+' && s[i+1] == '+'){\n                s[i] = s[i+1] = '-';\n                ans.push_back(s);\n                s[i] = s[i+1] = '+';\n            }\n        }\n        return ans;\n    }\n};"
  },
  {
    "path": "flip_game_2.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.lintcode.com/problem/flip-game-ii/\n// very good question\n\nclass Solution {\npublic:\n    bool canWin(string &s) {\n        // write your code here\n        if(s.length()<2) return false;\n        return flipGame(s);\n    }\n    \n    bool flipGame(string &s){\n        for(int i=0;i<s.length()-1;i++){\n            if(s[i]=='+' && s[i+1]=='+'){\n                // find the next state of the string and see if the other player can win\n                // with the next state\n                string nextState = s.substr(0,i)+\"--\"+s.substr(i+2);\n                // if the player can't win with the next state, i will win the flipGame\n                // and hence return true\n                if(!flipGame(nextState)){\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n};"
  },
  {
    "path": "jump_game_2..cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/jump-game-ii/\n// dp+greedy(range-based)\n\nclass Solution {\npublic:\n    int jump(vector<int>& nums) {\n       int pos=0,des=0,jump=0;\n        for(int i=0;i<nums.size()-1;i++){ //nums.size()-1 is done coz we dont need the last index\n            des = max(des,i+nums[i]);\n            if(pos == i){\n                pos = des;\n                jump++;\n            }\n        }\n        return jump;\n    }\n};"
  },
  {
    "path": "longest_alternating_subsequence.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/wiggle-subsequence\n\n// O(n^2) time and o(n) space\nclass Solution {\npublic:\n    int wiggleMaxLength(vector<int>& nums) {\n        int n=nums.size();\n        if(n == 0) return 0;\n//     up[i] refers to the length of the longest wiggle subsequence obtained so far considering ith element   \n        vector<int>up(n,1),down(n,1);\n        for(int i=1;i<n;i++){\n            for(int j=0;j<i;j++){\n                if(nums[i] > nums[j]){\n                    up[i] = max(up[i],1+down[j]);\n                }\n                else if(nums[i] < nums[j]){\n                    down[i] = max(down[i],1+up[j]);\n                }\n            }\n        }\n        return max(up[n-1],down[n-1]);\n    }\n};\n\n\n// O(n) time and O(n) space\n\nclass Solution {\npublic:\n    int wiggleMaxLength(vector<int>& nums) {\n        int n=nums.size();\n        if(n == 0) return 0;\n//     up[i] refers to the length of the longest wiggle subsequence obtained so far considering ith element   \n        vector<int>up(n,1),down(n,1);\n        for(int i=1;i<n;i++){\n            if(nums[i] > nums[i-1]){\n                up[i] = 1+down[i-1];\n                down[i] = down[i-1];\n            }\n            else if(nums[i] < nums[i-1]){\n                down[i] = 1+up[i-1];\n                up[i] = up[i-1];\n            }\n            else{\n                down[i] = down[i-1];\n                up[i] = up[i-1];\n            }\n        }\n        return max(up[n-1],down[n-1]);\n    }\n};\n\n\n\n// O(n) ime and O(1) space\nclass Solution {\npublic:\n    int wiggleMaxLength(vector<int>& nums) {\n        int n=nums.size();\n        if(n == 0) return 0;\n        int up=1,down=1;\n        for(int i=1;i<n;i++){\n            if(nums[i] > nums[i-1]){\n                up = down+1;\n            }\n            else if(nums[i] < nums[i-1]){\n                down = up+1;\n            }\n        }\n        return max(up,down);\n    }\n};"
  },
  {
    "path": "maximal_square.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/maximal-square/\n\nclass Solution {\npublic:\n    int maximalSquare(vector<vector<char>>& matrix) {\n        if(matrix.empty()) return 0;\n        int res=0;\n        vector<vector<int>>m(matrix.size(),vector<int>(matrix[0].size()));\n        for(int i=0;i<matrix.size();i++){\n            for(int j=0;j<matrix[0].size();j++){\n                if(matrix[i][j] == '0') m[i][j]=0;\n                else {\n                    m[i][j] = 1;\n                    res = 1;\n                }\n            }\n        }\n        int dp[m.size()][m[0].size()];\n        for(int i=0;i<matrix.size();i++) dp[i][0] = m[i][0];\n        for(int i=0;i<matrix[0].size();i++) dp[0][i] = m[0][i];\n        for(int i=1;i<m.size();i++){\n            for(int j=1;j<m[0].size();j++){\n                if(m[i][j] == 1) dp[i][j] = 1+min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));\n                else dp[i][j] = 0;\n                res = max(res,dp[i][j]);\n            }\n        }\n        return res*res;\n    }\n};"
  },
  {
    "path": "maximum_product_subarray.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/maximum-product-subarray/\n\nclass Solution {\npublic:\n    int maxProduct(vector<int>& nums) {\n//         almost similar to kadane\n        int n=nums.size(),maxPro=1,minPro=1,best=INT_MIN;\n        for(int i=0;i<n;i++){\n            if(nums[i]<0){\n                swap(maxPro,minPro);\n            }\n            maxPro = max(maxPro*nums[i],nums[i]);\n            minPro = min(minPro*nums[i],nums[i]);\n            best = max(best,maxPro);\n        }\n        return best;\n    }\n};"
  },
  {
    "path": "maximum_sum_submatrix.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.interviewbit.com/problems/maximum-sum-square-submatrix/\n// very beautiful question\n\nint Solution::solve(vector<vector<int> > &A, int B) {\n    int r = A.size(),c=A[0].size();\n    vector<vector<int>>dp(r+1,vector<int>(c+1,0));\n    for(int i=1;i<dp.size();i++){\n        for(int j=1;j<dp[0].size();j++){\n            dp[i][j] = A[i-1][j-1] + dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1];\n        }\n    }\n    for(int i=1;i<dp.size();i++){\n        for(int j=1;j<dp[0].size();j++){\n            int sum = INT_MIN;\n            if(i-B >=0 && j-B >= 0){\n                sum = max(sum,dp[i][j]-dp[i-B][j]-dp[i][j-B]+dp[i-B][j-B]);\n            }\n        }\n    }\n    return sum;\n}\n"
  },
  {
    "path": "minm_number_of_taps_to_open_water.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/minimum-number-of-taps-to-open-to-water-a-garden/\n\nclass Solution {\npublic:\n    int minTaps(int n, vector<int>& ranges) {\n        int minm=0;\n        int maxm=0;\n        int open=0;\n        while(maxm < n){\n            for(int i=0;i<ranges.size();i++){\n                int l = i-ranges[i];\n                int r = i+ranges[i];\n                if(l<=minm && r>maxm){\n                    maxm = r;\n                }\n            }\n            if(minm == maxm) return -1;\n            minm = maxm;\n            open++;\n        }\n        return open;\n    }\n};"
  },
  {
    "path": "nim_game.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/nim-game\n\n//  n > 10^9 won't work, O(n) solution\nclass Solution {\npublic:\n    bool canWinNim(int n) {\n        if(n <= 3) return true;\n        bool dp[n+1];\n        dp[0]=false;\n        dp[1]=true,dp[2]=true,dp[3]=true;\n        for(int i=4;i<=n;i++){\n            dp[i] = !(dp[i-1] && dp[i-2] && dp[i-3]);\n        }\n        return dp[n];\n    }\n};\n\n//  O(1) solution\n\nclass Solution {\npublic:\n    bool canWinNim(int n) {\n        return !(n%4 == 0);\n    }\n};"
  },
  {
    "path": "nth_catlan_number.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// O(n^2) approach;\nint nCatlan(int n) {\n    vector<int>dp(n,0);\n    dp[0] = dp[1] = 1;\n    for(int i=2;i<=n;i++){\n        for(int j=0;j<i;j++){\n            dp[i] += dp[j]*dp[i-j-1];\n        }\n    }\n    return dp[n];\n}\n\n// O(n) approach using binomial coefficient\n\n// binomial coefficent\nint binomial(int n,int r){\n    int res=1;\n    if(r > n-r) r = n-r;\n    for(int i=0;i<r;i++){\n        res *= (n-i);\n        res /= (i+1);\n    }\n    return res;\n}\n\n// catlan using binomial coefficient\nint catlan(int n){\n    // C(n) = 1/n+1[(2*n)Cn]\n    int b = binomial(2*n,n);\n    return b/(n+1);\n}\n\n\nint main(){\n    int n;\n    cin >> n;\n    cout<<nCatlan(n)<<\"\\n\";\n    cout<<catlan(n)<<\"\\n\";\n}"
  },
  {
    "path": "num_products.cpp",
    "content": "// https://codeforces.com/problemset/problem/1215/B\n\n#include<bits/stdc++.h>\nusing namespace std;\nvector<int>d[2005];\nvoid divisors() {\n    for(int i = 1 ; i <= 2005 ; i++) {\n        if(i != 1)d[i].push_back(1);\n        for(int j = 2 ; j * j <= i ; j++) {\n            if(i % j == 0) {\n                d[i].push_back(j);\n                if(i/j != j) d[i].push_back(i/j);\n            }\n        }\n    }\n}\n\nint main() {\n    #define int long long\n    int n;\n    cin>>n;\n    vector<int>a(n);\n    for(int i = 0 ; i < n ;i++) {\n        cin>>a[i];\n    }\n    int a1 = 0, a2 = 0, neg = 0, pos = 0;\n    for(int i = 0; i < n ;i++) {\n        if(a[i] < 0) {\n            swap(pos, neg);\n            neg++;\n            a1 += pos;\n            a2 += neg;\n        } else {\n            pos++;\n            a1 += pos;\n            a2 += neg;\n        }\n    }\n    cout<<a2 <<\" \"<<a1<<\"\\n\";\n}\n"
  },
  {
    "path": "number_of_permutations_such_that_no_three_forms_increasing_sequence.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// O(n) approach using binomial coefficient\n\n// binomial coefficent\nint binomial(int n,int r){\n    int res=1;\n    if(r > n-r) r = n-r;\n    for(int i=0;i<r;i++){\n        res *= (n-i);\n        res /= (i+1);\n    }\n    return res;\n}\n\n// catlan using binomial coefficient\nint catlan(int n){\n    // C(n) = 1/n+1[(2*n)Cn]\n    int b = binomial(2*n,n);\n    return b/(n+1);\n}\n\n\nint main(){\n    int n;\n    cin >> n;\n    cout<<catlan(n);\n}\n"
  },
  {
    "path": "number_of_valid_parenthesis.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// O(n) approach using binomial coefficient\n\n// binomial coefficent\nint binomial(int n,int r){\n    int res=1;\n    if(r > n-r) r = n-r;\n    for(int i=0;i<r;i++){\n        res *= (n-i);\n        res /= (i+1);\n    }\n    return res;\n}\n\n// catlan using binomial coefficient\nint catlan(int n){\n    // C(n) = 1/n+1[(2*n)Cn]\n    int b = binomial(2*n,n);\n    return b/(n+1);\n}\n\n\nint main(){\n    string s;\n    cin >> s;\n    int n = s.length();\n    cout<<catlan(n/2);\n}\n"
  },
  {
    "path": "spoj/ABA12C - Buying Apples!.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define int long long int \n\nsigned main(){\n    int t;cin >> t;\n    while( t--){\n        int n , k; cin >> n >> k ;\n        vector<int> prices(k); for ( int i = 0;  i < k ; i++ ) cin >> prices[i];\n        vector<int> dp( 1001, INT_MAX);\n        dp[0] = 0;\n        for ( int i =0 ; i < k ; i ++ ){\n            if  ( prices[i] == -1) continue;\n            for ( int weight = i+1 ; weight <= k ; weight ++) {\n                dp[ weight ] = min( dp[weight - i -  1] + prices[i] , dp[weight]);\n            }\n        }\n        if ( dp[k] == INT_MAX){\n            cout << -1 << \"\\n\";\n        }\n        else cout << dp[k];\n    }\n}"
  },
  {
    "path": "spoj/ACODE - Alphacode.cpp",
    "content": "/*\n\nHINT \n\nTestcases\n25114\n1111111111\n3333333333\n109\n20201\n1013\n211003\n100\n21103\n101230\n\nOutput\n6\n89\n1\n1\n1\n2\n0\n0\n2\n\n\n*/\n\n#include <bits/stdc++.h>\nusing namespace std;\n#define ll long long int\nsigned main()\n{\n    while (true)\n    {\n        string s;\n        cin >> s;\n        if (s == \"0\")break;\n        int n = s.size();\n        vector<int> dp(n + 1, 0);\n        dp[n-1]=1;\n        if ( n>=2){\n            int x = (s[n-2] - '0') * 10 + s[n-1] - '0';\n            if ( x >= 10 && x <= 26 ) dp[n-2] =1;\n        }\n        int np = 0;\n        for (int i = n - 2; i >= 0; i--){\n            if ( s[i+1] == '0' ) {\n                if (s[i] == '0') np = 1;\n                dp[i] += dp[i+2];\n                continue;\n            }\n            dp[i] += dp[i + 1];\n            int x = (s[i] - '0') * 10 + s[i + 1] - '0';\n            if (x >= 10 && x <= 26 && s[i+2] != '0')\n                dp[i] +=  dp[i + 2];\n        }\n        if ( np) cout << 0 << \"\\n\";\n        else cout << dp[0] << \"\\n\";\n    }\n}"
  },
  {
    "path": "spoj/AIBOHP - Aibohphobia.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n#define int long long int\nint dp[6103][6103];\nsigned main(){\n    int t; cin >> t;\n    while( t--){\n        string s;\n        cin >> s; string t =s;\n        reverse( t.begin() , t.end());\n        memset( dp , 0 , sizeof(dp));\n        int n = s.size();\n        for ( int i = 1 ;i  <= n ; i++ ){\n            for ( int j = 1 ; j <= n ; j++ ){\n                if ( s[i-1] == t[j-1]) dp[i][j] =1 + dp[i-1][j-1] ;\n                dp[i][j] = max( dp[i][j] ,max( dp[i-1][j] , dp[i][j-1]));\n            }\n        }\n        cout << n - dp[n][n] << \"\\n\";\n    }\n}"
  },
  {
    "path": "spoj/ANARC09A - Seinfeld.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define int long long int\n\nsigned main(){\n    \n    for ( int t =1; ; t++){\n        string s; cin >> s;\n        if ( s[0] == '-') break;\n        int open = 0 ;\n        int ans =  0 ; \n        int n = s.size();\n        for ( int i = 0 ; i < n ; i ++){\n            if ( s[i] == '}'){\n                if ( !open){\n                    ans++;\n                    open++;\n                }\n                else open--;\n            }\n            else open++;            \n        }\n        cout <<t << \". \" <<   ans + open/2<< \"\\n\";\n    }\n}"
  },
  {
    "path": "unique_paths_1.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem: https://leetcode.com/problems/unique-paths/\n\nclass Solution {\npublic:\n    int uniquePaths(int m, int n) {\n        vector<vector<int>>dp(m,vector<int>(n,1));\n        for(int i=1;i<m;i++){\n            for(int j=1;j<n;j++){\n                dp[i][j]=dp[i-1][j]+dp[i][j-1];\n            }\n        }\n        return dp[m-1][n-1];\n    }\n};"
  },
  {
    "path": "unique_paths_2.cpp",
    "content": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/unique-paths-ii\n\nclass Solution {\npublic:\n    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {\n        int n=obstacleGrid.size(),m=obstacleGrid[0].size();\n        vector<vector<int>>dp(n,vector<int>(m,1));\n        int f=0;\n        for(int i=0;i<n;i++){\n            if(obstacleGrid[i][0] == 1){\n                f = 1;\n            }\n            if(f == 1){\n                dp[i][0] = 0;\n            }\n        }\n        f=0;\n        for(int i=0;i<m;i++){\n            if(obstacleGrid[0][i] == 1){\n                f = 1;\n            }\n            if(f == 1){\n                dp[0][i] = 0;\n            }\n        }\n        for(int i=1;i<n;i++){\n            for(int j=1;j<m;j++){\n                if(obstacleGrid[i][j] == 0){\n                    dp[i][j] = dp[i-1][j] + dp[i][j-1];\n                }\n                else{\n                    dp[i][j] = 0;\n                }\n            }\n        }\n        return dp[n-1][m-1];\n    }\n};"
  },
  {
    "path": "video_stiching.cpp",
    "content": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem: https://leetcode.com/problems/video-stitching/\n\nclass Solution {\npublic:\n    int videoStitching(vector<vector<int>>& clips, int T) {\n        int minm=0;\n        int maxm=0;\n        int total = 0;\n        while(maxm < T){\n            for(int i=0;i<clips.size();i++){\n                int l = clips[i][0];\n                int r = clips[i][1];\n                if(l<=minm && r>maxm){\n                    maxm = r;\n                }\n            }\n            if(minm == maxm) return -1;\n            minm = maxm;\n            total++;\n        }\n        return total;\n    }\n};"
  },
  {
    "path": "zerosAndOnes.cpp",
    "content": "\n// link https://leetcode.com/problems/ones-and-zeroes/\n#include<bits/stdc++.h>\nusing namespace std;\nclass Solution {\n    public:\n    Solution(){}\n    int findMaxForm(vector<string>& strs, int m, int n) {\n        int len = strs.size();\n        int dp[len+1][m+1][n+1];\n        memset(dp, 0, sizeof dp);\n        \n        for (int i=1;i<=len;i++){\n                    int ones = count(strs[i-1].begin(), strs[i-1].end(), '1');\n                    int zeros = strs[i-1].size()-ones;\n            for (int j=0;j<=m;j++){\n                for (int k=0;k<=n;k++){\n\n                    int res = dp[i-1][j][k];\n                    if (zeros<=j && ones<=k) \n                       res = max(res, dp[i-1][j-zeros][k-ones]+1);\n                    dp[i][j][k] = res;\n                }\n            }\n        }\n        \n        return dp[len][m][n];\n        \n    }\n};\nint main(){\n    Solution s;\n    int m,n;\n    cout<<\"Enter the max zeros \";\n    cin>>m;\n    cout<<\"Enter the max ones \";\n    cin>>n;\n    int strings;\n    cout<<\"Eneter the no of words \";\n    cin>>strings;\n    vector<string>words;\n    for(int i=0;i<strings;i++) {\n        string str;\n        cin>>str;\n        words.push_back(str);\n    }\n    cout<<s.findMaxForm(words,m,n)<<\"\\n\";\n}"
  }
]