├── A.cpp
├── B.cpp
├── C.cpp
├── D.cpp
├── E.cpp
├── F.cpp
├── G.cpp
├── H.cpp
├── I.cpp
├── J_iterative.cpp
├── J_recursive.cpp
├── K.cpp
├── L.cpp
├── M.cpp
├── M_optimized_memory.cpp
├── README.md
└── S.cpp


/A.cpp:
--------------------------------------------------------------------------------
 1 | /* Priyansh Agarwal*/
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #include<ext/pb_ds/assoc_container.hpp>
 5 | #include<ext/pb_ds/tree_policy.hpp>
 6 | #include<algorithm>
 7 | #include<string.h>
 8 | #include<unordered_map>
 9 | #include<vector>
10 | #include<unordered_set>
11 | #include<set>
12 | #include<map>
13 | #include<queue>
14 | #include<stack>
15 | #include<map>
16 | #include<chrono>
17 | 
18 | using namespace std;
19 | using namespace __gnu_pbds;
20 | using namespace chrono;
21 | 
22 | #define debug(x) cout << #x << " " << x <<endl;
23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
24 | #define MOD 1000000007
25 | #define MOD1 998244353
26 | #define INF 1e18
27 | #define nline "\n"
28 | #define pb push_back
29 | #define ppb pop_back;
30 | #define mp make_pair
31 | #define ff first
32 | #define ss second
33 | #define PI 3.141592653589793238462
34 | #define set_bits __builtin_popcount
35 | #define sz(x) (int)(x.size())
36 | 
37 | typedef long long ll;
38 | typedef unsigned long long ull;
39 | typedef long double lld;
40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
41 | 
42 | /*---------------------------------------------------------------------------------------------------------------------------*/
43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
48 | bool revsort(ll a, ll b) {return a > b;}
49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
51 | void google(int t) {cout << "Case #" << t << ": ";}
52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
58 | /*--------------------------------------------------------------------------------------------------------------------------*/
59 | 
60 | void solve() {
61 | 	int n;
62 | 	cin >> n;
63 | 	int arr[n];
64 | 	for (int i = 0; i < n; i++)
65 | 		cin >> arr[i];
66 | 	int dp[n];
67 | 	dp[0] = 0;
68 | 	dp[1] = abs(arr[1] - arr[0]);
69 | 	for (int i = 2; i < n; i++) {
70 | 		dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]), dp[i - 2] + abs(arr[i] - arr[i - 2]));
71 | 	}
72 | 	cout << dp[n - 1] << "\n";
73 | 
74 | }
75 | int main() {
76 | 	fastio();
77 | #ifndef ONLINE_JUDGE
78 | 	freopen("Input.txt", "r", stdin);
79 | 	freopen("Output.txt", "w", stdout);
80 | 	freopen("Error.txt", "w", stderr);
81 | #endif
82 | 	auto start1 = high_resolution_clock::now();
83 | 	solve();
84 | 	auto stop1 = high_resolution_clock::now();
85 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
86 | #ifndef ONLINE_JUDGE
87 | 	cerr << "Time: " << duration.count() / 1000 << endl;
88 | #endif
89 | 	return 0;
90 | }


--------------------------------------------------------------------------------
/B.cpp:
--------------------------------------------------------------------------------
 1 | /* Priyansh Agarwal*/
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #include<ext/pb_ds/assoc_container.hpp>
 5 | #include<ext/pb_ds/tree_policy.hpp>
 6 | #include<algorithm>
 7 | #include<string.h>
 8 | #include<unordered_map>
 9 | #include<vector>
10 | #include<unordered_set>
11 | #include<set>
12 | #include<map>
13 | #include<queue>
14 | #include<stack>
15 | #include<map>
16 | #include<chrono>
17 | 
18 | using namespace std;
19 | using namespace __gnu_pbds;
20 | using namespace chrono;
21 | 
22 | #define debug(x) cout << #x << " " << x <<endl;
23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
24 | #define MOD 1000000007
25 | #define MOD1 998244353
26 | #define INF 1e18
27 | #define nline "\n"
28 | #define pb push_back
29 | #define ppb pop_back;
30 | #define mp make_pair
31 | #define ff first
32 | #define ss second
33 | #define PI 3.141592653589793238462
34 | #define set_bits __builtin_popcount
35 | #define sz(x) (int)(x.size())
36 | 
37 | typedef long long ll;
38 | typedef unsigned long long ull;
39 | typedef long double lld;
40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
41 | 
42 | /*---------------------------------------------------------------------------------------------------------------------------*/
43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
48 | bool revsort(ll a, ll b) {return a > b;}
49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
51 | void google(int t) {cout << "Case #" << t << ": ";}
52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
58 | /*--------------------------------------------------------------------------------------------------------------------------*/
59 | 
60 | void solve() {
61 | 	int n, k;
62 | 	cin >> n >> k;
63 | 	int arr[n];
64 | 	for (int i = 0; i < n; i++)
65 | 		cin >> arr[i];
66 | 	int dp[n];
67 | 	dp[0] = 0;
68 | 	for (int i = 1; i < n; i++) {
69 | 		dp[i] = dp[i - 1] + abs(arr[i] - arr[i - 1]);
70 | 		for (int j = i - 2; j >= max(i - k, 0); j--)
71 | 			dp[i] = min(dp[i], dp[j] + abs(arr[i] - arr[j]));
72 | 	}
73 | 	cout << dp[n - 1] << "\n";
74 | }
75 | int main() {
76 | 	fastio();
77 | #ifndef ONLINE_JUDGE
78 | 	freopen("Input.txt", "r", stdin);
79 | 	freopen("Output.txt", "w", stdout);
80 | 	freopen("Error.txt", "w", stderr);
81 | #endif
82 | 	auto start1 = high_resolution_clock::now();
83 | 	solve();
84 | 	auto stop1 = high_resolution_clock::now();
85 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
86 | #ifndef ONLINE_JUDGE
87 | 	cerr << "Time: " << duration.count() / 1000 << endl;
88 | #endif
89 | 	return 0;
90 | }


