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";
}
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
SYMBOL INDEX (188 symbols across 89 files)
FILE: 3_segment.cpp
function main (line 8) | int main() {
FILE: Best_Time_To_Buy_And_Sell_Stock_.cpp
function best_time (line 6) | int best_time(vector<int>&arr,int n){
function main (line 19) | int main(){
FILE: BitonicSequence.cpp
function main (line 3) | int main() {
FILE: Box_Stacking_Problem.cpp
type Box (line 4) | struct Box{
function comparator (line 10) | bool comparator(Box b1, Box b2){
function maxStackHeight (line 13) | int maxStackHeight(int h[],int d[],int w[],int n){
FILE: Circular_Kadene.cpp
function maxMoney (line 6) | int maxMoney(int arr[], int num)
FILE: Coin_Changing_1.cpp
function Max_ways (line 4) | int Max_ways(int coins[],int size,int sum){
function main (line 32) | int main() {
FILE: Coin_Changing_2.cpp
function Minm_Coins (line 4) | int Minm_Coins(int coins[],int size,int sum) {
function main (line 24) | int main(){
FILE: Count_All_Increasing_Subsequences.cpp
function Count_AIS (line 4) | int Count_AIS(int a[],int size){
function AIS (line 27) | int AIS(int a[],int size){
function main (line 41) | int main(){
FILE: Count_All_Pallindromic_Subsequence.cpp
function CountLPS (line 4) | int CountLPS(string s){
function main (line 24) | int main(){
FILE: Count_Distinct_Subsequences.cpp
function CDS (line 4) | int CDS(string s,int size){
function main (line 17) | int main(){
FILE: Count_Number_of_hops.cpp
function solve (line 3) | void solve(int n){
function main (line 11) | int main()
FILE: Count_Pallindromic_SubString_Of_String_gfg.cpp
function expandAroundCenter (line 4) | int expandAroundCenter(string s,int left,int right){
function CountLPSubstring (line 14) | int CountLPSubstring(string s){
function main (line 23) | int main(){
FILE: Count_Subsets_of_given_Sum.cpp
function CountSubsets (line 4) | int CountSubsets(int a[],int size,int sum) {
function main (line 31) | int main() {
FILE: Count_ways_to_N'th_Stair.cpp
function countWays (line 1) | long long countWays(int m){
FILE: Diameter_Of_Binary_Tree.cpp
function helper (line 2) | int helper(Node* node,int &res){
function diameter (line 11) | int diameter(Node* node) {
FILE: Distinct_Occurences.cpp
function Count_All_Distinct_Occurences (line 4) | int Count_All_Distinct_Occurences(string s1,string s2){
function main (line 28) | int main(){
FILE: Edit_Distance.cpp
function Edit_Distance (line 4) | int Edit_Distance(string s1,string s2){
function main (line 28) | int main(){
FILE: Equal_Sum_Partition.cpp
function EqualSubsetSum (line 4) | bool EqualSubsetSum(int a[],int size) {
function main (line 30) | int main() {
FILE: Friends_Pairing_Problem.cpp
function main (line 4) | int main()
FILE: Get_Minimum_Squares.cpp
function getMinimumSquares (line 3) | int getMinimumSquares(int n){
function main (line 19) | int main(){
FILE: GoldMine_Problem.cpp
function main (line 3) | int main(){
FILE: Jump_Game_3.cpp
class Solution (line 1) | class Solution {
method canReach (line 3) | bool canReach(vector<int>& arr, int start) {
method help (line 8) | bool help(vector<int>& arr, int start, vector<int>& tab, int N) {
FILE: Jump_Game_5.cpp
function helper (line 6) | int helper(vector<int>& arr,int d,int i){
function maxJumps (line 15) | int maxJumps(vector<int>& arr, int d) {
FILE: Kadane.cpp
function Kadane (line 4) | int Kadane(int a[],int size){
function main (line 13) | int main(){
FILE: Knapsack_0_1.cpp
function knapsack (line 3) | int knapsack(int wt[],int val[],int W,int size){
function main (line 21) | int main() {
FILE: Last_Stone_3.cpp
function helper (line 6) | int helper(vector<int>& s,int i){
function string (line 16) | string stoneGameIII(vector<int>& s) {
function helper (line 24) | int helper(vector<int>&s,int i){
function string (line 35) | string stoneGameIII(vector<int>& s) {
function string (line 43) | string stoneGameIII(vector<int>& s) {
function main (line 60) | int main(){
FILE: Longest_Common_Subsequence.cpp
function Lcs (line 3) | int Lcs(string s1,string s2){
function main (line 26) | int main(){
FILE: Longest_Common_Substring.cpp
function LCSub (line 3) | int LCSub(string s1,string s2){
function main (line 22) | int main(){
FILE: Longest_Consequetive_Subsequence.cpp
function main (line 3) | int main()
FILE: Longest_Decreasing_Subsequence.cpp
function LDS (line 4) | int LDS(int a[],int size){
function main (line 19) | int main(){
FILE: Longest_Increasing_Subsequence.cpp
function LIS (line 4) | int LIS(int a[],int size){
function main (line 19) | int main(){
FILE: Longest_Pallindromic_Subsequence.cpp
function longestPalindromeSubseq (line 5) | int longestPalindromeSubseq(string s) {
function main (line 27) | int main(){
FILE: Longest_Pallindromic_Substring.cpp
function expandAroundCenter (line 4) | int expandAroundCenter(string s,int left,int right){
function string (line 12) | string LPSubstring(string s){
function main (line 26) | int main(){
FILE: Longest_Repeating_Subsequence.cpp
function LRS (line 4) | int LRS(string s){
function main (line 23) | int main() {
FILE: Matrix_Chain_Multiplication.cpp
function MCM (line 5) | int MCM(int a[],int i,int j){
function main (line 16) | int main(){
FILE: Max_Path_Sum_in_Triangle.cpp
function Max_Sum_Tri (line 5) | int Max_Sum_Tri(int t[][N],int m,int n){
function main (line 14) | int main(){
FILE: Max_path_sum.cpp
function largest_sum (line 6) | int largest_sum(int child,int parent) {
function main (line 17) | int main() {
FILE: Maximize_the_cutting.cpp
function main (line 3) | int main()
FILE: Maximum_Dot_Product_Subsequence.cpp
function maxDotProduct (line 5) | int maxDotProduct(vector<int>& A, vector<int>& B,int size1,int size2) {
function main (line 19) | int main(){
class Solution (line 34) | class Solution {
method maxDotProduct (line 36) | int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
FILE: Maximum_Path_Sum_in_Binary_tree.cpp
class Solution (line 2) | class Solution {
method maxToRoot (line 3) | int maxToRoot(TreeNode *root, int &re) {
method maxPathSum (line 13) | int maxPathSum(TreeNode *root) {
FILE: Maximum_Product_Increasing_Subsequence.cpp
function MPIS (line 3) | int MPIS(int a[],int size){
function main (line 24) | int main(){
FILE: Maximum_Size_Submatrix_Square.cpp
function Max_Square (line 5) | int Max_Square(int M[r][c]){
function main (line 31) | int main(){
FILE: Maximum_Sum_Decreasing_Subsequence.cpp
function MSDS (line 3) | int MSDS(int a[],int size){
function main (line 24) | int main(){
FILE: Maximum_Sum_Dividing_Recurssive.cpp
function main (line 3) | int main()
FILE: Maximum_Sum_Increasing_Subsequence.cpp
function MSIS (line 3) | int MSIS(int a[],int size){
function main (line 24) | int main(){
FILE: Maximum_length_of_pairs.cpp
function findLongestChain (line 1) | int findLongestChain(vector<vector<int>>& pairs) {
FILE: Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp
function minimumDeleteSum (line 3) | int minimumDeleteSum(string s1, string s2) {
function main (line 35) | int main(){
FILE: Minimum_Initial_Points_To_Reach_Destinaion.cpp
function MinmIniPoints (line 8) | int MinmIniPoints(int a[][3]){
function main (line 22) | int main(){
FILE: Minimum_Jumps_To_Reach_End.cpp
function Min_Jumps (line 5) | int Min_Jumps(int a[],int size){
function minJumps (line 20) | int minJumps(int a[],int n){
function main (line 40) | int main(){
FILE: Minimum_Subset_Sum_Difference.cpp
function Minm_SubsetSum_Diff (line 3) | int Minm_SubsetSum_Diff(int a[],int size){
function main (line 34) | int main(){
FILE: Minm_Cost_To_Fill_Bag.cpp
function minm_Cost (line 6) | int minm_Cost(int cost[],int n,int W){
function main (line 46) | int main()
FILE: Minm_Deletion_To_Make_Pallindrome.cpp
function DelPallin (line 4) | int DelPallin(string s){
function main (line 26) | int main() {
FILE: Minm_Insertion_Deletion_Convert.cpp
function Idconvert (line 4) | int Idconvert(string s1,string s2){
function main (line 26) | int main() {
FILE: No_Of_Ways_To_Tile.cpp
function main (line 3) | int main()
FILE: Number_of_ways_to_decode_a_string.cpp
function countWays (line 5) | int countWays(string s){
function main (line 23) | int main(){
FILE: Optimal_Strategy_To_Play_A_Game.cpp
function OptimalStrategy (line 7) | int OptimalStrategy(int coins[],int i,int j){
function main (line 22) | int main(){
FILE: Path_In_A_Matrix.cpp
function solve (line 4) | void solve(int n,int cost[][1000]){
function main (line 21) | int main(){
FILE: Print_Longest_Common_Subsequence.cpp
function string (line 3) | string PrintLcs(string s1,string s2){
function main (line 36) | int main(){
FILE: Procuct_of_array_except_self.cpp
class Solution (line 3) | class Solution {
method productExceptSelf (line 5) | vector<int> productExceptSelf(vector<int>& nums) {
FILE: Reach_a_given_score.cpp
function solve (line 3) | void solve(int sum){
function main (line 12) | int main()
FILE: Rod_Cutting.cpp
function rodCutting (line 4) | int rodCutting(int cost[],int len[],int size) {
function main (line 28) | int main() {
FILE: Russian_Doll_Envelope.cpp
function maxEnvelopes (line 7) | int maxEnvelopes(vector<vector<int>>& envelopes) {
FILE: Shortest_Common_Supersequence.cpp
function Scs (line 4) | int Scs(string s1,string s2){
function main (line 23) | int main(){
FILE: SubsetSum.cpp
function SubsetSum (line 3) | bool SubsetSum(int a[],int size,int sum) {
function main (line 24) | int main() {
FILE: Tiling_Problem.cpp
function CountWays (line 4) | int CountWays(int n, int m)
function main (line 18) | int main()
FILE: Unbounded_Knapsack.cpp
function knapsack (line 3) | int knapsack(int wt[],int val[],int W,int size){
function main (line 27) | int main() {
FILE: Uncrossed_Lines.cpp
function maxUncrossedLines (line 4) | int maxUncrossedLines(vector<int>& A, vector<int>& B,int n,int m) {
function main (line 20) | int main(){
FILE: count_submatrices_with_all_ones.cpp
class Solution (line 6) | class Solution {
method countSquares (line 8) | int countSquares(vector<vector<int>>& m) {
FILE: count_subsets_of_given_difference.cpp
function count (line 9) | int count(vector<int> &nums,int sum) {
function main (line 31) | int main() {
FILE: flip_game_1.cpp
class Solution (line 6) | class Solution {
method generatePossibleNextMoves (line 8) | vector<string> generatePossibleNextMoves(string &s) {
FILE: flip_game_2.cpp
class Solution (line 7) | class Solution {
method canWin (line 9) | bool canWin(string &s) {
method flipGame (line 15) | bool flipGame(string &s){
FILE: jump_game_2..cpp
class Solution (line 7) | class Solution {
method jump (line 9) | int jump(vector<int>& nums) {
FILE: longest_alternating_subsequence.cpp
class Solution (line 7) | class Solution {
method wiggleMaxLength (line 9) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 33) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 61) | int wiggleMaxLength(vector<int>& nums) {
class Solution (line 31) | class Solution {
method wiggleMaxLength (line 9) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 33) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 61) | int wiggleMaxLength(vector<int>& nums) {
class Solution (line 59) | class Solution {
method wiggleMaxLength (line 9) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 33) | int wiggleMaxLength(vector<int>& nums) {
method wiggleMaxLength (line 61) | int wiggleMaxLength(vector<int>& nums) {
FILE: maximal_square.cpp
class Solution (line 6) | class Solution {
method maximalSquare (line 8) | int maximalSquare(vector<vector<char>>& matrix) {
FILE: maximum_product_subarray.cpp
class Solution (line 6) | class Solution {
method maxProduct (line 8) | int maxProduct(vector<int>& nums) {
FILE: minm_number_of_taps_to_open_water.cpp
class Solution (line 6) | class Solution {
method minTaps (line 8) | int minTaps(int n, vector<int>& ranges) {
FILE: nim_game.cpp
class Solution (line 7) | class Solution {
method canWinNim (line 9) | bool canWinNim(int n) {
method canWinNim (line 25) | bool canWinNim(int n) {
class Solution (line 23) | class Solution {
method canWinNim (line 9) | bool canWinNim(int n) {
method canWinNim (line 25) | bool canWinNim(int n) {
FILE: nth_catlan_number.cpp
function nCatlan (line 5) | int nCatlan(int n) {
function binomial (line 19) | int binomial(int n,int r){
function catlan (line 30) | int catlan(int n){
function main (line 37) | int main(){
FILE: num_products.cpp
function divisors (line 6) | void divisors() {
function main (line 18) | int main() {
FILE: number_of_permutations_such_that_no_three_forms_increasing_sequence.cpp
function binomial (line 7) | int binomial(int n,int r){
function catlan (line 18) | int catlan(int n){
function main (line 25) | int main(){
FILE: number_of_valid_parenthesis.cpp
function binomial (line 7) | int binomial(int n,int r){
function catlan (line 18) | int catlan(int n){
function main (line 25) | int main(){
FILE: spoj/ABA12C - Buying Apples!.cpp
function main (line 6) | signed main(){
FILE: spoj/ACODE - Alphacode.cpp
function main (line 34) | signed main()
FILE: spoj/AIBOHP - Aibohphobia.cpp
function main (line 5) | signed main(){
FILE: spoj/ANARC09A - Seinfeld.cpp
function main (line 6) | signed main(){
FILE: unique_paths_1.cpp
class Solution (line 6) | class Solution {
method uniquePaths (line 8) | int uniquePaths(int m, int n) {
FILE: unique_paths_2.cpp
class Solution (line 6) | class Solution {
method uniquePathsWithObstacles (line 8) | int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
FILE: video_stiching.cpp
class Solution (line 6) | class Solution {
method videoStitching (line 8) | int videoStitching(vector<vector<int>>& clips, int T) {
FILE: zerosAndOnes.cpp
class Solution (line 5) | class Solution {
method Solution (line 7) | Solution(){}
method findMaxForm (line 8) | int findMaxForm(vector<string>& strs, int m, int n) {
function main (line 31) | int main(){
Condensed preview — 92 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (78K chars).
[
{
"path": ".gitignore",
"chars": 5,
"preview": "a.out"
},
{
"path": "3_segment.cpp",
"chars": 953,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// question link\n// https://codeforces.com/problemset/problem/987/C\n\n\nint "
},
{
"path": "Best_Time_To_Buy_And_Sell_Stock_.cpp",
"chars": 577,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n//A very beautiful problem with a tweak of Kadane's algorithm.\n\nint best_t"
},
{
"path": "BitonicSequence.cpp",
"chars": 919,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint main() {\n int t;\n cin>>t;\n while(t--) {\n int n;\n "
},
{
"path": "Box_Stacking_Problem.cpp",
"chars": 1381,
"preview": "#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, B"
},
{
"path": "Circular_Kadene.cpp",
"chars": 639,
"preview": "// A very beautiful explalation given in leetcode\n// https://leetcode.com/problems/maximum-sum-circular-subarray/discuss"
},
{
"path": "Coin_Changing_1.cpp",
"chars": 797,
"preview": "#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 "
},
{
"path": "Coin_Changing_2.cpp",
"chars": 687,
"preview": "#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"
},
{
"path": "Count_All_Increasing_Subsequences.cpp",
"chars": 931,
"preview": "#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"
},
{
"path": "Count_All_Pallindromic_Subsequence.cpp",
"chars": 562,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint CountLPS(string s){\n int n = s.length();\n int dp[n][n];\n mems"
},
{
"path": "Count_Distinct_Subsequences.cpp",
"chars": 464,
"preview": "#include<bits/stdc++.h>\n#define MAX_CHAR 256\nusing namespace std;\nint CDS(string s,int size){\n vector<int>last_char(M"
},
{
"path": "Count_Number_of_hops.cpp",
"chars": 299,
"preview": "#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"
},
{
"path": "Count_Pallindromic_SubString_Of_String_gfg.cpp",
"chars": 679,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint expandAroundCenter(string s,int left,int right){\n if(s.length()==0 "
},
{
"path": "Count_Subsets_of_given_Sum.cpp",
"chars": 765,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint CountSubsets(int a[],int size,int sum) {\n int dp[size+1][sum+1];\n "
},
{
"path": "Count_ways_to_N'th_Stair.cpp",
"chars": 172,
"preview": "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(in"
},
{
"path": "Diameter_Of_Binary_Tree.cpp",
"chars": 368,
"preview": "//Function Written only\nint helper(Node* node,int &res){\n if(node==NULL) return 0;\n int left=helper(node->left,res"
},
{
"path": "Distinct_Occurences.cpp",
"chars": 901,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Count_All_Distinct_Occurences(string s1,string s2){\n int n=s1.lengt"
},
{
"path": "Edit_Distance.cpp",
"chars": 777,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Edit_Distance(string s1,string s2){\n int m = s1.length();\n int n"
},
{
"path": "Equal_Sum_Partition.cpp",
"chars": 755,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nbool EqualSubsetSum(int a[],int size) {\n int sum=0;\n for(int i=0;i<s"
},
{
"path": "Friends_Pairing_Problem.cpp",
"chars": 345,
"preview": "#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 "
},
{
"path": "Get_Minimum_Squares.cpp",
"chars": 558,
"preview": "#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 "
},
{
"path": "GoldMine_Problem.cpp",
"chars": 835,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint main(){\n int t;\n cin>>t;\n while(t--){\n int m,n;\n "
},
{
"path": "Jump_Game_3.cpp",
"chars": 642,
"preview": "class Solution {\npublic:\n bool canReach(vector<int>& arr, int start) {\n int N = arr.size();\n vector<int"
},
{
"path": "Jump_Game_5.cpp",
"chars": 619,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n//LEETCODE QUESTION\n\nint dp[1001];\nint helper(vector<int>& arr,int d,int i)"
},
{
"path": "Kadane.cpp",
"chars": 370,
"preview": "#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(i"
},
{
"path": "Knapsack_0_1.cpp",
"chars": 675,
"preview": "#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 "
},
{
"path": "Last_Stone_3.cpp",
"chars": 1633,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n//Leetcode Question\n\n//Recurssion base soln\nint helper(vector<int>& s,int i"
},
{
"path": "Longest_Common_Subsequence.cpp",
"chars": 685,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint Lcs(string s1,string s2){\n int m = s1.length(),n = s2.length();\n "
},
{
"path": "Longest_Common_Substring.cpp",
"chars": 612,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint LCSub(string s1,string s2){\n int m = s1.length(),n = s2.length();\n "
},
{
"path": "Longest_Consequetive_Subsequence.cpp",
"chars": 463,
"preview": "#include<iostream>\nusing namespace std;\nint main()\n {\n int t;\n cin>>t;\n while(t--){\n int n;\n "
},
{
"path": "Longest_Decreasing_Subsequence.cpp",
"chars": 482,
"preview": "#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<siz"
},
{
"path": "Longest_Increasing_Subsequence.cpp",
"chars": 502,
"preview": "#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<siz"
},
{
"path": "Longest_Pallindromic_Subsequence.cpp",
"chars": 763,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n//used bottom-up aproach(but similar to lcs)\nint longestPalindromeSubseq(s"
},
{
"path": "Longest_Pallindromic_Substring.cpp",
"chars": 735,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint expandAroundCenter(string s,int left,int right){\n if(s.length()==0 "
},
{
"path": "Longest_Repeating_Subsequence.cpp",
"chars": 541,
"preview": "#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(i"
},
{
"path": "Matrix_Chain_Multiplication.cpp",
"chars": 475,
"preview": "#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("
},
{
"path": "Max_Path_Sum_in_Triangle.cpp",
"chars": 453,
"preview": "#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>="
},
{
"path": "Max_path_sum.cpp",
"chars": 672,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nvector<int>v(100,0);\nvector<int>dp(100,0);\nvector<int>adj[100];\nint largest"
},
{
"path": "Maximize_the_cutting.cpp",
"chars": 635,
"preview": "#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 "
},
{
"path": "Maximum_Dot_Product_Subsequence.cpp",
"chars": 1454,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n\nint maxDotProduct(vector<int>& A, vector<int>& B,int size1,int size2) {\n "
},
{
"path": "Maximum_Path_Sum_in_Binary_tree.cpp",
"chars": 464,
"preview": "//Only function Written\nclass Solution {\n int maxToRoot(TreeNode *root, int &re) {\n if (!root) return 0;\n "
},
{
"path": "Maximum_Product_Increasing_Subsequence.cpp",
"chars": 581,
"preview": "#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"
},
{
"path": "Maximum_Size_Submatrix_Square.cpp",
"chars": 950,
"preview": "#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"
},
{
"path": "Maximum_Sum_Decreasing_Subsequence.cpp",
"chars": 603,
"preview": "#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"
},
{
"path": "Maximum_Sum_Dividing_Recurssive.cpp",
"chars": 270,
"preview": "#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"
},
{
"path": "Maximum_Sum_Increasing_Subsequence.cpp",
"chars": 580,
"preview": "#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"
},
{
"path": "Maximum_length_of_pairs.cpp",
"chars": 493,
"preview": "int findLongestChain(vector<vector<int>>& pairs) {\n int n=pairs.size();\n int dp[n+1],res=1;\n sort(p"
},
{
"path": "Minimum_Ascii_Sum_deletion_To_Make_two_Strings_equal.cpp",
"chars": 1003,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint minimumDeleteSum(string s1, string s2) {\n int m=s1.length(),n=s2"
},
{
"path": "Minimum_Initial_Points_To_Reach_Destinaion.cpp",
"chars": 613,
"preview": "#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 problem"
},
{
"path": "Minimum_Jumps_To_Reach_End.cpp",
"chars": 895,
"preview": "#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;"
},
{
"path": "Minimum_Subset_Sum_Difference.cpp",
"chars": 842,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint Minm_SubsetSum_Diff(int a[],int size){\n int sum = 0;\n for(int i=0"
},
{
"path": "Minm_Cost_To_Fill_Bag.cpp",
"chars": 1263,
"preview": "//A very very good variation of Unbounded Knapsack.#include<iostream>\n#include<bits/stdc++.h>\n#define INF 1000000\nusing "
},
{
"path": "Minm_Deletion_To_Make_Pallindrome.cpp",
"chars": 632,
"preview": "#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];"
},
{
"path": "Minm_Insertion_Deletion_Convert.cpp",
"chars": 719,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Idconvert(string s1,string s2){\n int m = s1.length(),n=s2.length(),"
},
{
"path": "No_Of_Ways_To_Tile.cpp",
"chars": 324,
"preview": "#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 l"
},
{
"path": "Number_of_ways_to_decode_a_string.cpp",
"chars": 494,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// similar to fibonacci\nint countWays(string s){\n int n = s.length();\n "
},
{
"path": "Optimal_Strategy_To_Play_A_Game.cpp",
"chars": 589,
"preview": "#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 "
},
{
"path": "Path_In_A_Matrix.cpp",
"chars": 804,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nint cost[1000][1000];\nvoid solve(int n,int cost[][1000]){\n int dp[n][n];"
},
{
"path": "Print_Longest_Common_Subsequence.cpp",
"chars": 887,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nstring PrintLcs(string s1,string s2){\n int m = s1.length(),n = s2.length"
},
{
"path": "Procuct_of_array_except_self.cpp",
"chars": 886,
"preview": "https://leetcode.com/explore/featured/card/30-day-leetcoding-challenge/530/week-3/3300/\n\nclass Solution {\npublic:\n ve"
},
{
"path": "README.md",
"chars": 5881,
"preview": "# Dynamic-Programming\nA DP a day keeps the bug away.\n\n**Cointains Dp Problems**<br><br>\n\n**Parent Problem** : [*Kadane's"
},
{
"path": "Reach_a_given_score.cpp",
"chars": 396,
"preview": "#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;"
},
{
"path": "Rod_Cutting.cpp",
"chars": 818,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint rodCutting(int cost[],int len[],int size) {\n int dp[size+1][size+1]"
},
{
"path": "Russian_Doll_Envelope.cpp",
"chars": 601,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// Problem Statement : https://leetcode.com/problems/russian-doll-envelope"
},
{
"path": "Shortest_Common_Supersequence.cpp",
"chars": 612,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint Scs(string s1,string s2){\n int m = s1.length(),n=s2.length(),lcs;\n "
},
{
"path": "SubsetSum.cpp",
"chars": 666,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\nbool SubsetSum(int a[],int size,int sum) {\n bool dp[size+1][sum+1];\n "
},
{
"path": "Tiling_Problem.cpp",
"chars": 448,
"preview": "#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 "
},
{
"path": "Unbounded_Knapsack.cpp",
"chars": 798,
"preview": "#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 "
},
{
"path": "Uncrossed_Lines.cpp",
"chars": 651,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\nint maxUncrossedLines(vector<int>& A, vector<int>& B,int n,int m) {\n ve"
},
{
"path": "count_submatrices_with_all_ones.cpp",
"chars": 802,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/count-square-submatrices-with-a"
},
{
"path": "count_subsets_of_given_difference.cpp",
"chars": 1052,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// given an array a difference of subset.find the count of that difference"
},
{
"path": "flip_game_1.cpp",
"chars": 510,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.lintcode.com/problem/flip-game/\n\nclass Solution {"
},
{
"path": "flip_game_2.cpp",
"chars": 879,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.lintcode.com/problem/flip-game-ii/\n// very good q"
},
{
"path": "jump_game_2..cpp",
"chars": 486,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/jump-game-ii/\n// dp+greedy(rang"
},
{
"path": "longest_alternating_subsequence.cpp",
"chars": 1942,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/wiggle-subsequence\n\n// O(n^2) "
},
{
"path": "maximal_square.cpp",
"chars": 1054,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/maximal-square/\n\nclass Solution"
},
{
"path": "maximum_product_subarray.cpp",
"chars": 559,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/maximum-product-subarray/\n\nclas"
},
{
"path": "maximum_sum_submatrix.cpp",
"chars": 731,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://www.interviewbit.com/problems/maximum-sum-square-subm"
},
{
"path": "minm_number_of_taps_to_open_water.cpp",
"chars": 642,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/minimum-number-of-taps-to-open"
},
{
"path": "nim_game.cpp",
"chars": 544,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/nim-game\n\n// n > 10^9 won't w"
},
{
"path": "nth_catlan_number.cpp",
"chars": 727,
"preview": "#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]"
},
{
"path": "num_products.cpp",
"chars": 866,
"preview": "// https://codeforces.com/problemset/problem/1215/B\n\n#include<bits/stdc++.h>\nusing namespace std;\nvector<int>d[2005];\nvo"
},
{
"path": "number_of_permutations_such_that_no_three_forms_increasing_sequence.cpp",
"chars": 474,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// O(n) approach using binomial coefficient\n\n// binomial coefficent\nint bi"
},
{
"path": "number_of_valid_parenthesis.cpp",
"chars": 503,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// O(n) approach using binomial coefficient\n\n// binomial coefficent\nint bi"
},
{
"path": "spoj/ABA12C - Buying Apples!.cpp",
"chars": 668,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define int long long int \n\nsigned main(){\n int t;cin >> t;\n while("
},
{
"path": "spoj/ACODE - Alphacode.cpp",
"chars": 989,
"preview": "/*\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"
},
{
"path": "spoj/AIBOHP - Aibohphobia.cpp",
"chars": 596,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n#define int long long int\nint dp[6103][6103];\nsigned main(){\n int t; ci"
},
{
"path": "spoj/ANARC09A - Seinfeld.cpp",
"chars": 578,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define int long long int\n\nsigned main(){\n \n for ( int t =1; ; t++)"
},
{
"path": "unique_paths_1.cpp",
"chars": 388,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem: https://leetcode.com/problems/unique-paths/\n\nclass Solution {\n"
},
{
"path": "unique_paths_2.cpp",
"chars": 1032,
"preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n// problem : https://leetcode.com/problems/unique-paths-ii\n\nclass Solution"
},
{
"path": "video_stiching.cpp",
"chars": 626,
"preview": "#include <bits/stdc++.h>\nusing namespace std;\n\n// problem: https://leetcode.com/problems/video-stitching/\n\nclass Solutio"
},
{
"path": "zerosAndOnes.cpp",
"chars": 1232,
"preview": "\n// link https://leetcode.com/problems/ones-and-zeroes/\n#include<bits/stdc++.h>\nusing namespace std;\nclass Solution {\n "
}
]
About this extraction
This page contains the full source code of the skm2000/Dynamic-Programming GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 92 files (67.8 KB), approximately 24.4k tokens, and a symbol index with 188 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.