├── README.md
├── code(A - Frog 1).cpp
├── code(B - Frog 2).cpp
├── code(C - Vacation).cpp
├── code(D - Knapsack 1).cpp
├── code(E - Knapsack 2).cpp
├── code(F - LCS).cpp
├── code(H - Grid 1).cpp
├── code(I - Coins)_EasyApproach.cpp
├── code(I - Coins)_HardApproach.cpp
├── code(J - Sushi).cpp
├── code(K - Stones).cpp
├── code(L - Deque).cpp
├── code(M - Candies).cpp
├── code(N - Slimes).cpp
├── code(O - Matching).cpp
└── code(S - Digit Sum).cpp


/README.md:
--------------------------------------------------------------------------------
 1 | I am Listing below the concepts I have used whilst solving the questions.
 2 | 
 3 | | <h3>PROBLEMS</h3>  | <h3>CONCEPTS USED</h3> |
 4 | | ------------- | ------------- |
 5 | | Frog 1 | Classical DP Approach, Bottom Up DP  |
 6 | | Frog 2  | Classical DP Approach, Bottom Up DP  |
 7 | | Vacation  |  Bottom Up DP  |
 8 | | Knapsack 1 | Classical DP Approach, Top Down DP  |
 9 | | Knapsack 2  | Classical DP (with a twist), Bottom Up DP  |
10 | | LCS  | Top Down DP Approach  |
11 | | Longest Path  |   |
12 | | Grid 1  | Grid DP, Bottom Up DP  |
13 | | Coins  | Probability DP, Bottom Up DP(Hard), Top Down DP(Easy)  |
14 | | Sushi  | Expected Value DP, Mathematics  |
15 | | Stones  | Game Theory and DP  |
16 | | Deque  | Game Theory and Multi-dimensional DP  |
17 | | Candies  | Multidimensional DP optimisation |
18 | | Slimes  | DP over intervals  |
19 | | Matching  | DP + Bitmasking  |
20 | | Independent Set |   |
21 | | Flowers  |   |
22 | | Walk  ||
23 | | Digit Sum  | Digit DP  |
24 | 


--------------------------------------------------------------------------------
/code(A - Frog 1).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 |     fast_io;
14 |     
15 |     ll n;
16 |     cin>>n;
17 |     vector<ll> h(n+1);
18 | 
19 |     for(ll i=0;i<n;i++)
20 |     cin>>h[i];
21 |     vector<ll> dp(n+1);
22 | 
23 |     //base case
24 |     dp[0] = 0;
25 |     dp[1] = h[1] - h[0];
26 | 
27 |     //BU
28 |     for(ll i=2;i<n;i++)
29 |     {
30 |         ll op1 = dp[i-1] + abs(h[i]-h[i-1]);
31 |         ll op2 = dp[i-2] + abs(h[i]-h[i-2]);
32 |         dp[i] = min(op1,op2);
33 |     }
34 |     cout<< dp[n-1] <<endl;
35 | 
36 |     return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/code(B - Frog 2).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 |     fast_io;
14 | 
15 |     ll n,k;
16 |     cin>>n>>k;
17 | 
18 |     vector<ll> h(n+1);
19 | 
20 |     for(ll i=0;i<n;i++)
21 |     cin>>h[i];
22 |     vector<ll> dp(n+1);
23 | 
24 |     //base case
25 |     dp[0] = 0;
26 | 
27 |     for(ll i=1;i<n;i++)
28 |     {
29 |         dp[i] = INT_MAX;
30 |         for(ll j=i-1;j>=0 && (i-j)<=k;j--)
31 |         {
32 |             dp[i] = min(dp[i], abs(h[j] - h[i]) + dp[j]);
33 |         }
34 |     }
35 |     cout<<dp[n-1]<<endl;
36 |     
37 | return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/code(C - Vacation).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
 9 | using namespace std; 