--------------------------------------------------------------------------------
/C.cpp:
--------------------------------------------------------------------------------
 1 | /* Priyansh Agarwal*/
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #include<ext/pb_ds/assoc_container.hpp>
 5 | #include<ext/pb_ds/tree_policy.hpp>
 6 | #include<algorithm>
 7 | #include<string.h>
 8 | #include<unordered_map>
 9 | #include<vector>
10 | #include<unordered_set>
11 | #include<set>
12 | #include<map>
13 | #include<queue>
14 | #include<stack>
15 | #include<map>
16 | #include<chrono>
17 | 
18 | using namespace std;
19 | using namespace __gnu_pbds;
20 | using namespace chrono;
21 | 
22 | #define debug(x) cout << #x << " " << x <<endl;
23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
24 | #define MOD 1000000007
25 | #define MOD1 998244353
26 | #define INF 1e18
27 | #define nline "\n"
28 | #define pb push_back
29 | #define ppb pop_back;
30 | #define mp make_pair
31 | #define ff first
32 | #define ss second
33 | #define PI 3.141592653589793238462
34 | #define set_bits __builtin_popcount
35 | #define sz(x) (int)(x.size())
36 | 
37 | typedef long long ll;
38 | typedef unsigned long long ull;
39 | typedef long double lld;
40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
41 | 
42 | /*---------------------------------------------------------------------------------------------------------------------------*/
43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
48 | bool revsort(ll a, ll b) {return a > b;}
49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
51 | void google(int t) {cout << "Case #" << t << ": ";}
52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
58 | /*--------------------------------------------------------------------------------------------------------------------------*/
59 | 
60 | void solve() {
61 | 	int n;
62 | 	cin >> n;
63 | 	vector<vector<int>> v1;
64 | 	for (int i = 0; i < n; i++) {
65 | 		int a, b, c;
66 | 		cin >> a >> b >> c;
67 | 		vector<int> values;
68 | 		values.pb(a);
69 | 		values.pb(b);
70 | 		values.pb(c);
71 | 		v1.pb(values);
72 | 	}
73 | 	int dp[n][3];
74 | 	dp[0][0] = v1[0][0];
75 | 	dp[0][1] = v1[0][1];
76 | 	dp[0][2] = v1[0][2];
77 | 	for (int i = 1; i < n; i++) {
78 | 		dp[i][0] = v1[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
79 | 		dp[i][1] = v1[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
80 | 		dp[i][2] = v1[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
81 | 	}
82 | 	cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << "\n";
83 | }
84 | int main() {
85 | 	fastio();
86 | #ifndef ONLINE_JUDGE
87 | 	freopen("Input.txt", "r", stdin);
88 | 	freopen("Output.txt", "w", stdout);
89 | 	freopen("Error.txt", "w", stderr);
90 | #endif
91 | 	auto start1 = high_resolution_clock::now();
92 | 	solve();
93 | 	auto stop1 = high_resolution_clock::now();
94 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
95 | #ifndef ONLINE_JUDGE
96 | 	cerr << "Time: " << duration.count() / 1000 << endl;
97 | #endif
98 | 	return 0;
99 | }


--------------------------------------------------------------------------------
/D.cpp:
--------------------------------------------------------------------------------
 1 | /* Priyansh Agarwal*/
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #include<ext/pb_ds/assoc_container.hpp>
 5 | #include<ext/pb_ds/tree_policy.hpp>
 6 | #include<algorithm>
 7 | #include<string.h>
 8 | #include<unordered_map>
 9 | #include<vector>
10 | #include<unordered_set>
11 | #include<set>
12 | #include<map>
13 | #include<queue>
14 | #include<stack>
15 | #include<map>
16 | #include<chrono>
17 | 
18 | using namespace std;
19 | using namespace __gnu_pbds;
20 | using namespace chrono;
21 | 
22 | #define debug(x) cout << #x << " " << x <<endl;
23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
24 | #define MOD 1000000007
25 | #define MOD1 998244353
26 | #define INF 1e18
27 | #define nline "\n"
28 | #define pb push_back
29 | #define ppb pop_back;
30 | #define mp make_pair
31 | #define ff first
32 | #define ss second
33 | #define PI 3.141592653589793238462
34 | #define set_bits __builtin_popcount
35 | #define sz(x) (int)(x.size())
36 | 
37 | typedef long long ll;
38 | typedef unsigned long long ull;
39 | typedef long double lld;
40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
41 | 
42 | /*---------------------------------------------------------------------------------------------------------------------------*/
43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
48 | bool revsort(ll a, ll b) {return a > b;}
49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
51 | void google(int t) {cout << "Case #" << t << ": ";}
52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
58 | /*--------------------------------------------------------------------------------------------------------------------------*/
59 | 
60 | void solve() {
61 | 	ll n, w;
62 | 	cin >> n >> w;
63 | 	pair<ll, ll> arr[n];
64 | 	for (int i = 0; i < n; i++) {
65 | 		cin >> arr[i].ff >> arr[i].ss;
66 | 	}
67 | 	ll dp[n + 1][w + 1];
68 | 	//remember it is better here to have n*w rather than w*n due to segmentatoin
69 | 	for (int i = 0; i <= w; i++)
70 | 		dp[0][i] = 0;
71 | 	for (int i = 1; i <= n; i++) {
72 | 		for (int j = 0; j <= w; j++) {
73 | 			dp[i][j] = dp[i - 1][j];
74 | 			if (j >= arr[i - 1].ff)
75 | 				dp[i][j] = max(dp[i][j], arr[i - 1].ss + dp[i - 1][j - arr[i - 1].ff]);
76 | 		}
77 | 	}
78 | 	cout << dp[n][w] << nline;
79 | }
80 | int main() {
81 | 	fastio();
82 | #ifndef ONLINE_JUDGE
83 | 	freopen("Input.txt", "r", stdin);
84 | 	freopen("Output.txt", "w", stdout);
85 | 	freopen("Error.txt", "w", stderr);
86 | #endif
87 | 	auto start1 = high_resolution_clock::now();
88 | 	solve();
89 | 	auto stop1 = high_resolution_clock::now();
90 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
91 | #ifndef ONLINE_JUDGE
92 | 	cerr << "Time: " << duration.count() / 1000 << endl;
93 | #endif
94 | 	return 0;
95 | }


--------------------------------------------------------------------------------
/E.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | void solve() {
 60 | 	ll n, w;
 61 | 	cin >> n >> w;
 62 | 	pair<ll, ll> arr[n];
 63 | 	ll p = 0;
 64 | 	for (int i = 0; i < n; i++) {
 65 | 		cin >> arr[i].ff >> arr[i].ss;
 66 | 		p = max(p, arr[i].ss);
 67 | 	}
 68 | 	ll max_value = p * n;
 69 | 	ll dp[n + 1][max_value + 1];
 70 | 
 71 | 	//remember it is better here to have n*max_value rather than max_value*n due to segmentatoin
 72 | 	for (int i = 0; i <= max_value; i++)
 73 | 		dp[0][i] = INF;
 74 | 	dp[0][0] = 0;
 75 | 	for (int i = 1; i <= n; i++) {
 76 | 		for (int j = 0; j <= max_value; j++) {
 77 | 			dp[i][j] = dp[i - 1][j];
 78 | 			if (arr[i - 1].ss <= j) {
 79 | 				ll a = dp[i - 1][j - arr[i - 1].ss];
 80 | 				ll b = arr[i - 1].ff;
 81 | 				if (a <= w && b <= w && a + b <= w) {
 82 | 					dp[i][j] = min(dp[i][j], a + b);
 83 | 				}
 84 | 			}
 85 | 			if (dp[i][j] > w)
 86 | 				dp[i][j] = INF;
 87 | 		}
 88 | 	}
 89 | 	ll ans = 0;
 90 | 	for (int i = 0; i <= n; i++)
 91 | 		for (int j = max_value; j >= 0; j--)
 92 | 			if (dp[i][j] <= w)
 93 | 			{
 94 | 				ans = j;
 95 | 				break;
 96 | 			}
 97 | 	cout << ans << nline;
 98 | }
 99 | int main() {
100 | 	fastio();
101 | #ifndef ONLINE_JUDGE
102 | 	freopen("Input.txt", "r", stdin);
103 | 	freopen("Output.txt", "w", stdout);
104 | 	freopen("Error.txt", "w", stderr);
105 | #endif
106 | 	auto start1 = high_resolution_clock::now();
107 | 	solve();
108 | 	auto stop1 = high_resolution_clock::now();
109 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
110 | #ifndef ONLINE_JUDGE
111 | 	cerr << "Time: " << duration.count() / 1000 << endl;
112 | #endif
113 | 	return 0;
114 | }


--------------------------------------------------------------------------------
/F.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | struct state {
 60 | 	int value;
 61 | 	int direction;
 62 | };
 63 | void solve() {
 64 | 	string s, t;
 65 | 	cin >> s >> t;
 66 | 	int n = s.length();
 67 | 	int m = t.length();
 68 | 	state dp[n + 1][m + 1];
 69 | 	for (int i = 0; i <= n; i++)
 70 | 		dp[i][0] = {0, 1};
 71 | 	for (int i = 0; i <= m; i++)
 72 | 		dp[0][i] = {0, 2};
 73 | 	for (int i = 1; i <= n; i++)
 74 | 	{
 75 | 		for (int j = 1; j <= m; j++)
 76 | 		{
 77 | 			dp[i][j] = {0, 0};
 78 | 			if (dp[i - 1][j - 1].value > dp[i][j].value)
 79 | 				dp[i][j] = {dp[i - 1][j - 1].value, 0};
 80 | 			if (dp[i - 1][j].value > dp[i][j].value)
 81 | 				dp[i][j] = {dp[i - 1][j].value, 1};
 82 | 			if (dp[i][j - 1].value > dp[i][j].value)
 83 | 				dp[i][j] = {dp[i][j - 1].value, 2};
 84 | 			if (s[i - 1] == t[j - 1])
 85 | 				if (2 + dp[i - 1][j - 1].value > dp[i][j].value)
 86 | 					dp[i][j] = {dp[i - 1][j - 1].value + 2, 3};
 87 | 		}
 88 | 	}
 89 | 	string ans = "";
 90 | 	int i = n;
 91 | 	int j = m;
 92 | 	while (i > 0 && j > 0) {
 93 | 		if (dp[i][j].direction == 3)
 94 | 		{
 95 | 			ans = s[i - 1] + ans;
 96 | 			i--;
 97 | 			j--;
 98 | 		}
 99 | 		else if (dp[i][j].direction == 0)
100 | 			i--, j--;
101 | 		else if (dp[i][j].direction == 1)
102 | 			i--;
103 | 		else
104 | 			j--;
105 | 	}
106 | 	cout << ans << nline;
107 | }
108 | int main() {
109 | 	fastio();
110 | #ifndef ONLINE_JUDGE
111 | 	freopen("Input.txt", "r", stdin);
112 | 	freopen("Output.txt", "w", stdout);
113 | 	freopen("Error.txt", "w", stderr);
114 | #endif
115 | 	auto start1 = high_resolution_clock::now();
116 | 	solve();
117 | 	auto stop1 = high_resolution_clock::now();
118 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
119 | #ifndef ONLINE_JUDGE
120 | 	cerr << "Time: " << duration.count() / 1000 << endl;
121 | #endif
122 | 	return 0;
123 | }


--------------------------------------------------------------------------------
/G.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | void dfs(int start, vector<int>*edges, bool *visited, vector<int>& ans)
 60 | {
 61 | 	visited[start] = true;
 62 | 	for (auto i : edges[start])
 63 | 	{
 64 | 		if (visited[i])
 65 | 			continue;
 66 | 		dfs(i, edges, visited, ans);
 67 | 	}
 68 | 	ans.pb(start);
 69 | }
 70 | vector<int> topo_sort(int n, vector<int>*edges)
 71 | {
 72 | 	vector<int> v1;
 73 | 	bool *visited = new bool[n]();
 74 | 	for (int i = 0; i < n; i++)
 75 | 	{
 76 | 		if (visited[i])
 77 | 			continue;
 78 | 		dfs(i, edges, visited, v1);
 79 | 	}
 80 | 	return v1;
 81 | }
 82 | void solve() {
 83 | 	int n, m;
 84 | 	cin >> n >> m;
 85 | 	vector<int>*edges = new vector<int>[n];
 86 | 	for (int i = 0; i < m; i++)
 87 | 	{
 88 | 		int a, b;
 89 | 		cin >> a >> b;
 90 | 		edges[a - 1].pb(b - 1);
 91 | 	}
 92 | 	int *dp = new int[n]();
 93 | 	vector<int> sorted = topo_sort(n, edges);
 94 | 	for (int i = 0; i < n; i++) {
 95 | 		int a = sorted[i];
 96 | 		if (edges[a].size() > 0) {
 97 | 			for (auto j : edges[a])
 98 | 				dp[a] = max(dp[a], dp[j] + 1);
 99 | 		}
100 | 	}
101 | 	int ans = 0;
102 | 	for (int i = 0; i < n; i++)
103 | 		ans = max(ans, dp[i]);
104 | 	cout << ans << nline;
105 | }
106 | int main() {
107 | 	fastio();
108 | #ifndef ONLINE_JUDGE
109 | 	freopen("Input.txt", "r", stdin);
110 | 	freopen("Output.txt", "w", stdout);
111 | 	freopen("Error.txt", "w", stderr);
112 | #endif
113 | 	auto start1 = high_resolution_clock::now();
114 | 	solve();
115 | 	auto stop1 = high_resolution_clock::now();
116 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
117 | #ifndef ONLINE_JUDGE
118 | 	cerr << "Time: " << duration.count() / 1000 << endl;
119 | #endif
120 | 	return 0;
121 | }


--------------------------------------------------------------------------------
/H.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | void solve() {
 61 | 	int n, m;
 62 | 	cin >> n >> m;
 63 | 	string grid[n];
 64 | 	for (int i = 0; i < n; i++)
 65 | 		cin >> grid[i];
 66 | 	ll dp[n][m];
 67 | 	dp[0][0] = 1;
 68 | 	for (int i = 0; i < n; i++)
 69 | 	{
 70 | 		for (int j = 0; j < m; j++)
 71 | 		{
 72 | 			if (i == 0 && j == 0)
 73 | 				continue;
 74 | 			if (grid[i][j] == '#')
 75 | 			{
 76 | 				dp[i][j] = 0;
 77 | 				continue;
 78 | 			}
 79 | 			ll a = (i > 0) ? dp[i - 1][j] : 0;
 80 | 			ll b = (j > 0) ? dp[i][j - 1] : 0;
 81 | 			dp[i][j] = mod_add(a, b, MOD);
 82 | 		}
 83 | 	}
 84 | 	cout << dp[n - 1][m - 1] << nline;
 85 | }
 86 | int main() {
 87 | 	fastio();
 88 | #ifndef ONLINE_JUDGE
 89 | 	freopen("Input.txt", "r", stdin);
 90 | 	freopen("Output.txt", "w", stdout);
 91 | 	freopen("Error.txt", "w", stderr);
 92 | #endif
 93 | 	auto start1 = high_resolution_clock::now();
 94 | 	solve();
 95 | 	auto stop1 = high_resolution_clock::now();
 96 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
 97 | #ifndef ONLINE_JUDGE
 98 | 	cerr << "Time: " << duration.count() / 1000 << endl;
 99 | #endif
100 | 	return 0;
101 | }


--------------------------------------------------------------------------------
/I.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | void solve() {
 61 | 	int n;
 62 | 	cin >> n;
 63 | 	lld arr[n];
 64 | 	for (int i = 0; i < n; i++)
 65 | 		cin >> arr[i];
 66 | 	vector<lld> dp;
 67 | 	dp.pb(1 - arr[0]);
 68 | 	dp.pb(arr[0]);
 69 | 	vector<lld> temp;
 70 | 	for (int i = 2; i <= n; i++) {
 71 | 		for (int j = 0; j <= i; j++) {
 72 | 			lld a = j <= (i - 1) ? dp[j] * (1 - arr[i - 1]) : 0;
 73 | 			lld b = (j - 1) >= 0 ? dp[j - 1] * (arr[i - 1]) : 0;
 74 | 			temp.pb(a + b);
 75 | 		}
 76 | 		dp.clear();
 77 | 		for (auto j : temp)
 78 | 			dp.pb(j);
 79 | 		temp.clear();
 80 | 	}
 81 | 	lld sum = 0;
 82 | 	for (int i = n / 2 + 1; i <= n; i++)
 83 | 		sum += dp[i];
 84 | 	cout << setprecision(10) << fixed;
 85 | 	cout << sum << nline;
 86 | }
 87 | int main() {
 88 | 	fastio();
 89 | #ifndef ONLINE_JUDGE
 90 | 	freopen("Input.txt", "r", stdin);
 91 | 	freopen("Output.txt", "w", stdout);
 92 | 	freopen("Error.txt", "w", stderr);
 93 | #endif
 94 | 	auto start1 = high_resolution_clock::now();
 95 | 	solve();
 96 | 	auto stop1 = high_resolution_clock::now();
 97 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
 98 | #ifndef ONLINE_JUDGE
 99 | 	cerr << "Time: " << duration.count() / 1000 << endl;
100 | #endif
101 | 	return 0;
102 | }


--------------------------------------------------------------------------------
/J_iterative.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | lld dp[301][301][301];
 61 | void solve() {
 62 | 	int n;
 63 | 	cin >> n;
 64 | 	int a1 = 0, a2 = 0, a3 = 0;
 65 | 	for (int i = 0; i < n; i++) {
 66 | 		int ai;
 67 | 		cin >> ai;
 68 | 		if (ai == 1)
 69 | 			a1++;
 70 | 		else if (ai == 2)
 71 | 			a2++;
 72 | 		else
 73 | 			a3++;
 74 | 	}
 75 | 	// dp[a][b][c] = p_a * (1 + dp[a-1][b][c]) + p_b * (1 + dp[a+1][b-1][c]) + p_c * (1 + dp[a][b+1][c-1]) + p_d * (1 + dp[a][b][c]);
 76 | 
 77 | 	// 1 * p_a + 1 * p_b + 1 * p_c + 1 * p_d = 1
 78 | 
 79 | 	// dp[a][b][c] - p_d * (dp[a][b][c]) = 1 + p_a * (dp[a-1][b][c]) + p_b * (dp[a+1][b-1][c]) +p_c * (dp[a][b+1][c-1]);
 80 | 
 81 | 	// dp[a][b][c] = (1 - p_d) * [1 + p*a (dp[a-1][b][c]) + p_b * (dp[a+1][b-1][c]) + p_c * (dp[a][b+1][c-1])]
 82 | 
 83 | 	dp[0][0][0] = 0;
 84 | 	for (int threes = 0; threes <= n; threes++) {
 85 | 		for (int twos = 0; twos <= n; twos++) {
 86 | 			for (int ones = 0; ones <= n; ones++) {
 87 | 				if (threes + twos + ones > n)
 88 | 					continue;
 89 | 				if (threes + ones + twos == 0)
 90 | 					continue;
 91 | 				lld p_a = ((lld)ones) / n;
 92 | 				lld p_b = ((lld)twos) / n;
 93 | 				lld p_c = ((lld)threes) / n;
 94 | 				lld p_d = ((lld)(n - ones - twos - threes)) / n;
 95 | 				lld value = 1;
 96 | 				if (ones - 1 >= 0)
 97 | 					value += p_a * dp[threes][twos][ones - 1];
 98 | 				if (twos - 1 >= 0)
 99 | 					value += p_b * dp[threes][twos - 1][ones + 1];
100 | 				if (threes - 1 >= 0)
101 | 					value += p_c * dp[threes - 1][twos + 1][ones];
102 | 				value = value / (1 - p_d);
103 | 				dp[threes][twos][ones] = value;
104 | 			}
105 | 		}
106 | 	}
107 | 	cout << setprecision(15);
108 | 	cout << fixed;
109 | 	cout << dp[a3][a2][a1] << nline;
110 | }
111 | int main() {
112 | 	fastio();
113 | #ifndef ONLINE_JUDGE
114 | 	freopen("Input.txt", "r", stdin);
115 | 	freopen("Output.txt", "w", stdout);
116 | 	freopen("Error.txt", "w", stderr);
117 | #endif
118 | 	auto start1 = high_resolution_clock::now();
119 | 	solve();
120 | 	auto stop1 = high_resolution_clock::now();
121 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
122 | #ifndef ONLINE_JUDGE
123 | 	cerr << "Time: " << duration.count() / 1000 << endl;
124 | #endif
125 | 	return 0;
126 | }


--------------------------------------------------------------------------------
/J_recursive.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | lld dp[301][301][301];
 61 | int n;
 62 | lld helper(ll a, ll b, ll c) {
 63 | 	if (a == 0 && b == 0 && c == 0)
 64 | 		return 0;
 65 | 	if (dp[a][b][c] != -1.0)
 66 | 		return dp[a][b][c];
 67 | 	// dp[a][b][c] = p_a * (1 + dp[a-1][b][c]) + p_b * ( 1 + dp[a+1][b-1][c]) + p_c * ( 1 + dp[a][b+1][c-1]) + p_d * (1 + dp[a][b][c]);
 68 | 
 69 | 	// 1 * p_a + 1 * p_b + 1 * p_c + 1 * p_d=1
 70 | 
 71 | 	// dp[a][b][c] - p_d * (dp[a][b][c]) = 1 + p_a * (dp[a-1][b][c]) + p_b * (dp[a+1][b-1][c]) +p_c * (dp[a][b+1][c-1]);
 72 | 
 73 | 	// dp[a][b][c] = (1 - p_d) * [1 + p*a (dp[a-1][b][c]) + p_b * (dp[a+1][b-1][c]) + p_c * (dp[a][b+1][c-1])]
 74 | 
 75 | 	lld p_a = ((lld)a) / n;
 76 | 	lld p_b = ((lld)b) / n;
 77 | 	lld p_c = ((lld)c) / n;
 78 | 	lld p_d = ((lld)(n - a - b - c)) / n;
 79 | 	lld value = 1;
 80 | 	if (a - 1 >= 0)
 81 | 		value += p_a * (helper(a - 1, b, c));
 82 | 	if (b - 1 >= 0)
 83 | 		value += p_b * (helper(a + 1, b - 1, c));
 84 | 	if (c - 1 >= 0)
 85 | 		value += p_c * (helper(a, b + 1, c - 1));
 86 | 	value = value / (1 - p_d);
 87 | 	dp[a][b][c] = value;
 88 | 	return value;
 89 | }
 90 | void solve() {
 91 | 	cin >> n;
 92 | 	int a1 = 0, a2 = 0, a3 = 0;
 93 | 	for (int i = 0; i < n; i++) {
 94 | 		int ai;
 95 | 		cin >> ai;
 96 | 		if (ai == 1)
 97 | 			a1++;
 98 | 		else if (ai == 2)
 99 | 			a2++;
100 | 		else
101 | 			a3++;
102 | 	}
103 | 	for (int i = 0; i <= n; i++)
104 | 		for (int j = 0; j <= n; j++)
105 | 			for (int k = 0; k <= n; k++)
106 | 				dp[i][j][k] = -1;
107 | 	cout << setprecision(15);
108 | 	cout << fixed;
109 | 	cout << helper(a1, a2, a3) << nline;
110 | }
111 | int main() {
112 | 	fastio();
113 | #ifndef ONLINE_JUDGE
114 | 	freopen("Input.txt", "r", stdin);
115 | 	freopen("Output.txt", "w", stdout);
116 | 	freopen("Error.txt", "w", stderr);
117 | #endif
118 | 	auto start1 = high_resolution_clock::now();
119 | 	solve();
120 | 	auto stop1 = high_resolution_clock::now();
121 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
122 | #ifndef ONLINE_JUDGE
123 | 	cerr << "Time: " << duration.count() / 1000 << endl;
124 | #endif
125 | 	return 0;
126 | }


--------------------------------------------------------------------------------
/K.cpp:
--------------------------------------------------------------------------------
 1 | /* Priyansh Agarwal*/
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #include<ext/pb_ds/assoc_container.hpp>
 5 | #include<ext/pb_ds/tree_policy.hpp>
 6 | #include<algorithm>
 7 | #include<string.h>
 8 | #include<unordered_map>
 9 | #include<vector>
10 | #include<unordered_set>
11 | #include<set>
12 | #include<map>
13 | #include<queue>
14 | #include<stack>
15 | #include<map>
16 | #include<chrono>
17 | 
18 | using namespace std;
19 | using namespace __gnu_pbds;
20 | using namespace chrono;
21 | 
22 | #define debug(x) cout << #x << " " << x <<endl;
23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
24 | #define MOD 1000000007
25 | #define MOD1 998244353
26 | #define INF 1e18
27 | #define nline "\n"
28 | #define pb push_back
29 | #define ppb pop_back;
30 | #define mp make_pair
31 | #define ff first
32 | #define ss second
33 | #define PI 3.141592653589793238462
34 | #define set_bits __builtin_popcount
35 | #define sz(x) (int)(x.size())
36 | 
37 | typedef long long ll;
38 | typedef unsigned long long ull;
39 | typedef long double lld;
40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
41 | 
42 | /*---------------------------------------------------------------------------------------------------------------------------*/
43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
48 | bool revsort(ll a, ll b) {return a > b;}
49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
51 | void google(int t) {cout << "Case #" << t << ": ";}
52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
58 | /*--------------------------------------------------------------------------------------------------------------------------*/
59 | 
60 | void solve() {
61 | 	int n, k;
62 | 	cin >> n >> k;
63 | 	int dp[k + 1];
64 | 	dp[0] = 0;
65 | 	int arr[n];
66 | 	for (int i = 0; i < n; i++)
67 | 		cin >> arr[i];
68 | 	for (int i = 1; i <= k; i++) {
69 | 		dp[i] = 0;
70 | 		for (int j = 0; j < n; j++) {
71 | 			if (i - arr[j] < 0)
72 | 				break;
73 | 			if (dp[i - arr[j]] == 0) {
74 | 				dp[i] = 1;
75 | 				break;
76 | 			}
77 | 		}
78 | 	}
79 | 	if (dp[k])
80 | 		cout << "First" << nline;
81 | 	else
82 | 		cout << "Second" << nline;
83 | }
84 | int main() {
85 | 	fastio();
86 | #ifndef ONLINE_JUDGE
87 | 	freopen("Input.txt", "r", stdin);
88 | 	freopen("Output.txt", "w", stdout);
89 | 	freopen("Error.txt", "w", stderr);
90 | #endif
91 | 	auto start1 = high_resolution_clock::now();
92 | 	solve();
93 | 	auto stop1 = high_resolution_clock::now();
94 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
95 | #ifndef ONLINE_JUDGE
96 | 	cerr << "Time: " << duration.count() / 1000 << endl;
97 | #endif
98 | 	return 0;
99 | }


--------------------------------------------------------------------------------
/L.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | void solve() {
 61 | 	int n;
 62 | 	cin >> n;
 63 | 	ll arr[n];
 64 | 	for (int i = 0; i < n; i++)
 65 | 		cin >> arr[i];
 66 | 	ll segment_sum[n][n];
 67 | 	for (int i = 0; i < n; i++) {
 68 | 		ll sum = 0;
 69 | 		for (int j = i; j < n; j++) {
 70 | 			sum += arr[j];
 71 | 			segment_sum[i][j] = sum;
 72 | 		}
 73 | 	}
 74 | 	ll dp[n][n];
 75 | 	for (int i = 0; i < n; i++)
 76 | 		dp[i][i] = arr[i];
 77 | 	for (int i = 2; i <= n; i++) {
 78 | 		for (int j = 0; j <= n - i; j++) {
 79 | 			ll value1 = arr[j] + segment_sum[j + 1][j + i - 1] - dp[j + 1][j + i - 1];
 80 | 			ll value2 = arr[j + i - 1] + segment_sum[j][j + i - 2] - dp[j][j + i - 2];
 81 | 			dp[j][j + i - 1] = max(value1, value2);
 82 | 		}
 83 | 	}
 84 | 	ll x = dp[0][n - 1];
 85 | 	ll y = segment_sum[0][n - 1] - x;
 86 | 	cout << x - y << nline;
 87 | }
 88 | int main() {
 89 | 	fastio();
 90 | #ifndef ONLINE_JUDGE
 91 | 	freopen("Input.txt", "r", stdin);
 92 | 	freopen("Output.txt", "w", stdout);
 93 | 	freopen("Error.txt", "w", stderr);
 94 | #endif
 95 | 	auto start1 = high_resolution_clock::now();
 96 | 	solve();
 97 | 	auto stop1 = high_resolution_clock::now();
 98 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
 99 | #ifndef ONLINE_JUDGE
100 | 	cerr << "Time: " << duration.count() / 1000 << endl;
101 | #endif
102 | 	return 0;
103 | }


--------------------------------------------------------------------------------
/M.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | 
 61 | ll dp[101][100001];
 62 | ll prefix[101][100001];
 63 | 
 64 | void solve() {
 65 | 
 66 | 	// dp[n][k] = number of ways to distribute k candies among n people
 67 | 	// dp[n][k] = dp[n-1][k] + dp[n-1][k-1] + dp[n-1][k-2]..... + dp[n-1][k-a[n]];
 68 | 	// then to find dp[n+1][k] we can find prefix sum from dp[n][0] to dp[n][k-a[n+1]];
 69 | 	// in the end we just find dp[n][k]
 70 | 
 71 | 	// base cases dp[0][0] = 1
 72 | 	// dp[0][i] = 0 for i > 0
 73 | 
 74 | 	int n, k;
 75 | 	cin >> n >> k;
 76 | 	ll arr[n];
 77 | 	for (int i = 0; i < n; i++)
 78 | 		cin >> arr[i];
 79 | 	dp[0][0] = 1;
 80 | 	for (int i = 1; i <= k; i++)
 81 | 		dp[0][i] = 0;
 82 | 	for (int i = 0; i <= k; i++) {
 83 | 		prefix[0][i] = (dp[0][i] + ((i > 0) ? prefix[0][i - 1] : 0)) % MOD;
 84 | 	}
 85 | 	for (int i = 1; i <= n; i++) {
 86 | 		for (int j = 0; j <= k; j++) {
 87 | 			int right = j;
 88 | 			int left = max(j - arr[i - 1], (ll)0);
 89 | 			dp[i][j] = (prefix[i - 1][right] - ((left > 0) ? prefix[i - 1][left - 1] : 0)) % MOD;
 90 | 		}
 91 | 		for (int j = 0; j <= k; j++) {
 92 | 			prefix[i][j] = (dp[i][j] + ((j > 0) ? prefix[i][j - 1] : 0)) % MOD;
 93 | 		}
 94 | 	}
 95 | 	cout << mod_add(dp[n][k], 0, MOD) << nline;
 96 | }
 97 | int main() {
 98 | 	fastio();
 99 | #ifndef ONLINE_JUDGE
100 | 	freopen("Input.txt", "r", stdin);
101 | 	freopen("Output.txt", "w", stdout);
102 | 	freopen("Error.txt", "w", stderr);
103 | #endif
104 | 	auto start1 = high_resolution_clock::now();
105 | 	solve();
106 | 	auto stop1 = high_resolution_clock::now();
107 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
108 | #ifndef ONLINE_JUDGE
109 | 	cerr << "Time: " << duration.count() / 1000 << endl;
110 | #endif
111 | 	return 0;
112 | }


--------------------------------------------------------------------------------
/M_optimized_memory.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | 
 60 | 
 61 | ll dp[100001];
 62 | ll prefix[100001];
 63 | ll temp[100001];
 64 | 
 65 | void solve() {
 66 | 
 67 | 	// dp[n][k] = number of ways to distribute k candies among n people
 68 | 	// dp[n][k] = dp[n-1][k] + dp[n-1][k-1] + dp[n-1][k-2]..... + dp[n-1][k-a[n]];
 69 | 	// then to find dp[n+1][k] we can find prefix sum from dp[n][0] to dp[n][k-a[n+1]];
 70 | 	// in the end we just find dp[n][k]
 71 | 
 72 | 	// base cases dp[0][0] = 1
 73 | 	// dp[0][i] = 0 for i > 0
 74 | 
 75 | 	int n, k;
 76 | 	cin >> n >> k;
 77 | 	ll arr[n];
 78 | 	for (int i = 0; i < n; i++)
 79 | 		cin >> arr[i];
 80 | 	dp[0] = 1;
 81 | 	for (int i = 1; i <= k; i++)
 82 | 		dp[i] = 0;
 83 | 	for (int i = 0; i <= k; i++) {
 84 | 		prefix[i] = (dp[i] + ((i > 0) ? prefix[i - 1] : 0)) % MOD;
 85 | 	}
 86 | 	for (int i = 1; i <= n; i++) {
 87 | 		for (int j = 0; j <= k; j++) {
 88 | 			int right = j;
 89 | 			int left = max(j - arr[i - 1], (ll)0);
 90 | 			dp[j] = (prefix[right] - ((left > 0) ? prefix[left - 1] : 0)) % MOD;
 91 | 		}
 92 | 		for (int j = 0; j <= k; j++) {
 93 | 			prefix[j] = (dp[j] + ((j > 0) ? prefix[j - 1] : 0)) % MOD;
 94 | 		}
 95 | 	}
 96 | 	cout << mod_add(dp[k], 0, MOD) << nline;
 97 | 
 98 | 	//memory can be optimized as we only require the previous stage.
 99 | }
100 | int main() {
101 | 	fastio();
102 | #ifndef ONLINE_JUDGE
103 | 	freopen("Input.txt", "r", stdin);
104 | 	freopen("Output.txt", "w", stdout);
105 | 	freopen("Error.txt", "w", stderr);
106 | #endif
107 | 	auto start1 = high_resolution_clock::now();
108 | 	solve();
109 | 	auto stop1 = high_resolution_clock::now();
110 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
111 | #ifndef ONLINE_JUDGE
112 | 	cerr << "Time: " << duration.count() / 1000 << endl;
113 | #endif
114 | 	return 0;
115 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Solutions to Atcoder Educational DP contest problems.
2 | 
3 | https://atcoder.jp/contests/dp
4 | 


--------------------------------------------------------------------------------
/S.cpp:
--------------------------------------------------------------------------------
  1 | /* Priyansh Agarwal*/
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #include<ext/pb_ds/assoc_container.hpp>
  5 | #include<ext/pb_ds/tree_policy.hpp>
  6 | #include<algorithm>
  7 | #include<string.h>
  8 | #include<unordered_map>
  9 | #include<vector>
 10 | #include<unordered_set>
 11 | #include<set>
 12 | #include<map>
 13 | #include<queue>
 14 | #include<stack>
 15 | #include<map>
 16 | #include<chrono>
 17 | 
 18 | using namespace std;
 19 | using namespace __gnu_pbds;
 20 | using namespace chrono;
 21 | 
 22 | #define debug(x) cout << #x << " " << x <<endl;
 23 | #define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 24 | #define MOD 1000000007
 25 | #define MOD1 998244353
 26 | #define INF 1e18
 27 | #define nline "\n"
 28 | #define pb push_back
 29 | #define ppb pop_back;
 30 | #define mp make_pair
 31 | #define ff first
 32 | #define ss second
 33 | #define PI 3.141592653589793238462
 34 | #define set_bits __builtin_popcount
 35 | #define sz(x) (int)(x.size())
 36 | 
 37 | typedef long long ll;
 38 | typedef unsigned long long ull;
 39 | typedef long double lld;
 40 | typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > pbds; // find_by_order, order_of_key
 41 | 
 42 | /*---------------------------------------------------------------------------------------------------------------------------*/
 43 | ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
 44 | ll expo(ll a, ll b, ll mod) {ll res = 1; while (b > 0) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b = b >> 1;} return res;}
 45 | void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
 46 | ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
 47 | ll mminvprime(ll a, ll b) {return expo(a, b - 2, b);}
 48 | bool revsort(ll a, ll b) {return a > b;}
 49 | void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
 50 | ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
 51 | void google(int t) {cout << "Case #" << t << ": ";}
 52 | vector<int> sieve(int n) {int*arr = new int[n + 1](); vector<int> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
 53 | ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
 54 | ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
 55 | ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
 56 | ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
 57 | ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0)n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
 58 | /*--------------------------------------------------------------------------------------------------------------------------*/
 59 | ll dp[10005][105][2];
 60 | ll helper(string &s, int x, int n, int sum, int tight) {
 61 | 	if (n == 0) {
 62 | 		if (sum == 0)
 63 | 			return 1;
 64 | 		return 0;
 65 | 	}
 66 | 	if (dp[n][sum][tight] != -1)
 67 | 		return dp[n][sum][tight];
 68 | 	int ub = tight ? (s[s.length() - n] - '0') : 9;
 69 | 	ll ans = 0;
 70 | 	for (int i = 0; i <= ub; i++) {
 71 | 		ll ans1 = helper(s, x, n - 1, (sum + i) % x, tight & (i == ub));
 72 | 		ans = mod_add(ans, ans1, MOD);
 73 | 	}
 74 | 	dp[n][sum][tight] = ans;
 75 | 	return ans;
 76 | }
 77 | void solve() {
 78 | 	string s;
 79 | 	cin >> s;
 80 | 	memset(dp, -1, sizeof(dp));
 81 | 	int x;
 82 | 	cin >> x;
 83 | 	ll ans1 = helper(s, x, s.length(), 0, 1);
 84 | 	cout << mod_sub(ans1, 1, MOD) << nline;
 85 | }
 86 | int main() {
 87 | 	fastio();
 88 | #ifndef ONLINE_JUDGE
 89 | 	freopen("Input.txt", "r", stdin);
 90 | 	freopen("Output.txt", "w", stdout);
 91 | 	freopen("Error.txt", "w", stderr);
 92 | #endif
 93 | 	auto start1 = high_resolution_clock::now();
 94 | 	solve();
 95 | 	auto stop1 = high_resolution_clock::now();
 96 | 	auto duration = duration_cast<microseconds>(stop1 - start1);
 97 | #ifndef ONLINE_JUDGE
 98 | 	cerr << "Time: " << duration.count() / 1000 << endl;
 99 | #endif
100 | 	return 0;
101 | }


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