10 | 
11 | struct act
12 | {
13 |     ll a,b,c;
14 | };
15 | 
16 | int main()
17 | {
18 |     fast_io;
19 | 
20 |     ll n;
21 |     cin>>n;
22 |     vector<act> v(n+1);
23 | 
24 |     for(ll i=1;i<=n;i++)
25 |     {
26 |         cin>>v[i].a;
27 |         cin>>v[i].b;
28 |         cin>>v[i].c;
29 |     }
30 | 
31 |     ll dp[n+1][3];
32 |     //Base case
33 |     dp[1][0] = v[1].a;
34 |     dp[1][1] = v[1].b;
35 |     dp[1][2] = v[1].c;
36 | 
37 |     //BU
38 |     for(ll i=2;i<=n;i++)
39 |     {
40 |         dp[i][0] = v[i].a + max(dp[i-1][1], dp[i-1][2]);
41 |         dp[i][1] = v[i].b + max(dp[i-1][0], dp[i-1][2]);
42 |         dp[i][2] = v[i].c + max(dp[i-1][0], dp[i-1][1]);
43 |     }
44 | 
45 |     cout<< max(dp[n][0], max(dp[n][1], dp[n][2])) <<endl;
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/code(D - Knapsack 1).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | //ll dp[101];
13 | ll dp[101][100005];
14 | /*struct ks
15 | {
16 |     ll weight,value;
17 | };*/
18 | 
19 | ll fun(ll w, ll n, ll weight[], ll value[])
20 | {
21 |     
22 |     //Base case
23 |     if(n==0)
24 |     return 0;
25 |     if(w <= 0)
26 |     return 0;
27 | 
28 |     //Lookup
29 |     if(dp[n][w] != -1)
30 |     return dp[n][w];
31 | 
32 |     //Rec case
33 |     ll op1 = (w-weight[n] >= 0) ? (value[n] + fun(w-weight[n], n-1,weight, value)) : INT_MIN;
34 |     ll op2 = fun(w, n-1,weight,value);
35 | 
36 |     return dp[n][w] = max(op1, op2); 
37 | }
38 | 
39 | int main()
40 | {
41 |     fast_io;
42 | 
43 |     ll n,w;
44 |     cin>>n>>w;
45 |     //vector<ks> ar;
46 |     ll weight[n+1],value[n+1];
47 | 
48 |     for(ll i=1;i<=n;i++)
49 |     cin>>weight[i]>>value[i];
50 | 
51 |     memset(dp,-1,sizeof(dp));
52 |     cout<<fun(w,n,weight,value)<<endl;
53 | 
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/code(E - Knapsack 2).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 |     ll n,w;
15 |     cin>>n>>w;
16 | 
17 |     vector<ll> weight(n),value(n);
18 |     for(ll i=0;i<n;i++)
19 |     cin>>weight[i]>>value[i];
20 | 
21 |     ll max_val = 0;
22 |     for(ll&x : value)
23 |     max_val += x;
24 | 
25 |     vector<ll> dp(max_val+1,INT_MAX);
26 |     dp[0] = 0;
27 | 
28 |     for(ll i=0;i<n;i++)
29 |     {
30 |         for(ll j=max_val-value[i];j>=0;j--)
31 |         {
32 |             dp[j+value[i]] = min(dp[j+value[i]], dp[j]+weight[i]);
33 |         }
34 |     }
35 |     ll ans = INT_MIN;
36 |     for(ll i=0;i<=max_val;i++)
37 |     {
38 |         if(dp[i] <= w)
39 |         ans = max(ans, i);
40 |     }
41 | 
42 |     cout<<ans<<endl;
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/code(F - LCS).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h> 
 3 | #define ll long long
 4 | #define ull unsigned long long
 5 | #define endl '\n'
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
 9 | using namespace std;
10 | 
11 | const ll v = 3001;
12 | ll dp[v][v];
13 | 
14 | ll length(string& s,string& t,ll i,ll j)
15 | {
16 |    // memset(dp,-1,sizeof(dp));
17 |     //Base case
18 |     if(i>=s.size() || j>=t.size())
19 |     return 0;
20 | 
21 |     //Lookup
22 |     if(dp[i][j] != -1)
23 |     return dp[i][j];
24 | 
25 |     //Rec case
26 |     if(s[i] == t[j])
27 |     return dp[i][j] = 1 + length(s,t,i+1,j+1);
28 | 
29 |     else
30 |     return dp[i][j] = max(length(s,t,i+1,j), length(s,t,i,j+1));
31 | }
32 | 
33 | int main()
34 | {
35 |    fast_io;
36 |     string s,t;
37 |     cin>>s>>t;
38 |      memset(dp,-1,sizeof(dp));
39 | 
40 |     //cout<<length(s,t,0,0)<<endl;
41 |   ll len = length(s,t,0,0);
42 |   ll i=0,j=0;
43 | 
44 |    string ans = " ";
45 |    while(len)
46 |    {
47 |        if(s[i] == t[j])
48 |        {
49 |            ans.pb(s[i]);
50 |            i++;
51 |            j++;
52 |            len--;
53 |        }
54 |        else
55 |        {
56 |            if(dp[i][j+1] > dp[i+1][j])
57 |            j++;
58 |            else
59 |            i++;
60 |        }
61 |    }
62 |    cout<<ans<<endl;
63 |    return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/code(H - Grid 1).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 |     fast_io;
15 |     ll ro,co;
16 |     cin>>ro>>co;
17 |     ll mod = 1e9+7;
18 | 
19 |     vector< vector<ll>> dp(ro+1, vector<ll> (co+1,0));
20 |     dp[0][0] = 1;
21 | 
22 |     for(ll i=0;i<ro;i++)
23 |     {
24 |         string s;
25 |         cin>>s;
26 |         for(ll j=0;j<co;j++)
27 |         {
28 |             if(s[j] == '.')
29 |             {
30 |                 if(i>0)
31 |                 {
32 |                     dp[i][j] += dp[i-1][j];
33 |                     dp[i][j] %= mod;
34 |                 }
35 |                 if(j>0)
36 |                 {
37 |                     dp[i][j] += dp[i][j-1];
38 |                     dp[i][j] %= mod;
39 |                 }
40 |             }
41 |             else
42 |             dp[i][j] = 0;
43 | 
44 |         }
45 |     }
46 |     cout<<dp[ro-1][co-1]<<endl;
47 | 
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/code(I - Coins)_EasyApproach.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define sp(x) fixed<<setprecision(x)
10 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
11 | using namespace std;
12 | 
13 | //vector<vector<double>> dp(3001,vector<double>(3001,-1));
14 | double dp[3001][3001];
15 | double fun(vector<double> &p, int i, int atleast_heads)
16 | {
17 |     //Base case
18 |     if(atleast_heads == 0)
19 |     return 1;
20 | 
21 |     if(i == 0)
22 |     return 0;
23 | 
24 |     //Lookup
25 |     if(dp[i][atleast_heads] > -0.9)
26 |     return dp[i][atleast_heads];
27 | 
28 |     //Rec case
29 |     //double op1 = p[i]*fun(p,i-1,atleast_heads-1);
30 |     //double op2 = (1-p[i])*fun(p,i-1,atleast_heads);
31 |     return dp[i][atleast_heads] = p[i]*fun(p,i-1,atleast_heads-1) + (1-p[i])*fun(p,i-1,atleast_heads);
32 | }
33 | 
34 | int main()
35 | {
36 |     fast_io;
37 | 
38 |     memset(dp,-1,sizeof(dp));
39 |     int n;
40 |     cin>>n;
41 |     vector<double> p(n+1);
42 | 
43 |     for(int i=1;i<=n;i++)
44 |     cin>>p[i];
45 | 
46 |     cout<<sp(10)<<fun(p,n,(n+1)/2)<<endl;
47 | 
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/code(I - Coins)_HardApproach.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define sp(x) fixed<<setprecision(x)
10 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 |     fast_io;
16 |     
17 |     int n;
18 |     cin>>n;
19 |     double p;
20 |     double ans=0;
21 |     
22 |     vector<double> dp(n+1);
23 |     dp[0] = 1;
24 |     
25 |     for(int coins=0;coins<n;coins++)
26 |     {
27 |         cin>>p;
28 |         for(int i=coins+1;i>=0;i--)
29 |         {
30 |            // double s = (i==0) ? 0 : p*dp[i-1];
31 |             dp[i] = (i==0 ? 0 : p*dp[i-1] )+ dp[i]*(1-p);
32 |         }
33 |     }
34 |     
35 |     for(int heads=0;heads<=n;heads++)
36 |     {
37 |         int tails = n-heads;
38 |         if(heads > tails)
39 |         ans += dp[heads];
40 |     }
41 |     cout<<sp(10)<<ans<<endl;
42 |     
43 |     return 0;
44 |     
45 | }
46 | 


--------------------------------------------------------------------------------
/code(J - Sushi).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h> 
 3 | #define ll long long
 4 | #define ull unsigned long long
 5 | #define endl '\n'
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define sp(x) fixed<<setprecision(x)
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | double dp[301][301][301];
13 | 
14 | 
15 | double fun(int& n, int x, int y, int z)
16 | {
17 |     //Base case
18 |     if(x==0 && y==0 && z==0)
19 |     return 0;
20 |     if(x<0 || y<0 || z<0)
21 |     return 0;
22 | 
23 |     //Lookup
24 |     if(dp[x][y][z] > -0.9)
25 |     return dp[x][y][z];
26 | 
27 |     //Rec case
28 |     double ans = n + (x*fun(n,x-1,y,z)) + (y*fun(n,x+1,y-1,z)) + (z*fun(n,x,y+1,z-1));
29 |     return dp[x][y][z] = ans/(x+y+z);
30 | }
31 | 
32 | int main()
33 | {
34 |     fast_io;
35 |     
36 |     memset(dp,-1,sizeof(dp));
37 |     int n,j;
38 |     cin>>n;
39 | 
40 |     int o=0,tw=0,th=0;
41 | 
42 |     for(int i=0;i<n;i++)
43 |     {
44 |         cin>>j;
45 |         if(j == 1)
46 |         o++;
47 |         else if(j == 2)
48 |         tw++;
49 |         else
50 |         th++;
51 |     }
52 |     cout<<sp(10)<<fun(n,o,tw,th)<<endl;
53 | 
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/code(K - Stones).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h> 
 3 | #define ll long long
 4 | #define ull unsigned long long
 5 | #define endl '\n'
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define sp(x) fixed<<setprecision(x)
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 |     fast_io;
15 |     
16 |     int n,k;
17 |     cin>>n>>k;
18 |     
19 |     vector<int> v(n);
20 |     for(int& i : v)
21 |     cin>>i;
22 |     
23 |     vector<bool> dp(k+1,0);
24 |     for(int i=0;i<=k;i++)
25 |     {
26 |         for(int move : v)
27 |         {
28 |             if(i-move>=0 && dp[i-move]==0)
29 |             dp[i] = 1;
30 |         }
31 |     }
32 |     
33 |     (dp[k]>0) ? cout<<"First" : cout<<"Second";
34 |     
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/code(L - Deque).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define sp(x) fixed<<setprecision(x)
10 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
11 | #define s 3003
12 | using namespace std;
13 | 
14 | ll dp[s][s];
15 | 
16 | ll solve(vector<ll>& a, ll i, ll j)
17 | {
18 |     //Base case
19 |     if(i > j)
20 |     return 0;
21 |     
22 |     //Lookup
23 |     if(dp[i][j] != -1)
24 |     return dp[i][j];
25 |     
26 |     //Rec Case
27 |     ll op1 = a[i] + min( solve(a,i+1,j-1), solve(a,i+2,j));
28 |     ll op2 = a[j] + min( solve(a,i+1,j-1), solve(a,i,j-2));
29 |     
30 |     return dp[i][j] = max(op1,op2);
31 | }
32 | 
33 | int main()
34 | {
35 |     fast_io;
36 |     
37 |     ll n;
38 |     cin>>n;
39 |     vector<ll> a(n+1);
40 |     
41 |     for(int i=0;i<n;i++)
42 |     cin>>a[i];
43 |     
44 |     memset(dp,-1,sizeof(dp));
45 |     ll X = solve(a,0,n-1);
46 |     
47 |     ll sum = 0;
48 |     for(ll j=0;j<a.size();j++)
49 |     sum += a[j];
50 |     
51 |     ll Y = sum - X;
52 |     cout<<X-Y<<endl;
53 |     
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/code(M - Candies).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h> 
 3 | #define ll long long
 4 | #define ull unsigned long long
 5 | #define endl '\n'
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define sp(x) fixed<<setprecision(x)
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | using namespace std;
11 | 
12 | ll mod = 1e9 + 7;
13 | ll dp[102][100005];
14 | 
15 | int fun(vector<ll>& a, ll n, ll k)
16 | {
17 |     //Base case
18 |     for(ll j=0;j<=k;j++)
19 |     dp[1][j] = (j > a[1]) ? 0 : 1;
20 | 
21 |     //BU
22 |     for(ll i=2;i<=n;i++)
23 |     {
24 |         for(ll j=0;j<=k;j++)
25 |         {
26 |             if(j == 0)
27 |             {
28 |                 dp[i][j] = dp[i-1][j];
29 |                 dp[i][j] = (mod + dp[i][j])%mod;
30 |             }
31 |             else
32 |             {
33 |                 dp[i][j] = dp[i-1][j] + dp[i][j-1] - ( (j-1-a[i] >= 0) ? dp[i-1][j-1-a[i]] : 0);
34 |                 dp[i][j] = (mod + dp[i][j])%mod;
35 |             }
36 |         }
37 |     }
38 |     return dp[n][k];
39 | }
40 | 
41 | int main()
42 | {
43 |     fast_io;
44 | 
45 |     ll n,k;
46 |     cin>>n>>k;
47 | 
48 |     vector<ll> a(n+1);
49 |     for(ll i=1;i<=n;i++)
50 |     cin>>a[i];
51 | 
52 |     cout<<fun(a,n,k)<<endl;
53 | 
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/code(N - Slimes).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h> 
 3 | #define ll long long
 4 | #define ull unsigned long long
 5 | #define endl '\n'
 6 | #define pb push_back
 7 | #define mp make_pair
 8 | #define sp(x) fixed<<setprecision(x)
 9 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
10 | 
11 | #define infinity 1e18
12 | using namespace std;
13 | 
14 | ll dp[401][401];
15 | ll s[401];
16 | 
17 | ll sum(ll i, ll j)
18 | {
19 |     if(i == 0)
20 |     return s[j];
21 |     
22 |     return (s[j] - s[i-1]);
23 | }
24 | 
25 | ll fun(ll i, ll j)
26 | {
27 |     //Base Case
28 |     if(i == j)
29 |     return 0;
30 |     if(i > j)
31 |     return 0;
32 |     
33 |     //Lookup
34 |     if(dp[i][j] != -1)
35 |     return dp[i][j];
36 |     
37 |     //Rec Case
38 |     ll ans = infinity;
39 |     for(ll k=i;k<j;k++)
40 |     {
41 |         ans = min(ans, fun(i,k)+fun(k+1,j)+sum(i,j));
42 |     }
43 |     
44 |     return dp[i][j] = ans;
45 | }
46 | 
47 | int main()
48 | {
49 |     fast_io;
50 |     
51 |     ll n;
52 |     cin>>n;
53 |     for(ll i=0;i<n;i++)
54 |     cin>>s[i];
55 |     
56 |     for(ll i=1;i<n;i++)
57 |     {
58 |         s[i] += s[i-1];
59 |     }
60 |     memset(dp,-1,sizeof(dp));
61 |     
62 |     cout<<fun(0,n-1)<<endl;
63 |     
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/code(O - Matching).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define sp(x) fixed<<setprecision(x)
10 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
11 | using namespace std;
12 | ll mod = 1e9+7;
13 | ll dp[22][(1<<22)];
14 | 
15 | ll fun( vector< vector<ll>> &comp, ll N, ll i, ll woman_bit)
16 | {
17 |     //Base case
18 |     if(i == N+1)
19 |     {
20 |         if(woman_bit == 0)
21 |         return 1;
22 |         return 0;
23 |     }
24 |     
25 |     //Lookup
26 |     if(dp[i][woman_bit] != -1)
27 |     return dp[i][woman_bit];
28 |     
29 |     //Rec case
30 |     ll ans = 0;
31 |     for(ll w=0;w<N;w++)
32 |     {
33 |         bool is_avail = ( ((1<<w) & woman_bit) != 0) ? 1 : 0;
34 |         
35 |         if(is_avail && comp[i][w+1])
36 |         {
37 |             ans += fun( comp,N,i+1, (woman_bit ^ (1<<w)));
38 |             ans %= mod;
39 |         }
40 |     }
41 |     return dp[i][woman_bit] = ans;
42 | }
43 | 
44 | int main()
45 | {
46 |     fast_io;
47 |     
48 |     ll N;
49 |     cin>>N;
50 |     
51 |     vector< vector<ll>> comp(N+1, vector<ll>(N+1));
52 |    //int comp[22][22];
53 |     for(ll i=1;i<=N;i++)
54 |     {
55 |         for(ll j=1;j<=N;j++)
56 |         cin>>comp[i][j];
57 |     }
58 |     
59 |     memset(dp,-1,sizeof(dp));
60 |     cout<<fun(comp,N,1,(1<<N)-1)<<endl;
61 |     
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/code(S - Digit Sum).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <bits/stdc++.h> 
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define endl '\n'
 7 | #define pb push_back
 8 | #define mp make_pair
 9 | #define sp(x) fixed<<setprecision(x)
10 | #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
11 | using namespace std;
12 | 
13 | const ll mod = 1e9 + 7;
14 | //const int scope = 100005;
15 | char k[100005];
16 | 
17 | void add_store(int &a, int b)
18 | {
19 |     (a += b) %= mod;
20 |     
21 | }
22 | 
23 | int main()
24 | {
25 |     fast_io;
26 |     
27 |     int D;
28 |     cin>>k>>D;
29 |     int length = strlen(k);
30 |     
31 |     vector< vector<int>> dp (D, vector<int> (2));
32 |     dp[0][0] = 1;
33 |     
34 |     for(int pos=0;pos<length;pos++)
35 |     {
36 |         vector< vector<int>> dp1(D, vector<int>(2));
37 |         for(int sum=0;sum<D;sum++)
38 |         {
39 |             for( bool small : {false,true})
40 |             {
41 |                 for(int dig=0;dig<=9;dig++)
42 |                 {
43 |                     
44 |                     if(dig > pos[k]-'0' && small == false)
45 |                     break;
46 |                     
47 |                     add_store( dp1[(sum+dig)%D][small || dig < pos[k]-'0'], dp[sum][small]);
48 |                 }
49 |             }
50 |         }
51 |         dp = dp1;
52 |     }
53 |     
54 |     int ans = dp[0][true] + dp[0][false];
55 |     int res = (ans%mod)-1;
56 |     
57 |     //res =0 ? cout<<res : cout<<0;
58 |   //res == -1 ? cout<<mod-1 : cout<<res;
59 |     cout<<( mod + ans - 1)%mod;
60 |     cout<<endl;
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------