├── .gitignore ├── Additional Problems └── Counting_Bits.cpp ├── Advanced Techniques ├── Beautiful_Subgrids.cpp ├── Course_Schedule_II ├── Course_Schedule_II.cpp ├── Hamming_Distance.cpp ├── Meet_in_the_Middle.cpp ├── Reachable_Nodes.cpp └── a.out ├── Dynamic Programming ├── Array_Description.cpp ├── Book_Shop.cpp ├── Coin_Combinations_I.cpp ├── Coin_Combinations_II.cpp ├── Counting_Numbers.cpp ├── Counting_Tilings.cpp ├── Counting_Towers.cpp ├── Dice_Combinations.cpp ├── Edit_Distance.cpp ├── Elevator_Rides.cpp ├── Grid_Paths.cpp ├── Increasing_Subsequence.cpp ├── Minimizing_Coins.cpp ├── Money_Sums.cpp ├── Projects.cpp ├── Rectangle_Cutting.cpp ├── Removal_Game.cpp ├── Removing_Digits.cpp ├── Two_Sets_II.cpp └── a.out ├── Geometry ├── Line_Segment_Intersection.cpp ├── Minimum_Euclidean_Distance.cpp ├── Point_Location_Test.cpp └── a.out ├── Graph Algorithms ├── Building_Roads.cpp ├── Building_Teams.cpp ├── Counting_Rooms.cpp ├── Course_Schedule.cpp ├── Cycle_Finding.cpp ├── Flight_Discount.cpp ├── Flight_Routes.cpp ├── Flight_Routes_Check.cpp ├── Game_Routes.cpp ├── Hamiltonian_Flights.cpp ├── High_Score.cpp ├── Investigation.cpp ├── Labyrinth.cpp ├── Longest_Flight_Route.cpp ├── Message_Route.cpp ├── Monsters.cpp ├── Planets_Queries_I.cpp ├── Planets_Queries_II.cpp ├── Planets_and_Kingdoms.cpp ├── Road_Construction.cpp ├── Road_Reparation.cpp ├── Round_Trip.cpp ├── Round_Trip_II.cpp ├── Shortest_Routes_I.cpp ├── Shortest_Routes_II.cpp └── a.out ├── Introductory Problems ├── Apple_Division.cpp ├── Bit _Strings.cpp ├── Chessboard_and_Queens.cpp ├── Coin_Piles.cpp ├── Creating_Strings_I.cpp ├── Digit_Queries.cpp ├── Gray_Code.cpp ├── Grid_Paths.cpp ├── Increasing_Array.cpp ├── Missing_Number.cpp ├── Number_Spiral.cpp ├── Palindrome_Reorder.cpp ├── Permutations.cpp ├── Repetitions.cpp ├── Tower_Of_Hanoi.cpp ├── Trailing_Zeros.cpp ├── Two_Knights.cpp ├── Two_Sets.cpp ├── Weird_Algorithm.cpp └── a.out ├── Mathematics ├── Another_Game.cpp ├── Binomial_Coefficients.cpp ├── Bracket_Sequences_I.cpp ├── Bracket_Sequences_II.cpp ├── Candy_Lottery.cpp ├── Christmas_Party.cpp ├── Common_Divisors.cpp ├── Counting_Coprime_Pairs.cpp ├── Counting_Divisors.cpp ├── Counting_Grids.cpp ├── Counting_Necklaces.cpp ├── Creating_Strings_II.cpp ├── Dice_Probability.cpp ├── Distributing_Apples.cpp ├── Divisor_Analysis.cpp ├── Exponentiation.cpp ├── Exponentiation_II.cpp ├── Fibonacci_Numbers.cpp ├── Graph_Paths_I.cpp ├── Graph_Paths_II.cpp ├── Grundy's_Game.cpp ├── Inversion_Probability.cpp ├── Josephus_Queries.cpp ├── Nim_Game_I.cpp ├── Nim_Game_II.cpp ├── Prime_Multiples.cpp ├── Stair_Game.cpp ├── Stick_Game.cpp ├── Sum_of_Divisors.cpp ├── Throwing_Dice.cpp └── a.out ├── Range Queries ├── Dynamic_Range_Minimum_Queries.cpp ├── Dynamic_Range_Sum_Queries.cpp ├── Forest_Queries.cpp ├── Forest_Queries_II.cpp ├── Hotel_Queries.cpp ├── List_Removals.cpp ├── Pizzeria_Queries.cpp ├── Prefix_Sum_Queries.cpp ├── Range_Update_Queries.cpp ├── Range_Updates_and_Sums.cpp ├── Range_Xor_Queries.cpp ├── Salary_Queries.cpp ├── Static_Range_Minimum_Queries.cpp ├── Static_Range_Sum_Queries.cpp ├── Subarray_Sum_Queries.cpp └── a.out ├── Sorting and Searching ├── Apartments.cpp ├── Array_Division.cpp ├── Collecting_Numbers.cpp ├── Collecting_Numbers_II.cpp ├── Concert_Tickets.cpp ├── Distinct_Numbers.cpp ├── Factory_Machines.cpp ├── Ferris_Wheel.cpp ├── Josephus_Problem_I.cpp ├── Josephus_Problem_II.cpp ├── Max_Subarray_Sum.cpp ├── Maximum_Subarray_Sum_II.cpp ├── Missing_Coin_Sum.cpp ├── Movie_Festival.cpp ├── Movie_Festival_II.cpp ├── Nearest_Smaller_Values.cpp ├── Nested_Ranges_Check.cpp ├── Nested_Ranges_Count.cpp ├── Playlist.cpp ├── Reading_Books.cpp ├── Restaurant_Customers.cpp ├── Room_Allocation.cpp ├── Sliding_Cost.cpp ├── Sliding_Median.cpp ├── Stick_Length.cpp ├── Subarray_Distinct_Values.cpp ├── Subarray_Divisibility.cpp ├── Subarray_Sums_I.cpp ├── Subarray_Sums_II.cpp ├── Sum_Of_Two_Values.cpp ├── Sum_of_Four_Values.cpp ├── Sum_of_Three_Values.cpp ├── Tasks_and_Deadlines.cpp ├── Towers.cpp ├── Traffic_Lights.cpp └── a.out ├── String Algorithms ├── Finding_Borders.cpp ├── Finding_Periods.cpp ├── Longest_Palindrome.cpp ├── Minimal_Rotation.cpp ├── String_Matching.cpp ├── Word_Combinations.cpp └── a.out ├── Tree Algorithms ├── Company_Queries_I.cpp ├── Company_Queries_II.cpp ├── Counting_Paths.cpp ├── Distance_Queries.cpp ├── Distinct_Colors.cpp ├── Finding_a_Centroid.cpp ├── Fixed-Length_Paths_I.cpp ├── Fixed_Length_Paths_I.cpp ├── Path_Queries.cpp ├── Path_Queries_II.cpp ├── Subordinates.cpp ├── Subtree_Queries.cpp ├── Tree_Diameter.cpp ├── Tree_Distances_I.cpp ├── Tree_Distances_II.cpp ├── Tree_Matching.cpp └── a.out └── format.txt /.gitignore: -------------------------------------------------------------------------------- 1 | **/a.out -------------------------------------------------------------------------------- /Advanced Techniques/Beautiful_Subgrids.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout << fixed << setprecision(6); 17 | 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | typedef pair pll; 22 | typedef vector vi; 23 | typedef vector vll; 24 | typedef vector vb; 25 | typedef vector vvb; 26 | typedef vector vvi; 27 | typedef vector vvll; 28 | 29 | void __print(int x) {cerr << x;} 30 | void __print(long x) {cerr << x;} 31 | void __print(long long x) {cerr << x;} 32 | void __print(unsigned x) {cerr << x;} 33 | void __print(unsigned long x) {cerr << x;} 34 | void __print(unsigned long long x) {cerr << x;} 35 | void __print(float x) {cerr << x;} 36 | void __print(double x) {cerr << x;} 37 | void __print(long double x) {cerr << x;} 38 | void __print(char x) {cerr << '"' << x << '"';} 39 | void __print(const char *x) {cerr << '"' << x << '"';} 40 | void __print(const string &x) {cerr << '"' << x << '"';} 41 | void __print(bool x) {cerr << (x ? "true" : "false");} 42 | 43 | template 44 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 45 | template 46 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 47 | void _print() {cerr << "]" << endl;} 48 | template 49 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 50 | 51 | #ifndef ONLINE_JUDGE 52 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 53 | #else 54 | #define deb(x...) 55 | #endif 56 | 57 | const double PI = 3.1415926535897932384626; 58 | const ll oo = 9e18; 59 | const double EPS = 1e-6; 60 | 61 | void solution(int testno) { 62 | cout << endl; 63 | } 64 | 65 | signed main() 66 | { 67 | fastIO; 68 | int test = 1; 69 | cin >> test; 70 | clock_t begin, end; 71 | 72 | fo(i,1,test+1) { 73 | begin = clock(); 74 | solution(i); 75 | end = clock(); 76 | cerr << "[ Case :- " << i << " | Time Taken :- " << ((ld)end - (ld)begin) / CLOCKS_PER_SEC << " ]" << endl; 77 | } 78 | return 0; 79 | } -------------------------------------------------------------------------------- /Advanced Techniques/Course_Schedule_II: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Advanced Techniques/Course_Schedule_II -------------------------------------------------------------------------------- /Advanced Techniques/Hamming_Distance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define fo(i, b, n) for (ll i = b; i < n; ++i) 14 | const double PI = 3.141592653589793238; 15 | const ll oo = 1e18; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | void solve() 23 | { 24 | string s; 25 | ll n, k; 26 | cin >> n >> k; 27 | vll v(n, 0); 28 | fo(i, 0, n) 29 | { 30 | cin >> s; 31 | reverse(s.begin(), s.end()); 32 | fo(j, 0, k) v[i] += (s[j] == '1') * (1 << j); 33 | } 34 | ll ans = 32; 35 | fo(i, 0, n) 36 | fo(j, i + 1, n) 37 | ans = min(ans, (ll)__builtin_popcount(v[i] ^ v[j])); 38 | cout << ans; 39 | } 40 | 41 | int main() 42 | { 43 | fast; 44 | solve(); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Advanced Techniques/Meet_in_the_Middle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define fo(i, b, n) for (long i = b; i < n; ++i) 14 | const double PI = 3.141592653589793238; 15 | const ll oo = 1e18; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | struct custom_hash // custom hash function for unordered map 23 | { 24 | static uint64_t splitmix64(uint64_t x) 25 | { 26 | x += 0x9e3779b97f4a7c15; 27 | x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; 28 | x = (x ^ (x >> 27)) * 0x94d049bb133111eb; 29 | return x ^ (x >> 31); 30 | } 31 | 32 | size_t operator()(uint64_t x) const 33 | { 34 | static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); 35 | return splitmix64(x + FIXED_RANDOM); 36 | } 37 | }; 38 | unordered_map mp; // storing generated combinations 39 | 40 | signed main() 41 | { 42 | fast; 43 | ll n, k, x, res = 0; 44 | cin >> n >> k; 45 | vll v1, v2; 46 | 47 | fo(i, 0, n / 2) 48 | { 49 | cin >> x; 50 | v1.push_back(x); 51 | } 52 | fo(i, n / 2, n) 53 | { 54 | cin >> x; 55 | v2.push_back(x); 56 | } 57 | ll n1 = n / 2, n2 = n - n1; 58 | 59 | for (ll i = 0; i < (1 << n1); ++i) //using bitset to generate all possible combinations 60 | { 61 | ll x = 0, y = 0, st = i; 62 | while (st > 0) // calculating sum value 63 | { 64 | if (st & 1) 65 | x += v1[y]; 66 | y++; 67 | st >>= 1; 68 | } 69 | mp[x]++; 70 | } 71 | 72 | for (ll i = 0; i < (1 << n2); ++i) 73 | { 74 | ll x = 0, y = 0, st = i; 75 | while (st > 0) 76 | { 77 | if (st & 1) 78 | x += v2[y]; 79 | y++; 80 | st >>= 1; 81 | } 82 | if (mp.count(k - x)) 83 | res += mp[k - x]; 84 | } 85 | cout << res; 86 | return 0; 87 | } -------------------------------------------------------------------------------- /Advanced Techniques/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Advanced Techniques/a.out -------------------------------------------------------------------------------- /Dynamic Programming/Array_Description.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | void solve() 24 | { 25 | long n, m; 26 | cin >> n >> m; 27 | vector dp(n, vl(m + 1, 0)); 28 | long x; 29 | cin >> x; 30 | if (x == 0) 31 | fill(dp[0].begin(), dp[0].end(), 1); 32 | else 33 | dp[0][x] = 1; 34 | 35 | for (long i = 1; i < n; ++i) 36 | { 37 | cin >> x; 38 | if (x == 0) 39 | { 40 | for (long j = 1; j <= m; ++j) 41 | for (long k : {j - 1, j, j + 1}) 42 | if (k >= 1 && k <= m) 43 | (dp[i][j] += dp[i - 1][k]) %= O; 44 | } 45 | else 46 | { 47 | for (long k : {x - 1, x, x + 1}) 48 | if (k >= 1 && k <= m) 49 | (dp[i][x] += dp[i - 1][k]) %= O; 50 | } 51 | } 52 | long ans = 0; 53 | for (long j = 1; j <= m; ++j) 54 | (ans += dp[n - 1][j]) %= O; 55 | cout << ans; 56 | } 57 | 58 | int main() 59 | { 60 | fast; 61 | // long t; 62 | // cin >> t; 63 | // while (t--) 64 | solve(); 65 | return 0; 66 | } -------------------------------------------------------------------------------- /Dynamic Programming/Book_Shop.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | ll n, x; 26 | cin >> n >> x; 27 | vll h(n), s(n); 28 | fo(i, n) cin >> h[i]; 29 | fo(i, n) cin >> s[i]; 30 | ll dp[x + 1]; 31 | 32 | memset(dp, 0, sizeof(dp)); 33 | 34 | for(long i = 1; i <= n; ++i) 35 | { 36 | for(long j = x; j > 0; --j) 37 | if(j - h[i - 1] >= 0) 38 | dp[j] = max(dp[j], s[i - 1] + dp[j - h[i - 1]]); 39 | } 40 | 41 | cout << dp[x]; 42 | return 0; 43 | } -------------------------------------------------------------------------------- /Dynamic Programming/Coin_Combinations_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n, x, i; 17 | cin >> n >> x; 18 | ll dp[x + 1], a[n]; 19 | dp[0] = 0; 20 | for(i = 0; i < n; ++i) 21 | cin >> a[i]; 22 | sort(a, a + n); 23 | for(i = 1; i <= x; ++i) { 24 | long j = 0; 25 | dp[i] = 0; 26 | while(j < n) { 27 | if(i - a[j] > 0) 28 | dp[i] += dp[i - a[j]]; 29 | else if(i - a[j] == 0) 30 | dp[i] += 1; 31 | dp[i] = dp[i] % 1000000007; 32 | ++j; 33 | } 34 | } 35 | cout << dp[x] << endl; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Dynamic Programming/Coin_Combinations_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n, x, i; 17 | cin >> n >> x; 18 | vll dp(x + 1, 0), a(n); 19 | for(i = 0; i < n; ++i) 20 | cin >> a[i]; 21 | 22 | dp[0] = 1; 23 | 24 | for(int i = 1; i <= n; ++i) { 25 | for(int j = 1; j <= x; ++j) { 26 | if(j - a[i - 1] >= 0) { 27 | dp[j] += dp[j - a[i - 1]]; 28 | dp[j] = dp[j] % 1000000007; 29 | } 30 | } 31 | } 32 | cout << dp[x] << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Dynamic Programming/Counting_Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | // dp[i][j][k][l] - count of numbers where j is not present at ith index in number 24 | // k denotes if the number contains leading zeros 25 | // l denotes if the number has tight constraints 26 | 27 | ll dp[20][10][2][2]; 28 | 29 | ll countNumbers(string &num, int n, int x, bool lead_zero, bool tight) 30 | { 31 | if (n == 0) 32 | return 1; 33 | 34 | if (x != -1 && dp[n][x][lead_zero][tight] != -1) 35 | return dp[n][x][lead_zero][tight]; 36 | 37 | // lower bound & upper bound 38 | int lb = 0; 39 | int ub = tight ? (num[num.size() - n] - '0') : 9; 40 | 41 | ll ans = 0; 42 | for (int i = lb; i <= ub; ++i) 43 | { 44 | if (i == x && lead_zero == 0) 45 | continue; 46 | ans += countNumbers(num, n - 1, i, (lead_zero && i == 0), (tight && i == ub)); 47 | } 48 | return dp[n][x][lead_zero][tight] = ans; 49 | } 50 | 51 | void solve() 52 | { 53 | ll a, b; 54 | cin >> a >> b; 55 | string A, B; 56 | A = to_string(a - 1); 57 | B = to_string(b); 58 | memset(dp, -1, sizeof(dp)); 59 | ll ansB = countNumbers(B, B.size(), -1, 1, 1); 60 | memset(dp, -1, sizeof(dp)); 61 | ll ansA = countNumbers(A, A.size(), -1, 1, 1); 62 | cout << ansB - ansA; 63 | } 64 | 65 | int main() 66 | { 67 | fast; 68 | // long t; 69 | // cin >> t; 70 | // while (t--) 71 | solve(); 72 | return 0; 73 | } -------------------------------------------------------------------------------- /Dynamic Programming/Counting_Tilings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, m, dp[1003][1030]; 35 | 36 | void solve(ll x = 0, ll y = 0, ll mask = 0, ll nxt_mask = 0) 37 | { 38 | if (x == n) 39 | return; 40 | if (y >= m) 41 | (dp[x - 1][nxt_mask] += dp[x][mask]) %= MOD; 42 | else 43 | { 44 | ll my_mask = 1 << y; 45 | if (mask & my_mask) 46 | solve(x, y + 1, mask, nxt_mask); 47 | else 48 | { 49 | solve(x, y + 1, mask, nxt_mask | my_mask); 50 | if (y + 1 < m && !(mask & (my_mask << 1))) 51 | solve(x, y + 2, mask, nxt_mask); 52 | } 53 | } 54 | } 55 | 56 | signed main() 57 | { 58 | fastIO; 59 | cin >> m >> n; 60 | dp[0][0] = 1; 61 | 62 | for (ll i = 0; i < n; ++i) 63 | { 64 | for (ll j = 0; j < (1 << m); ++j) 65 | solve(i, 0, j, 0); 66 | } 67 | cout << dp[n][0]; 68 | return 0; 69 | } -------------------------------------------------------------------------------- /Dynamic Programming/Counting_Towers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | ll dp[1000006][2]; 24 | 25 | // _ _ 26 | // dp[i][1] = last blocks are separate | || | 27 | // _ _ 28 | // dp[i][2] = last blocks are fused | | 29 | 30 | // transition: 31 | // _ _ _ _ _ _ _ _ _ _ 32 | // _ _ | || | |_|| | | ||_| |_||_| |_ _| 33 | // | || | => | || |, | || |, | || |, | || |, | | | 34 | // _ _ _ _ _ _ 35 | // _ _ | | |_|_| |_ _| 36 | // | | => | |, | |, | | 37 | 38 | // dp[i][0] = dp[i-1][0]*4 + dp[i-1][1] 39 | // dp[i][1] = dp[i-1][0] + dp[i-1][1]*2 40 | 41 | void solve() 42 | { 43 | long n; 44 | cin >> n; 45 | cout << (dp[n][0] + dp[n][1]) % O << endl; 46 | } 47 | 48 | int main() 49 | { 50 | fast; 51 | dp[1][0] = dp[1][1] = 1; 52 | for (long i = 2; i < 1000004; ++i) 53 | { 54 | dp[i][0] = (dp[i - 1][0] * 4 % O + dp[i - 1][1]) % O; 55 | dp[i][1] = (dp[i - 1][0] + dp[i - 1][1] * 2) % O; 56 | } 57 | 58 | long t; 59 | cin >> t; 60 | while (t--) 61 | solve(); 62 | return 0; 63 | } -------------------------------------------------------------------------------- /Dynamic Programming/Dice_Combinations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | /* 35 | This problem is one of the standard questions of DP. 36 | Before diving into DP approach, let's go through the question with a recursion approach & then we will memoize 37 | our solution to reduce the time complexity. 38 | Lets say the sum to construct is N, and the function that gives the number of ways to construct a sum x be F(x). 39 | So, the problem can be initially broken into 6 parts (each part for each possible outcome on a dice roll). 40 | 41 | F(x - 1) - Count no. of ways to construct (x - 1) & next throw could be a 1. 42 | F(x - 2) - Count no. of ways to construct (x - 2) & next throw could be a 2. 43 | F(x - 3) - Count no. of ways to construct (x - 3) & next throw could be a 3. 44 | ... and so on. 45 | 46 | The value of F(x) will the aggregate of all the values for possible outcomes of the dice (1 to 6). 47 | Next problem is the base condition for the recursion to terminate. 48 | CASE 1 :- x < 0, we cannot construct a negative sum, thus no. of ways will be 0. 49 | CASE 2 :- x == 0, since this is our win condition OR if the value of x becomes 0, it means that 50 | a particular sum has already been achieved, thus we return 1. 51 | 52 | Now since a decent recursion is achieved, we will just be memoizing the code, and the problem is solved. 53 | */ 54 | 55 | ll dp[10 * N]; 56 | 57 | ll solve(ll n) 58 | { 59 | if (n < 0) 60 | return 0; 61 | if (n == 0) 62 | return 1; 63 | 64 | if (dp[n] != -1) 65 | return dp[n]; 66 | 67 | ll res = 0; 68 | fo(i, 1, 7) 69 | res = (res + solve(n - i)) % MOD; 70 | return dp[n] = res; 71 | } 72 | 73 | signed main() 74 | { 75 | fastIO; 76 | mem(dp, -1); 77 | ll n; 78 | cin >> n; 79 | cout << solve(n); 80 | return 0; 81 | } -------------------------------------------------------------------------------- /Dynamic Programming/Edit_Distance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | string a, b; 26 | cin >> a >> b; 27 | int n = a.size(), m = b.size(); 28 | 29 | vector dp(n + 1, vi(m + 1, 0)); 30 | for (int i = 0; i <= n; ++i) 31 | { 32 | for (int j = 0; j <= m; ++j) 33 | { 34 | if (i == 0) 35 | { 36 | dp[i][j] = j; 37 | continue; 38 | } 39 | if (j == 0) 40 | { 41 | dp[i][j] = i; 42 | continue; 43 | } 44 | 45 | if (a[i - 1] == b[j - 1]) 46 | dp[i][j] = dp[i - 1][j - 1]; 47 | else 48 | dp[i][j] = 1 + min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]}); 49 | } 50 | } 51 | cout << dp[n][m]; 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Dynamic Programming/Elevator_Rides.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | signed main() 35 | { 36 | fastIO; 37 | int n, k; 38 | cin >> n >> k; 39 | int a[n]; 40 | fo(i, 0, n) cin >> a[i]; 41 | 42 | pair dp[1 << n]; 43 | dp[0] = {0, k + 1}; 44 | 45 | for (int s = 1; s < (1 << n); s++) 46 | { 47 | dp[s] = {25, 0}; 48 | for (int i = 0; i < n; ++i) 49 | { 50 | if ((s >> i) & 1) 51 | { 52 | auto t = dp[s ^ (1 << i)]; 53 | if (t.se + a[i] > k) 54 | { 55 | t.fi++; 56 | t.se = min(a[i], t.se); 57 | } 58 | else 59 | t.se += a[i]; 60 | dp[s] = min(dp[s], t); 61 | } 62 | } 63 | } 64 | 65 | cout << dp[(1 << n) - 1].fi; 66 | return 0; 67 | } -------------------------------------------------------------------------------- /Dynamic Programming/Grid_Paths.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n, i, j; 17 | cin >> n; 18 | char s[n][n]; 19 | ll dp[n][n] = {0}; 20 | for(i = 0; i < n; ++i) 21 | for(j = 0; j < n; ++j) 22 | cin >> s[i][j]; 23 | for(i = 0; i < n; ++i) 24 | if(s[0][i] == '*') 25 | { 26 | int k = i; 27 | while(k < n){ 28 | dp[0][k] = 0; 29 | ++k; 30 | } 31 | break; 32 | } 33 | else 34 | dp[0][i] = 1; 35 | 36 | for(i = 0; i < n; ++i) 37 | if(s[i][0] == '*') 38 | { 39 | int k = i; 40 | while(k < n){ 41 | dp[k][0] = 0; 42 | ++k; 43 | } 44 | break; 45 | } 46 | else 47 | dp[i][0] = 1; 48 | 49 | for(i = 1; i < n; ++i) 50 | { 51 | for(j = 1; j < n; ++j) 52 | { 53 | if(s[i][j] == '*') 54 | dp[i][j] = 0; 55 | else 56 | dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % 1000000007; 57 | } 58 | } 59 | cout << dp[n - 1][n - 1] << endl; 60 | return 0; 61 | } -------------------------------------------------------------------------------- /Dynamic Programming/Increasing_Subsequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | long n; 26 | cin >> n; 27 | vl dp; 28 | for(long i = 0; i < n; ++i) { 29 | long t; 30 | cin >> t; 31 | auto it = lower_bound(dp.begin(), dp.end(), t); 32 | if(it == dp.end()) { 33 | dp.push_back(t); 34 | } else { 35 | *it = t; 36 | } 37 | } 38 | cout << dp.size(); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /Dynamic Programming/Minimizing_Coins.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | /* 35 | This problem can be broken into many simple subproblems which would help in solving current problem. 36 | Lets say the function which gives the minimum number of coins to produce a sum of x is F(x), and the 37 | denominations are c1, c2, ... cn. Now lets start breaking the problem into subproblems. 38 | 39 | F(x - c1) - minimum no. of coins for making a sum of (x - c1) & we can add one more coin to make sum x. 40 | Thus total no. of coins would become (1 + F(x - c1)). 41 | F(x - c2) - minimum no. of coins for making a sum of (x - c2) & we can add one more coin to make sum x. 42 | Thus total no. of coins would become (1 + F(x - c2)). 43 | ... and so on. 44 | 45 | This is the idea of a simple recursion. Now lets move on to the base terminating conditions. 46 | CASE 1 - x < 0, this could not be achieved so the minimum no. of coins would be INFINITE (not 0). 47 | CASE 2 - x == 0, this is our win condition, as x equals to 0 means that the sum was achieved, thus 48 | we return 0 in this case. 49 | 50 | At last, we simply memoize our code to improve the time complexity. 51 | */ 52 | 53 | ll n, x, ci[101], memo[10 * N]; 54 | 55 | ll solve(ll v) 56 | { 57 | if (v < 0) 58 | return oo; 59 | if (v == 0) 60 | return 0; 61 | 62 | if (memo[v] != -1) 63 | return memo[v]; 64 | 65 | ll res = oo; 66 | fo(i, 0, n) 67 | res = min(res, solve(v - ci[i])); 68 | 69 | return memo[v] = 1 + res; 70 | } 71 | 72 | signed main() 73 | { 74 | fastIO; 75 | mem(memo, -1); 76 | cin >> n >> x; 77 | fo(i, 0, n) cin >> ci[i]; 78 | 79 | ll res = solve(x); 80 | if (res >= oo) 81 | cout << "-1"; 82 | else 83 | cout << res; 84 | return 0; 85 | } -------------------------------------------------------------------------------- /Dynamic Programming/Money_Sums.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | int n; 26 | cin >> n; 27 | vi a(n); 28 | fo(i, n) cin >> a[i]; 29 | 30 | int sum = accumulate(a.begin(), a.end(), 0); 31 | int dp[sum + 1]; 32 | memset(dp, 0, sizeof(dp)); 33 | dp[0] = 1; 34 | 35 | for(int i = 0; i < n; ++i) { 36 | for(int j = sum; j >= a[i]; --j) 37 | if(dp[j - a[i]] == 1) 38 | dp[j] = 1; 39 | } 40 | 41 | cout << accumulate(dp, dp + sum, 0) << endl; 42 | fo(i, sum) { 43 | if(dp[i + 1] == 1) 44 | cout << i + 1 << " "; 45 | } 46 | 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Dynamic Programming/Projects.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() {} 35 | 36 | signed main() 37 | { 38 | fastIO; 39 | ll n; 40 | map com; 41 | cin >> n; 42 | vll a(n), b(n), c(n); 43 | fo(i, 0, n) 44 | { 45 | cin >> a[i] >> b[i] >> c[i]; 46 | b[i]++; 47 | com[a[i]], com[b[i]]; 48 | } 49 | 50 | ll coords = 0; 51 | for (auto &v : com) 52 | v.second = coords++; 53 | 54 | vector> proj(coords); 55 | fo(i, 0, n) proj[com[b[i]]].emplace_back(com[a[i]], c[i]); 56 | 57 | vll dp(coords, 0); 58 | fo(i, 0, coords) 59 | { 60 | if (i > 0) 61 | dp[i] = dp[i - 1]; 62 | for (auto x : proj[i]) 63 | dp[i] = max(dp[i], dp[x.fi] + x.se); 64 | } 65 | 66 | cout << dp[coords - 1] << endl; 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Dynamic Programming/Rectangle_Cutting.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | long a, b; 26 | cin >> a >> b; 27 | 28 | vector dp(a + 1); 29 | fo(i, a + 1) dp[i].resize(b + 1, 0); 30 | 31 | for(long i = 1; i <= a; ++i) { 32 | for(long j = 1; j <= b; ++j) { 33 | if(i == j) 34 | continue; 35 | long mini = INT_MAX; 36 | for(long k = 1; k < i; ++k) 37 | mini = min(mini, dp[k][j] + dp[i - k][j] + 1); 38 | for(long k = 1; k < j; ++k) 39 | mini = min(mini, dp[i][k] + dp[i][j - k] + 1); 40 | dp[i][j] = mini; 41 | } 42 | } 43 | 44 | cout << dp[a][b]; 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Dynamic Programming/Removal_Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | long n; 26 | ll sum = 0; 27 | cin >> n; 28 | vll a(n); 29 | fo(i, n) 30 | { 31 | cin >> a[i]; 32 | sum += a[i]; 33 | } 34 | 35 | vector dp(n, vll(n, 0)); 36 | for (long l = n - 1; l >= 0; --l) 37 | { 38 | for (long r = l; r < n; ++r) 39 | { 40 | if (l == r) 41 | dp[l][r] = a[l]; 42 | else 43 | dp[l][r] = max(a[l] - dp[l + 1][r], a[r] - dp[l][r - 1]); 44 | } 45 | } 46 | cout << (sum + dp[0][n - 1]) / 2 << endl; 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Dynamic Programming/Removing_Digits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n, i; 17 | cin >> n; 18 | long dp[n + 1]; 19 | dp[0] = 0; 20 | for(i = 1; i <= n; ++i) { 21 | long min = INT_MAX, t = i; 22 | while(t) { 23 | if(t % 10 != 0 && 1 + dp[i - t % 10] < min) 24 | min = 1 + dp[i - t % 10]; 25 | t /= 10; 26 | } 27 | dp[i] = min; 28 | } 29 | cout << dp[n] << endl; 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Dynamic Programming/Two_Sets_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | ll n; 26 | cin >> n; 27 | ll S = n * (n + 1) / 2; 28 | if(S % 2 != 0) { 29 | cout << "0"; 30 | exit(0); 31 | } 32 | S /= 2; 33 | ll dp[n + 1][S + 1]; 34 | memset(dp, 0, sizeof(dp)); 35 | 36 | dp[0][0] = 1; 37 | for(long i = 1; i < n + 1; ++i) { 38 | for(long j = 1; j < S + 1; ++j) { 39 | dp[i][j] = dp[i - 1][j]; 40 | if(j - i >= 0) 41 | dp[i][j] += dp[i - 1][j - i]; 42 | dp[i][j] %= 1000000007; 43 | } 44 | } 45 | 46 | cout << dp[n][S]; 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Dynamic Programming/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Dynamic Programming/a.out -------------------------------------------------------------------------------- /Geometry/Point_Location_Test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | bool isLeft(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) 24 | { 25 | return ((y2 - y1) * (x3 - x1) - (y3 - y1) * (x2 - x1)) < 0; 26 | } 27 | 28 | bool isRight(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) 29 | { 30 | return ((y2 - y1) * (x3 - x1) - (y3 - y1) * (x2 - x1)) > 0; 31 | } 32 | 33 | void solve() 34 | { 35 | ll x1, x2, x3, y1, y2, y3; 36 | cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; 37 | 38 | if (isLeft(x1, y1, x2, y2, x3, y3)) 39 | cout << "LEFT\n"; 40 | else if (isRight(x1, y1, x2, y2, x3, y3)) 41 | cout << "RIGHT\n"; 42 | else 43 | cout << "TOUCH\n"; 44 | } 45 | 46 | int main() 47 | { 48 | fast; 49 | long t; 50 | cin >> t; 51 | while (t--) 52 | solve(); 53 | return 0; 54 | } -------------------------------------------------------------------------------- /Geometry/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Geometry/a.out -------------------------------------------------------------------------------- /Graph Algorithms/Building_Roads.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | /* 35 | This problem can be solved using concept of connected components. 36 | First step towards solving it, is to determine the cluster of cities which need to be connected, which 37 | are just disconnected components in a graph. After determining these fragments, the task is 38 | to connect them with minimum roads, which can be achieved by placing these fragments in a line 39 | & joining the adjacent clusters with a road. 40 | 41 | EXAMPLE - 42 | 1 1 1----2 2 3------4 43 | 1 1 2-----3 3 ,here same number denotes nodes in same fragment 44 | 45 | We can see that, if there are n disconnected fragments, they can be connected by using minimum 46 | (n - 1) roads. Just take a node from a cluster and print it to show which cities are the 47 | ends of the newly constructed road. 48 | 49 | Articles - 50 | > https://cp-algorithms.com/graph/search-for-connected-components.html 51 | > https://www.geeksforgeeks.org/connected-components-in-an-undirected-graph/ 52 | */ 53 | 54 | vi adj[N], res; 55 | int n, m; 56 | 57 | void dfs(int s, vb &vis) 58 | { 59 | vis[s] = 1; 60 | for (auto &e : adj[s]) 61 | { 62 | if (!vis[e]) 63 | dfs(e, vis); 64 | } 65 | } 66 | 67 | signed main() 68 | { 69 | int ai, bi; 70 | cin >> n >> m; 71 | vb vis(n + 1, 0); 72 | fo(i, 0, m) 73 | { 74 | cin >> ai >> bi; 75 | adj[ai].pb(bi); 76 | adj[bi].pb(ai); 77 | } 78 | 79 | fo(i, 1, n + 1) 80 | { 81 | if (!vis[i]) 82 | { 83 | res.pb(i); 84 | dfs(i, vis); 85 | } 86 | } 87 | 88 | cout << res.size() - 1 << endl; 89 | fo(i, 1, res.size()) cout << res[i] << " " << res[i - 1] << endl; 90 | return 0; 91 | } -------------------------------------------------------------------------------- /Graph Algorithms/Building_Teams.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | vector g; 23 | vb vis; 24 | vl team; 25 | queue q; 26 | bool f = true; 27 | 28 | void bfs(long n) { 29 | 30 | q.push(n); 31 | team[n] = 1; 32 | vis[n] = true; 33 | 34 | while(!q.empty()) { 35 | long p = q.front(); 36 | q.pop(); 37 | for(long i = 0; f && i < g[p].size(); ++i) { 38 | if(!vis[g[p][i]]) { 39 | if(team[p] == 1) 40 | team[g[p][i]] = 2; 41 | else 42 | team[g[p][i]] = 1; 43 | q.push(g[p][i]); 44 | vis[g[p][i]] = true; 45 | } 46 | else { 47 | if(team[g[p][i]] == team[p]) 48 | f = false; 49 | } 50 | } 51 | } 52 | } 53 | 54 | int main() 55 | { 56 | fast; 57 | long n, m, a, b; 58 | cin >> n >> m; 59 | 60 | g.resize(n + 1); 61 | vis.resize(n + 1, false); 62 | team.resize(n + 1, -1); 63 | 64 | fo(i, m) { 65 | cin >> a >> b; 66 | g[a].push_back(b); 67 | g[b].push_back(a); 68 | } 69 | 70 | for(long i = 1; f && i <= n; ++i) { 71 | if(!vis[i]) 72 | bfs(i); 73 | } 74 | 75 | if(!f) 76 | cout << "IMPOSSIBLE"; 77 | else 78 | fo(i, n) cout << team[i + 1] << " "; 79 | 80 | return 0; 81 | } -------------------------------------------------------------------------------- /Graph Algorithms/Course_Schedule.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | long n, m, a, b; 23 | vector adj; 24 | bool f = true; 25 | vi vis; 26 | stack st; 27 | 28 | void dfs(long n) 29 | { 30 | vis[n] = 1; 31 | for (auto edge : adj[n]) 32 | { 33 | if (vis[edge] == 0) 34 | dfs(edge); 35 | else if (vis[edge] == 1) 36 | { 37 | f = false; 38 | return; 39 | } 40 | } 41 | st.push(n); 42 | vis[n] = 2; 43 | } 44 | 45 | void topological_sort() 46 | { 47 | for (long i = 1; f && i <= n; ++i) 48 | { 49 | if (vis[i] == 0) 50 | dfs(i); 51 | } 52 | 53 | if (!f) 54 | { 55 | cout << "IMPOSSIBLE\n"; 56 | return; 57 | } 58 | while (!st.empty()) 59 | { 60 | cout << st.top() << " "; 61 | st.pop(); 62 | } 63 | } 64 | 65 | int main() 66 | { 67 | fast; 68 | cin >> n >> m; 69 | adj.resize(n + 1); 70 | vis.resize(n + 1, 0); 71 | 72 | for (long i = 0; i < m; ++i) 73 | { 74 | cin >> a >> b; 75 | adj[a].push_back(b); 76 | } 77 | 78 | topological_sort(); 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Graph Algorithms/Flight_Discount.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, m, u, v, w; 35 | 36 | void djikstra(vector> &adj, vll &dist, long s) 37 | { 38 | dist[s] = 0; 39 | priority_queue, greater> pq; 40 | pq.push({0, s}); 41 | 42 | while (!pq.empty()) 43 | { 44 | long v = pq.top().se, dv = pq.top().fi; 45 | pq.pop(); 46 | 47 | if (dv != dist[v]) 48 | continue; 49 | 50 | for (auto e : adj[v]) 51 | { 52 | long to = e.fi, len = e.se; 53 | if (dist[v] + len < dist[to]) 54 | { 55 | dist[to] = dist[v] + len; 56 | pq.push({dist[to], to}); 57 | } 58 | } 59 | } 60 | } 61 | 62 | void solution() 63 | { 64 | cin >> n >> m; 65 | vector> adj1(n + 1), adj2(n + 1); 66 | fo(i, 0, m) 67 | { 68 | cin >> u >> v >> w; 69 | adj1[u].pb({v, w}); 70 | adj2[v].pb({u, w}); 71 | } 72 | 73 | vll dist1(n + 1, oo), dist2(n + 1, oo); 74 | djikstra(adj1, dist1, 1); 75 | djikstra(adj2, dist2, n); 76 | 77 | ll res = oo; 78 | fo(i, 1, n + 1) 79 | { 80 | for (auto e : adj1[i]) 81 | res = min(res, dist1[i] + e.se / 2 + dist2[e.fi]); 82 | for (auto e : adj2[i]) 83 | res = min(res, dist2[i] + e.se / 2 + dist1[e.fi]); 84 | } 85 | cout << res; 86 | } 87 | 88 | signed main() 89 | { 90 | fastIO; 91 | solution(); 92 | return 0; 93 | } -------------------------------------------------------------------------------- /Graph Algorithms/Flight_Routes_Check.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void setIO(string s) { 5 | freopen((s + ".in").c_str(), "r", stdin); 6 | freopen((s + ".out").c_str(), "w", stdout); 7 | } 8 | 9 | int n, m, u, v; 10 | vector> adj, adjr; 11 | vector vis; 12 | vector order, comp; 13 | 14 | void dfs1(int ver) { 15 | vis[ver] = true; 16 | for(auto &ed : adj[ver]) 17 | if(!vis[ed]) dfs1(ed); 18 | order.push_back(ver); 19 | } 20 | 21 | void dfs2(int ver) { 22 | vis[ver] = true; 23 | comp.push_back(ver); 24 | for(auto &ed : adjr[ver]) 25 | if(!vis[ed]) dfs2(ed); 26 | } 27 | 28 | int main() { 29 | cin >> n >> m; 30 | adj.resize(n); 31 | adjr.resize(n); 32 | vis.assign(n, false); 33 | 34 | for(int i = 0; i < m; ++i) { 35 | cin >> u >> v; 36 | --u, --v; 37 | adj[u].push_back(v); 38 | adjr[v].push_back(u); 39 | } 40 | for(int i = 0; i < n; ++i) 41 | if(!vis[i]) dfs1(i); 42 | 43 | vis.assign(n, false); 44 | reverse(order.begin(), order.end()); 45 | 46 | dfs2(order[0]); 47 | if(comp.size() == n) cout << "YES"; 48 | else { 49 | cout << "NO\n"; 50 | bool f = 1; 51 | int u = -1, v = -1; 52 | for(int i = 0; i < n && f; ++i) { 53 | if(vis[i]) u = i; 54 | else v = i; 55 | for(int &ed : adj[i]) { 56 | if(vis[i] && !vis[ed]) { 57 | cout << ed + 1 << " " << i + 1; 58 | f = 0; 59 | break; 60 | } 61 | if(!vis[i] && vis[ed]) { 62 | cout << i + 1 << " " << ed + 1; 63 | f = 0; 64 | break; 65 | } 66 | } 67 | } 68 | 69 | if(f) 70 | cout << u + 1 << " " << v + 1; 71 | } 72 | 73 | return 0; 74 | } -------------------------------------------------------------------------------- /Graph Algorithms/High_Score.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, m, u, v, w; 35 | 36 | void dfs(vector> &adj, vb &vis, long s) 37 | { 38 | vis[s] = true; 39 | for (auto i : adj[s]) 40 | { 41 | if (!vis[i]) 42 | dfs(adj, vis, i); 43 | } 44 | } 45 | 46 | void solution() 47 | { 48 | cin >> n >> m; 49 | vector> adj1(n + 1), adj2(n + 1); 50 | vector> e(m); 51 | fo(i, 0, m) 52 | { 53 | cin >> u >> v >> w; 54 | adj1[u].pb(v); 55 | adj2[v].pb(u); 56 | e[i] = {u, v, -w}; 57 | } 58 | vb vis1(n + 1), vis2(n + 1); 59 | dfs(adj1, vis1, 1); 60 | dfs(adj2, vis2, n); 61 | 62 | vll dist(n + 1, oo); 63 | dist[1] = 0; 64 | bool flag = 0; 65 | 66 | fo(i, 0, n) 67 | { 68 | flag = 0; 69 | for (auto x : e) 70 | { 71 | tie(u, v, w) = x; 72 | if (vis1[u] && vis2[v] && dist[u] + w < dist[v]) 73 | { 74 | flag = true; 75 | dist[v] = dist[u] + w; 76 | } 77 | } 78 | } 79 | if (flag) 80 | cout << "-1"; 81 | else 82 | cout << -1 * dist[n]; 83 | } 84 | 85 | signed main() 86 | { 87 | fastIO; 88 | solution(); 89 | return 0; 90 | } -------------------------------------------------------------------------------- /Graph Algorithms/Message_Route.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | vector g; 23 | vb vis; 24 | vl par; 25 | queue q; 26 | 27 | void bfs(long n) { 28 | q.push(n); 29 | par[n] = -1; 30 | vis[n] = true; 31 | 32 | while(!q.empty()) { 33 | long p = q.front(); 34 | q.pop(); 35 | for(long i = 0; i < g[p].size(); ++i) { 36 | if(!vis[g[p][i]]) { 37 | par[g[p][i]] = p; 38 | q.push(g[p][i]); 39 | vis[g[p][i]] = true; 40 | } 41 | } 42 | } 43 | } 44 | 45 | void printRoute(long n) { 46 | vl path; 47 | long p = n; 48 | while(p != -1) { 49 | path.push_back(p); 50 | p = par[p]; 51 | } 52 | 53 | reverse(path.begin(), path.end()); 54 | cout << path.size() << endl; 55 | fo(i, path.size()) cout << path[i] << " "; 56 | } 57 | 58 | int main() 59 | { 60 | fast; 61 | long n, m, a, b; 62 | cin >> n >> m; 63 | 64 | g.resize(n + 1); 65 | vis.resize(n + 1, false); 66 | par.resize(n + 1, -1); 67 | 68 | fo(i, m) { 69 | cin >> a >> b; 70 | g[a].push_back(b); 71 | g[b].push_back(a); 72 | } 73 | 74 | bfs(1); 75 | 76 | if(par[n] == -1) 77 | cout << "IMPOSSIBLE"; 78 | else 79 | printRoute(n); 80 | return 0; 81 | } -------------------------------------------------------------------------------- /Graph Algorithms/Planets_Queries_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | const ll sz = 2 * N; 58 | const ll v = 31; 59 | 60 | int n, q, suc[sz][v], t[sz]; 61 | 62 | void pre() { 63 | fo(i,0,n) cin >> t[i]; 64 | 65 | fo(i,0,n) suc[i][0] = --t[i]; 66 | fo(i,1,v) 67 | fo(j,0,n) 68 | suc[j][i] = suc[suc[j][i - 1]][i - 1]; 69 | } 70 | 71 | void solution(int testno) { 72 | cin >> n >> q; 73 | pre(); 74 | 75 | while(q--) { 76 | int x, k; 77 | cin >> x >> k; 78 | --x; 79 | rfo(i,v-1,0) if(k >> i & 1) x = suc[x][i]; 80 | printf("%d\n", x + 1); 81 | } 82 | } 83 | 84 | signed main() 85 | { 86 | fastIO; 87 | ll test = 1; 88 | 89 | fo(i, 1, test + 1) 90 | solution(i); 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Graph Algorithms/Planets_Queries_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout << fixed << setprecision(6); 17 | 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | typedef pair pll; 22 | typedef vector vi; 23 | typedef vector vll; 24 | typedef vector vb; 25 | typedef vector vvb; 26 | typedef vector vvi; 27 | typedef vector vvll; 28 | 29 | void __print(int x) {cerr << x;} 30 | void __print(long x) {cerr << x;} 31 | void __print(long long x) {cerr << x;} 32 | void __print(unsigned x) {cerr << x;} 33 | void __print(unsigned long x) {cerr << x;} 34 | void __print(unsigned long long x) {cerr << x;} 35 | void __print(float x) {cerr << x;} 36 | void __print(double x) {cerr << x;} 37 | void __print(long double x) {cerr << x;} 38 | void __print(char x) {cerr << '"' << x << '"';} 39 | void __print(const char *x) {cerr << '"' << x << '"';} 40 | void __print(const string &x) {cerr << '"' << x << '"';} 41 | void __print(bool x) {cerr << (x ? "true" : "false");} 42 | 43 | template 44 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 45 | template 46 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 47 | void _print() {cerr << "]" << endl;} 48 | template 49 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 50 | 51 | #ifndef ONLINE_JUDGE 52 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 53 | #else 54 | #define deb(x...) 55 | #endif 56 | 57 | const double PI = 3.1415926535897932384626; 58 | const ll oo = 9e18; 59 | const double EPS = 1e-6; 60 | 61 | void solution(int testno) { 62 | } 63 | 64 | signed main() 65 | { 66 | fastIO; 67 | int test = 1; 68 | cin >> test; 69 | clock_t begin, end; 70 | 71 | fo(i,1,test+1) { 72 | begin = clock(); 73 | solution(i); 74 | end = clock(); 75 | cerr << "[ Case :- " << i << " | Time Taken :- " << ((ld)end - (ld)begin) / CLOCKS_PER_SEC << " ]" << endl; 76 | } 77 | return 0; 78 | } -------------------------------------------------------------------------------- /Graph Algorithms/Road_Reparation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define F first 14 | #define S second 15 | #define fo(i, N) for (long i = 0; i < N; ++i) 16 | #define fos(i, b, N) for (long i = b; i < N; ++i) 17 | #define forr(i, N) for (long i = N; i >= 0; --i) 18 | const double PI = 3.141592653589793238; 19 | const ll oo = 1e18; 20 | #define fast \ 21 | ios_base::sync_with_stdio(false); \ 22 | cin.tie(NULL); 23 | 24 | using namespace std; 25 | 26 | // PRIM'S Algorithm Standard 27 | 28 | vector> adj; 29 | ll n, m; 30 | vll key; 31 | vb vis; 32 | 33 | void solve() 34 | { 35 | ll a, b, c, res = 0; 36 | cin >> n >> m; 37 | adj.resize(n + 1); 38 | key.resize(n + 1, oo); 39 | vis.resize(n + 1, false); 40 | 41 | while (m--) 42 | { 43 | cin >> a >> b >> c; 44 | adj[a].push_back({b, c}); 45 | adj[b].push_back({a, c}); 46 | } 47 | 48 | priority_queue, greater> pq; 49 | key[1] = 0; 50 | pq.push({0, 1}); 51 | 52 | while (!pq.empty()) 53 | { 54 | ll wt = pq.top().first; 55 | ll u = pq.top().second; 56 | pq.pop(); 57 | 58 | if (vis[u]) 59 | continue; 60 | res += wt; 61 | vis[u] = true; 62 | 63 | for (auto x : adj[u]) 64 | { 65 | ll v = x.first; 66 | ll w1 = x.second; 67 | if (!vis[v] && key[v] > w1) 68 | { 69 | key[v] = w1; 70 | pq.push({w1, v}); 71 | } 72 | } 73 | } 74 | 75 | fo(i, n) if (key[i + 1] == oo) 76 | { 77 | cout << "IMPOSSIBLE"; 78 | return; 79 | } 80 | cout << res; 81 | } 82 | 83 | int main() 84 | { 85 | fast; 86 | solve(); 87 | return 0; 88 | } -------------------------------------------------------------------------------- /Graph Algorithms/Round_Trip.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | vector g; 23 | vb vis; 24 | vl par; 25 | 26 | void dfs(long v, long p) { 27 | vis[v] = true; 28 | par[v] = p; 29 | for(long i = 0; i < g[v].size(); ++i) { 30 | if(!vis[g[v][i]]) 31 | dfs(g[v][i], v); 32 | else if(g[v][i] != p) { 33 | vl cycle; 34 | long curr = v; 35 | cycle.push_back(curr); 36 | 37 | while(par[curr] != g[v][i]) { 38 | curr = par[curr]; 39 | cycle.push_back(curr); 40 | } 41 | 42 | cycle.push_back(g[v][i]); 43 | cycle.push_back(v); 44 | 45 | cout << cycle.size() << endl; 46 | for(long i = 0; i < cycle.size(); ++i) 47 | cout << cycle[i] << " "; 48 | exit(0); 49 | } 50 | } 51 | } 52 | 53 | int main() 54 | { 55 | fast; 56 | long n, m, a, b; 57 | cin >> n >> m; 58 | g.resize(n + 1); 59 | vis.resize(n + 1, false); 60 | par.resize(n + 1, -1); 61 | vl res; 62 | 63 | fo(i, m) { 64 | cin >> a >> b; 65 | g[a].push_back(b); 66 | g[b].push_back(a); 67 | } 68 | 69 | for(long i = 1; i <= n; ++i) { 70 | if(!vis[i]) { 71 | dfs(i, -1); 72 | } 73 | } 74 | 75 | cout << "IMPOSSIBLE"; 76 | return 0; 77 | } -------------------------------------------------------------------------------- /Graph Algorithms/Round_Trip_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, m, a, b; 35 | vll adj[N], vis(N, 0), path; 36 | bool f; 37 | 38 | void printPath() 39 | { 40 | ll i = path.size() - 2, cnt = 1; 41 | while (i >= 0 && path[i] != path.back()) 42 | { 43 | cnt++; 44 | i--; 45 | } 46 | cout << cnt + 1 << endl; 47 | while (i < path.size()) 48 | cout << path[i++] << " "; 49 | } 50 | 51 | void dfs(ll src) 52 | { 53 | if (!f) 54 | return; 55 | vis[src] = 1; 56 | path.pb(src); 57 | 58 | for (auto i : adj[src]) 59 | { 60 | if (!f) 61 | return; 62 | if (vis[i] == 0) 63 | dfs(i); 64 | else if (vis[i] == 1) 65 | { 66 | f = 0; 67 | path.pb(i); 68 | printPath(); 69 | return; 70 | } 71 | } 72 | if (!f) 73 | return; 74 | vis[src] = 2; 75 | path.pop_back(); 76 | } 77 | 78 | signed main() 79 | { 80 | fastIO; 81 | f = 1; 82 | cin >> n >> m; 83 | fo(i, 0, m) 84 | { 85 | cin >> a >> b; 86 | adj[a].pb(b); 87 | } 88 | 89 | fo(i, 1, n + 1) 90 | { 91 | if (vis[i] == 0) 92 | { 93 | dfs(i); 94 | if (!f) 95 | return 0; 96 | } 97 | } 98 | cout << "IMPOSSIBLE"; 99 | return 0; 100 | } -------------------------------------------------------------------------------- /Graph Algorithms/Shortest_Routes_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define fo(i, N) for (long i = 0; i < N; ++i) 14 | #define fos(i, b, N) for (long i = b; i < N; ++i) 15 | #define forr(i, N) for (long i = N; i >= 0; --i) 16 | const long long oo = 10e17; 17 | const double PI = 3.141592653589793238; 18 | #define fast \ 19 | ios_base::sync_with_stdio(false); \ 20 | cin.tie(NULL); 21 | 22 | using namespace std; 23 | 24 | ll n, m, a, b, c; 25 | vector> g; 26 | vll dis; 27 | vll p; 28 | 29 | void dijkstra(long s) 30 | { 31 | dis[s] = 0; 32 | priority_queue, greater> q; 33 | q.push({0, s}); 34 | 35 | while (!q.empty()) 36 | { 37 | ll v = q.top().second; 38 | ll dv = q.top().first; 39 | q.pop(); 40 | if (dis[v] != dv) 41 | continue; 42 | 43 | for (auto edge : g[v]) 44 | { 45 | ll to = edge.first; 46 | ll elen = edge.second; 47 | if (dis[v] + elen < dis[to]) 48 | { 49 | dis[to] = dis[v] + elen; 50 | p[to] = v; 51 | q.push({dis[to], to}); 52 | } 53 | } 54 | } 55 | } 56 | 57 | int main() 58 | { 59 | cin >> n >> m; 60 | g.resize(n + 1); 61 | dis.resize(n + 1, oo); 62 | p.resize(n + 1, -1); 63 | 64 | for (long i = 0; i < m; ++i) 65 | { 66 | cin >> a >> b >> c; 67 | g[a].push_back(make_pair(b, c)); 68 | } 69 | 70 | dijkstra(1); 71 | 72 | for (long i = 1; i <= n; ++i) 73 | cout << dis[i] << " "; 74 | 75 | return 0; 76 | } -------------------------------------------------------------------------------- /Graph Algorithms/Shortest_Routes_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define fo(i, N) for (long i = 0; i < N; ++i) 14 | #define fos(i, b, N) for (long i = b; i < N; ++i) 15 | #define forr(i, N) for (long i = N; i >= 0; --i) 16 | const long long oo = 10e17; 17 | const double PI = 3.141592653589793238; 18 | #define fast \ 19 | ios_base::sync_with_stdio(false); \ 20 | cin.tie(NULL); 21 | 22 | using namespace std; 23 | 24 | ll n, m, q; 25 | vector g; 26 | 27 | void floydWarshall() 28 | { 29 | for (long k = 1; k <= n; ++k) 30 | { 31 | for (long i = 1; i <= n; ++i) 32 | { 33 | for (long j = 1; j <= n; ++j) 34 | g[i][j] = min(g[i][j], g[i][k] + g[k][j]); 35 | } 36 | } 37 | } 38 | 39 | int main() 40 | { 41 | fast; 42 | cin >> n >> m >> q; 43 | g.resize(n + 1); 44 | for (long i = 0; i <= n; ++i) 45 | g[i].resize(n + 1, oo); 46 | for (long i = 0; i <= n; ++i) 47 | g[i][i] = 0; 48 | 49 | for (long i = 0; i < m; ++i) 50 | { 51 | ll x, y, k; 52 | cin >> x >> y >> k; 53 | g[x][y] = min(k, g[x][y]); 54 | g[y][x] = min(k, g[y][x]); 55 | } 56 | floydWarshall(); 57 | for (long i = 0; i < q; ++i) 58 | { 59 | long a, b; 60 | cin >> a >> b; 61 | if (g[a][b] == g[b][a] && g[a][b] == oo) 62 | cout << "-1\n"; 63 | else 64 | cout << min(g[a][b], g[b][a]) << endl; 65 | } 66 | return 0; 67 | } -------------------------------------------------------------------------------- /Graph Algorithms/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Graph Algorithms/a.out -------------------------------------------------------------------------------- /Introductory Problems/Apple_Division.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout<=0; --i) 11 | 12 | using namespace std; 13 | 14 | ll rec_min(ll arr[], ll i, ll sumCalc, ll sumTot){ 15 | if(i == 0) 16 | return abs((sumTot - sumCalc) - sumCalc); 17 | 18 | return min(rec_min(arr, i - 1, sumCalc + arr[i - 1], sumTot), rec_min(arr, i -1, sumCalc, sumTot)); 19 | } 20 | 21 | ll find_min(ll arr[], ll n){ 22 | ll sum = 0, i; 23 | for(i = 0; i < n; ++i) 24 | sum += arr[i]; 25 | return rec_min(arr, n, 0, sum); 26 | } 27 | 28 | int main() 29 | { 30 | ios_base::sync_with_stdio(false); 31 | cin.tie(NULL); 32 | ll n,i; 33 | cin >> n; 34 | ll a[n]; 35 | for(i = 0; i < n; ++i) 36 | cin>>a[i]; 37 | cout << find_min(a, n) << endl; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Introductory Problems/Bit _Strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000007 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | Total number of different binary strings of size n = 2 ^ n 16 | - This can be achieved in linear time using the below approach or using 17 | pow() function in c++ 18 | - We can also use BINARY EXPONENTIATION which can calculate a power in logarithmic 19 | time complexity. 20 | 21 | Link for binary exponentiation :- https://cp-algorithms.com/algebra/binary-exp.html 22 | */ 23 | 24 | int main() 25 | { 26 | ios_base::sync_with_stdio(false); 27 | cin.tie(NULL); 28 | long n; 29 | cin >> n; 30 | 31 | ll i, ans = 1; 32 | for (i = 0; i < n; ++i) 33 | { 34 | ans *= 2; 35 | ans = ans % O; 36 | } 37 | cout << ans << endl; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Introductory Problems/Chessboard_and_Queens.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | int ans = 0; 22 | string board[8]; 23 | vb cols(8, false), ldiag(16, false), rdiag(16, false); 24 | 25 | void calculate(int r) 26 | { 27 | if (r == 8) 28 | { 29 | ans++; 30 | return; 31 | } 32 | for (int i = 0; i < 8; ++i) 33 | { 34 | if (board[r][i] == '.') 35 | { 36 | if (!cols[i] && !ldiag[r + i] && !rdiag[r - i + 7]) 37 | { 38 | cols[i] = ldiag[r + i] = rdiag[r - i + 7] = true; 39 | calculate(r + 1); 40 | cols[i] = ldiag[r + i] = rdiag[r - i + 7] = false; 41 | } 42 | } 43 | } 44 | } 45 | 46 | int main() 47 | { 48 | fo(i, 8) cin >> board[i]; 49 | calculate(0); 50 | cout << ans; 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Introductory Problems/Coin_Piles.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout<=0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | long t; 16 | cin>>t; 17 | while(t--){ 18 | ll a,b; 19 | cin >> a >> b; 20 | 21 | ll gr, sm; 22 | if(a > b){ 23 | gr = a; 24 | sm = b; 25 | }else{ 26 | gr = b; 27 | sm = a; 28 | } 29 | ll x; 30 | x = gr - sm; 31 | if(sm - x == gr - 2*x && sm - x >= 0 && (sm - x) % 3 == 0) 32 | cout<< "YES\n"; 33 | else 34 | cout<< "NO\n"; 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Introductory Problems/Creating_Strings_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout<=0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(NULL); 17 | string s; 18 | cin >> s; 19 | vector sol; 20 | sort(s.begin(), s.end()); 21 | sol.push_back(s); 22 | while (next_permutation(s.begin(), s.end())) 23 | sol.push_back(s); 24 | cout << sol.size()< 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | ll ind_pos(ll n, ll pos) 16 | { 17 | ll i = 1; 18 | while (n > 0) 19 | { 20 | ll tmp = n % 10; 21 | if (i == pos) 22 | return tmp; 23 | n /= 10; 24 | ++i; 25 | } 26 | return 0; 27 | } 28 | 29 | int main() 30 | { 31 | ios_base::sync_with_stdio(false); 32 | cin.tie(NULL); 33 | 34 | ll q; 35 | cin >> q; 36 | while (q--) 37 | { 38 | ll n; 39 | cin >> n; 40 | ll digs = 1, curr = 0, c = 1; 41 | 42 | while (n > digs * 9 * c) 43 | { 44 | n -= digs * 9 * c; 45 | digs++; 46 | curr = curr * 10 + 9; 47 | c *= 10; 48 | } 49 | 50 | ll tmp1 = n / digs; 51 | curr += tmp1; 52 | ll tmp2 = n % digs; 53 | 54 | if (tmp2 == 0) 55 | cout << ind_pos(curr, 1); 56 | else 57 | cout << ind_pos(curr + 1, digs - tmp2 + 1); 58 | cout << endl; 59 | } 60 | return 0; 61 | } -------------------------------------------------------------------------------- /Introductory Problems/Gray_Code.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | vector GrayGen(int n) 16 | { 17 | if (n == 1) 18 | { 19 | vector res = {"0", "1"}; 20 | return res; 21 | } 22 | 23 | vector s = GrayGen(n - 1); 24 | vector t(s); 25 | reverse(t.begin(), t.end()); 26 | int m = s.size(); 27 | fo(i, m) s[i] = "0" + s[i]; 28 | fo(i, m) t[i] = "1" + t[i]; 29 | 30 | vector res(2 * m); 31 | merge(s.begin(), s.end(), t.begin(), t.end(), res.begin()); 32 | return res; 33 | } 34 | 35 | int main() 36 | { 37 | ios_base::sync_with_stdio(false); 38 | cin.tie(NULL); 39 | int n; 40 | cin >> n; 41 | vector vs = GrayGen(n); 42 | fo(i, vs.size()) cout << vs[i] << endl; 43 | return 0; 44 | } -------------------------------------------------------------------------------- /Introductory Problems/Increasing_Array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | One of the things to note here is that, you can only increase the value of the element; 16 | therefore if the current element is smaller than the previous element your only option is 17 | to increase the current element to at least the previous value, and that difference is 18 | the answer. 19 | */ 20 | 21 | int main() 22 | { 23 | ios_base::sync_with_stdio(false); 24 | cin.tie(NULL); 25 | long n; 26 | cin >> n; 27 | long a[n], i; 28 | for (i = 0; i < n; ++i) 29 | cin >> a[i]; 30 | long turns = 0, curr = a[0]; 31 | for (i = 1; i < n; ++i) 32 | { 33 | if (a[i] < curr) 34 | { 35 | turns += curr - a[i]; 36 | } 37 | else 38 | curr = a[i]; 39 | } 40 | cout << turns << endl; 41 | return 0; 42 | } -------------------------------------------------------------------------------- /Introductory Problems/Missing_Number.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | Since we will have all the numbers between 1 to n, just take the sum of 16 | all the numbers & subtract it from the sum of series 1 + 2 + 3 + ... + n 17 | 18 | One other easy ways to accomplish this task is to use XOR, by calculating the total 19 | XOR of array elements and XOR of numbers from 1 to n. Final answer is XOR of these two. 20 | */ 21 | 22 | int main() 23 | { 24 | ios_base::sync_with_stdio(false); 25 | cin.tie(NULL); 26 | long n, i, t; 27 | cin >> n; 28 | ll sum = 0; 29 | for (i = 1; i < n; ++i) 30 | { 31 | cin >> t; 32 | sum += t; 33 | } 34 | cout << (n * (n + 1)) / 2 - sum; 35 | return 0; 36 | } -------------------------------------------------------------------------------- /Introductory Problems/Number_Spiral.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(NULL); 17 | long t; 18 | cin >> t; 19 | while (t--) 20 | { 21 | long x, y; 22 | ll val; 23 | cin >> x >> y; 24 | long maxim = max(x, y); 25 | if (maxim == x) 26 | { 27 | if (x % 2 == 0) 28 | { 29 | val = x * x; 30 | val -= y - 1; 31 | } 32 | else 33 | { 34 | x--; 35 | val = x * x; 36 | val += y; 37 | } 38 | } 39 | else 40 | { 41 | if (y % 2 == 1) 42 | { 43 | val = y * y; 44 | val -= x - 1; 45 | } 46 | else 47 | { 48 | y--; 49 | val = y * y; 50 | val += x; 51 | } 52 | } 53 | cout << val << endl; 54 | } 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Introductory Problems/Palindrome_Reorder.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(NULL); 17 | string s; 18 | bool odd = false, solExist = true; 19 | cin >> s; 20 | if (s.size() % 2 != 0) 21 | odd = true; 22 | 23 | ll i, n = s.size(), cnt[26] = {0}; 24 | for (i = 0; i < n; ++i) 25 | cnt[(int)s[i] - 65]++; 26 | 27 | string sol; 28 | char mid; 29 | for (i = 0; i < 26; ++i) 30 | { 31 | if (cnt[i] > 0) 32 | { 33 | if (cnt[i] % 2 == 0) 34 | for (int j = 0; j < cnt[i] / 2; ++j) 35 | sol.push_back('A' + i); 36 | else 37 | { 38 | if (!odd) 39 | { 40 | solExist = false; 41 | break; 42 | } 43 | else 44 | { 45 | mid = 'A' + i; 46 | for (int j = 0; j < cnt[i] / 2; ++j) 47 | sol.push_back('A' + i); 48 | odd = false; 49 | } 50 | } 51 | } 52 | } 53 | 54 | if (!solExist) 55 | { 56 | cout << "NO SOLUTION\n"; 57 | } 58 | else 59 | { 60 | if (n % 2 == 1) 61 | sol.push_back(mid); 62 | 63 | ll start = n % 2 == 0 ? sol.size() - 1 : sol.size() - 2; 64 | while (start >= 0) 65 | { 66 | sol.push_back(sol[start]); 67 | start--; 68 | } 69 | 70 | cout << sol << endl; 71 | } 72 | return 0; 73 | } -------------------------------------------------------------------------------- /Introductory Problems/Permutations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | Constructive Algorithm :- 16 | Observe the condition to make a beautiful array, 17 | 18 | For n = 2, the possible arrays are {1, 2}, {2, 1}, none of which is beautiful 19 | For n = 3, the possible arrays are {1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2}, {3, 2, 1} 20 | none of these is beautiful 21 | For n > 3, beautiful array always exists 22 | Just place all the elements with even value and then place all elements with odd value or vice versa 23 | */ 24 | 25 | int main() 26 | { 27 | ios_base::sync_with_stdio(false); 28 | cin.tie(NULL); 29 | long n; 30 | cin >> n; 31 | if (n == 1) 32 | printf("1\n"); 33 | else if (n == 2 || n == 3) 34 | printf("NO SOLUTION\n"); 35 | else 36 | { 37 | long i; 38 | for (i = 2; i <= n; i += 2) 39 | printf("%ld ", i); 40 | for (i = 1; i <= n; i += 2) 41 | printf("%ld ", i); 42 | } 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /Introductory Problems/Repetitions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | Simple greedy approach :- 16 | Till the previous character is equal to the current character increase the 17 | current sum pointer; When both of these become unequal, capture this value and 18 | restore the current sum pointer to 0. The maximum value among the captured values 19 | is your answer. 20 | */ 21 | 22 | int main() 23 | { 24 | string s; 25 | cin >> s; 26 | long n = s.size(); 27 | char curr = s[0]; 28 | long i, reps = 0, maxim = 0; 29 | for (i = 0; i < n; ++i) 30 | { 31 | if (s[i] == curr) 32 | reps++; 33 | else 34 | { 35 | if (reps > maxim) 36 | maxim = reps; 37 | reps = 1; 38 | curr = s[i]; 39 | } 40 | } 41 | if (reps > maxim) 42 | maxim = reps; 43 | cout << maxim << endl; 44 | return 0; 45 | } -------------------------------------------------------------------------------- /Introductory Problems/Tower_Of_Hanoi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | void TOH(int a, int b, int c, int n) 16 | { 17 | if (n == 1) 18 | { 19 | cout << a << " " << c << endl; 20 | return; 21 | } 22 | 23 | TOH(a, c, b, n - 1); 24 | cout << a << " " << c << endl; 25 | TOH(b, a, c, n - 1); 26 | } 27 | 28 | int main() 29 | { 30 | ios_base::sync_with_stdio(false); 31 | cin.tie(NULL); 32 | int n; 33 | cin >> n; 34 | cout << pow(2, n) - 1 << endl; 35 | TOH(1, 2, 3, n); 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Introductory Problems/Trailing_Zeros.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | 14 | /* 15 | n! = 1 x 2 x 3 x ...x n 16 | we get a 0 at the end of a number only when it is divisible by 10, which means there is 17 | a factor of 5 and 2 behind the generation of a trailing zero. 18 | We also know that number of 2's will always be greater than number of 5's in n! 19 | The only task remains is to count the number of multiples of 5^1, 5^2...5^k , where 5^k <= n, occur 20 | in the value of n! 21 | */ 22 | 23 | int main() 24 | { 25 | ios_base::sync_with_stdio(false); 26 | cin.tie(NULL); 27 | ll t; 28 | cin >> t; 29 | ll f = 5, zeros = 0; 30 | while (f <= t) 31 | { 32 | zeros += t / f; 33 | f *= 5; 34 | } 35 | cout << zeros << endl; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Introductory Problems/Two_Knights.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(NULL); 17 | long t; 18 | cin >> t; 19 | 20 | for (int i = 1; i <= t; ++i) 21 | { 22 | if (i == 1) 23 | cout << "0\n"; 24 | else if (i == 2) 25 | cout << "6\n"; 26 | else 27 | { 28 | ll n = i * i; 29 | cout << (n * (n - 1)) / 2 - 4 * (i - 1) * (i - 2) << endl; 30 | } 31 | } 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Introductory Problems/Two_Sets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | long n; 16 | cin >> n; 17 | ll total = (n * (n + 1)) / 2; 18 | if (total % 2 != 0) 19 | cout << "NO\n"; 20 | else 21 | { 22 | ll target = total / 2, sum1 = 0, sum2 = 0; 23 | vll part1, part2; 24 | while (n != 0) 25 | { 26 | if (n <= target) 27 | { 28 | target -= n; 29 | sum1 += n; 30 | part1.push_back(n); 31 | n--; 32 | } 33 | else 34 | { 35 | sum2 += n; 36 | part2.push_back(n); 37 | n--; 38 | } 39 | } 40 | if (target != 0) 41 | cout << "NO\n"; 42 | else if (sum1 == sum2) 43 | { 44 | cout << "YES\n"; 45 | cout << part1.size() << endl; 46 | for (int i = 0; i < part1.size(); ++i) 47 | cout << part1[i] << " "; 48 | cout << endl; 49 | cout << part2.size() << endl; 50 | for (int i = 0; i < part2.size(); ++i) 51 | cout << part2[i] << " "; 52 | cout << endl; 53 | } 54 | else 55 | cout << "NO\n"; 56 | } 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /Introductory Problems/Weird_Algorithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout << n << endl 8 | #define fo(i, N) for (int i = 0; i < N; ++i) 9 | #define fos(i, b, N) for (int i = b; i < N; ++i) 10 | #define forr(i, N) for (i = N; i >= 0; --i) 11 | 12 | /* 13 | This is a really basic question, just follow the steps its asking you in 14 | the problem itself. The series will always converge at 1. Why? 15 | 16 | EXTRA PROOF :- 17 | Let's take some cases to prove it : 18 | Case 1 : n = 2^k, then number would converge surely 19 | Case 2 : n != 2^k and is even, then after continuosly dividing it by 2 20 | we will surely obtain an odd number. 21 | Case 3 : n != 2^k and is odd, on performing the operation , 22 | - if(n % 4 == 1), the obtained number will be divisible by 4, thus eliminating 23 | the odd set bit in the number 24 | - if(n % 4 == 3), the obtained number will be divisible by 2, the in the next two 25 | steps will generate the above case and eliminate the odd set bit 26 | */ 27 | 28 | using namespace std; 29 | int main() 30 | { 31 | ios_base::sync_with_stdio(false); 32 | cin.tie(NULL); 33 | ll n; 34 | cin >> n; 35 | while (n != 1) 36 | { 37 | printf("%lld ", n); 38 | if (n % 2 == 0) 39 | n /= 2; 40 | else 41 | n = n * 3 + 1; 42 | } 43 | printf("1"); 44 | return 0; 45 | } -------------------------------------------------------------------------------- /Introductory Problems/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Introductory Problems/a.out -------------------------------------------------------------------------------- /Mathematics/Another_Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout << fixed << setprecision(6); 17 | 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | typedef pair pll; 22 | typedef vector vi; 23 | typedef vector vll; 24 | typedef vector vb; 25 | typedef vector vvb; 26 | typedef vector vvi; 27 | typedef vector vvll; 28 | 29 | void __print(int x) {cerr << x;} 30 | void __print(long x) {cerr << x;} 31 | void __print(long long x) {cerr << x;} 32 | void __print(unsigned x) {cerr << x;} 33 | void __print(unsigned long x) {cerr << x;} 34 | void __print(unsigned long long x) {cerr << x;} 35 | void __print(float x) {cerr << x;} 36 | void __print(double x) {cerr << x;} 37 | void __print(long double x) {cerr << x;} 38 | void __print(char x) {cerr << '"' << x << '"';} 39 | void __print(const char *x) {cerr << '"' << x << '"';} 40 | void __print(const string &x) {cerr << '"' << x << '"';} 41 | void __print(bool x) {cerr << (x ? "true" : "false");} 42 | 43 | template 44 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 45 | template 46 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 47 | void _print() {cerr << "]" << endl;} 48 | template 49 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 50 | 51 | #ifndef ONLINE_JUDGE 52 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 53 | #else 54 | #define deb(x...) 55 | #endif 56 | 57 | const double PI = 3.1415926535897932384626; 58 | const ll oo = 9e18; 59 | const double EPS = 1e-6; 60 | 61 | void solution(int testno) { 62 | int n, cnt = 0, x; 63 | cin >> n; 64 | fo(i,0,n) { 65 | cin >> x; 66 | cnt += (x % 2); 67 | } 68 | 69 | if(cnt) cout << "first"; 70 | else cout << "second"; 71 | cout << endl; 72 | } 73 | 74 | signed main() 75 | { 76 | fastIO; 77 | int test = 1; 78 | cin >> test; 79 | clock_t begin, end; 80 | 81 | fo(i,1,test+1) { 82 | begin = clock(); 83 | solution(i); 84 | end = clock(); 85 | 86 | // cerr << "[ Case :- " << i << " | Time Taken :- " << ((ld)end - (ld)begin) / CLOCKS_PER_SEC << " ]" << endl; 87 | } 88 | return 0; 89 | } -------------------------------------------------------------------------------- /Mathematics/Binomial_Coefficients.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | const ll V = 10 * N; 34 | 35 | ll a, b, t; 36 | ll fact[V]; 37 | 38 | ll binPow(ll a, ll n) 39 | { 40 | ll res = 1; 41 | while (n) 42 | { 43 | if (n & 1) 44 | res = (res * a) % MOD; 45 | a = (a * a) % MOD; 46 | n >>= 1; 47 | } 48 | return res; 49 | } 50 | 51 | void solution() 52 | { 53 | cin >> a >> b; 54 | ll num = fact[a], deno = binPow((fact[b] * fact[a - b]) % MOD, MOD - 2); 55 | cout << (num * deno) % MOD << endl; 56 | } 57 | 58 | signed main() 59 | { 60 | fastIO; 61 | fact[0] = fact[1] = 1; 62 | fo(i, 2, V) fact[i] = (fact[i - 1] * i) % MOD; 63 | 64 | cin >> t; 65 | while (t--) 66 | solution(); 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Mathematics/Bracket_Sequences_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll fact[20 * N]; 35 | 36 | ll binPow(ll a, ll n) 37 | { 38 | ll res = 1; 39 | while (n) 40 | { 41 | if (n & 1) 42 | res = (res * a) % MOD; 43 | a = (a * a) % MOD; 44 | n >>= 1; 45 | } 46 | return res; 47 | } 48 | 49 | void solution() 50 | { 51 | fact[0] = fact[1] = 1; 52 | fo(i, 2, 20 * N) fact[i] = (fact[i - 1] * i) % MOD; 53 | 54 | ll n; 55 | cin >> n; 56 | if (n & 1) 57 | { 58 | cout << "0"; 59 | return; 60 | } 61 | 62 | n /= 2; 63 | ll den = (fact[n + 1] * fact[n]) % MOD; 64 | cout << (fact[2 * n] * binPow(den, MOD - 2)) % MOD; 65 | } 66 | 67 | signed main() 68 | { 69 | fastIO; 70 | solution(); 71 | return 0; 72 | } -------------------------------------------------------------------------------- /Mathematics/Candy_Lottery.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout << fixed << setprecision(6); 17 | 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | typedef pair pll; 22 | typedef vector vi; 23 | typedef vector vll; 24 | typedef vector vb; 25 | typedef vector vvb; 26 | typedef vector vvi; 27 | typedef vector vvll; 28 | 29 | void __print(int x) {cerr << x;} 30 | void __print(long x) {cerr << x;} 31 | void __print(long long x) {cerr << x;} 32 | void __print(unsigned x) {cerr << x;} 33 | void __print(unsigned long x) {cerr << x;} 34 | void __print(unsigned long long x) {cerr << x;} 35 | void __print(float x) {cerr << x;} 36 | void __print(double x) {cerr << x;} 37 | void __print(long double x) {cerr << x;} 38 | void __print(char x) {cerr << '"' << x << '"';} 39 | void __print(const char *x) {cerr << '"' << x << '"';} 40 | void __print(const string &x) {cerr << '"' << x << '"';} 41 | void __print(bool x) {cerr << (x ? "true" : "false");} 42 | 43 | template 44 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 45 | template 46 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 47 | void _print() {cerr << "]" << endl;} 48 | template 49 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 50 | 51 | #ifndef ONLINE_JUDGE 52 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 53 | #else 54 | #define deb(x...) 55 | #endif 56 | 57 | const double PI = 3.1415926535897932384626; 58 | const ll oo = 9e18; 59 | const double EPS = 1e-6; 60 | 61 | ld binPow(ld a, ll n) { 62 | ld res = 1.0; 63 | while(n) { 64 | if(n & 1) res = res * a; 65 | a = a * a; 66 | n >>= 1; 67 | } 68 | return res; 69 | } 70 | 71 | signed main() 72 | { 73 | fastIO; 74 | ld n, k; 75 | cin >> n >> k; 76 | ld res = 0.0; 77 | fo(i,1,k+1) res += i * (binPow(i / k, n) - binPow((i - 1) / k, n)); 78 | cout << res; 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Mathematics/Christmas_Party.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | // number of derangements 59 | 60 | void solution() { 61 | ll n; 62 | cin >> n; 63 | 64 | vll dp(n + 1, 0); 65 | dp[0] = 1; 66 | 67 | fo(i, 2, n + 1) 68 | dp[i] = ((dp[i - 1] + dp[i - 2]) * (i - 1)) % MOD; 69 | cout << dp[n]; 70 | } 71 | 72 | signed main() 73 | { 74 | fastIO; 75 | long t = 1; 76 | // cin >> t; 77 | while (t--) 78 | solution(); 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Mathematics/Common_Divisors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | vll cnt(1000000, 0); 24 | 25 | int main() 26 | { 27 | long n; 28 | cin >> n; 29 | vl a(n); 30 | fo(i, n) 31 | { 32 | cin >> a[i]; 33 | cnt[a[i]]++; 34 | } 35 | 36 | for (long i = 1000000; i >= 1; --i) 37 | { 38 | ll d = 0; 39 | for (long j = i; j <= 1000000; j += i) 40 | d += cnt[j]; 41 | if (d >= 2) 42 | { 43 | cout << i; 44 | return 0; 45 | } 46 | } 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Mathematics/Counting_Divisors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000007 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | int main() 16 | { 17 | ios_base::sync_with_stdio(false); 18 | cin.tie(NULL); 19 | long n, x; 20 | 21 | vl dp(1000001, 0); 22 | for(long i = 1; i <= 1000000; ++i) 23 | for(long j = i; j <= 1000000; j += i) 24 | dp[j]++; 25 | 26 | cin >> n; 27 | for(long i = 0; i < n; ++i) { 28 | cin >> x; 29 | cout << dp[x] << endl; 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Mathematics/Counting_Necklaces.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | // Orbit counting theorem or burnside's lemma 59 | 60 | ll n, m; 61 | 62 | ll binPow(ll a, ll n) { 63 | ll res = 1; 64 | while(n) { 65 | if(n & 1) res = (res * a) % MOD; 66 | a = (a * a) % MOD; 67 | n >>= 1; 68 | } 69 | return res; 70 | } 71 | 72 | void solution() { 73 | ll res = 0; 74 | cin >> n >> m; 75 | fo(i,0,n) { 76 | ll k = __gcd(n, (ll)i); 77 | res = (res + binPow(m, k)) % MOD; 78 | } 79 | res = (res * binPow(n, MOD - 2)) % MOD; 80 | cout << res; 81 | } 82 | 83 | signed main() 84 | { 85 | fastIO; 86 | long t = 1; 87 | // cin >> t; 88 | while (t--) 89 | solution(); 90 | return 0; 91 | } -------------------------------------------------------------------------------- /Mathematics/Creating_Strings_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | string s; 35 | ll fact[10 * N]; 36 | 37 | ll binPow(ll a, ll n) 38 | { 39 | ll res = 1; 40 | while (n) 41 | { 42 | if (n & 1) 43 | res = (res * a) % MOD; 44 | a = (a * a) % MOD; 45 | n >>= 1; 46 | } 47 | return res; 48 | } 49 | 50 | void solution() 51 | { 52 | cin >> s; 53 | ll n = s.size(); 54 | fact[0] = fact[1] = 1; 55 | fo(i, 2, 10 * N) fact[i] = (fact[i - 1] * i) % MOD; 56 | 57 | vll cnt(26, 0); 58 | fo(i, 0, n) cnt[s[i] - 'a']++; 59 | ll res = fact[n], inv = 1; 60 | fo(i, 0, 26) 61 | { 62 | if (cnt[i] > 1) 63 | inv = (inv * fact[cnt[i]]) % MOD; 64 | } 65 | res = (res * binPow(inv, MOD - 2)) % MOD; 66 | cout << res; 67 | } 68 | 69 | signed main() 70 | { 71 | fastIO; 72 | solution(); 73 | return 0; 74 | } -------------------------------------------------------------------------------- /Mathematics/Dice_Probability.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | void solution(ll testno) { 59 | // 60 | } 61 | 62 | signed main() 63 | { 64 | fastIO; 65 | ll test = 1; 66 | // cin >> test; 67 | fo(i, 1, test + 1) 68 | solution(i); 69 | return 0; 70 | } -------------------------------------------------------------------------------- /Mathematics/Distributing_Apples.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll fact[20 * N]; 35 | 36 | ll binPow(ll a, ll n) 37 | { 38 | ll res = 1; 39 | while (n) 40 | { 41 | if (n & 1) 42 | res = (res * a) % MOD; 43 | a = (a * a) % MOD; 44 | n >>= 1; 45 | } 46 | return res; 47 | } 48 | 49 | void solution() 50 | { 51 | fact[0] = fact[1] = 1; 52 | fo(i, 2, 20 * N) fact[i] = (fact[i - 1] * i) % MOD; 53 | 54 | ll n, m; 55 | cin >> n >> m; 56 | ll den = (fact[m] * fact[n - 1]) % MOD; 57 | cout << (fact[m + n - 1] * binPow(den, MOD - 2)) % MOD; 58 | } 59 | 60 | signed main() 61 | { 62 | fastIO; 63 | solution(); 64 | return 0; 65 | } -------------------------------------------------------------------------------- /Mathematics/Divisor_Analysis.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, a[N][2], r1, r2, r3; 35 | 36 | ll binPow(ll a, ll n) 37 | { 38 | ll res = 1; 39 | 40 | while (n) 41 | { 42 | if (n & 1) 43 | res = (res * a) % MOD; 44 | a = (a * a) % MOD; 45 | n >>= 1; 46 | } 47 | return res; 48 | } 49 | 50 | ll inverse(ll val) 51 | { 52 | if (val <= 1) 53 | return val; 54 | return binPow(val, MOD - 2) % MOD; 55 | } 56 | 57 | ll funcR2(ll val, ll po) 58 | { 59 | ll inv = inverse(val - 1); 60 | return ((binPow(val, po) - 1) * inv) % MOD; 61 | } 62 | 63 | signed main() 64 | { 65 | fastIO; 66 | r1 = r2 = r3 = 1; 67 | ll cnt = 1; 68 | cin >> n; 69 | fo(i, 0, n) 70 | { 71 | cin >> a[i][0] >> a[i][1]; 72 | r1 = (r1 * (a[i][1] + 1)) % MOD; 73 | r2 = (r2 * funcR2(a[i][0], a[i][1] + 1)) % MOD; 74 | r3 = binPow(r3, a[i][1] + 1) * binPow(binPow(a[i][0], a[i][1] * (a[i][1] + 1) / 2), cnt) % MOD; 75 | cnt = cnt * (a[i][1] + 1) % (MOD - 1); 76 | } 77 | 78 | cout << r1 << " " << r2 << " " << r3; 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Mathematics/Exponentiation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000007 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | int main() 16 | { 17 | long n; 18 | cin >> n; 19 | while (n--) 20 | { 21 | ll a, b; 22 | cin >> a >> b; 23 | ll res = 1, fac = a; 24 | while (b) 25 | { 26 | if (b % 2 == 1) 27 | { 28 | res = (res * fac) % O; 29 | b--; 30 | continue; 31 | } 32 | 33 | fac = (fac * fac) % O; 34 | b /= 2; 35 | } 36 | 37 | cout << res << endl; 38 | } 39 | return 0; 40 | } -------------------------------------------------------------------------------- /Mathematics/Exponentiation_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000007 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | ll exponent(ll a, ll b, ll mod) 16 | { 17 | ll res = 1, fac = a; 18 | while (b) 19 | { 20 | if (b % 2 == 1) 21 | { 22 | res = (res * fac) % mod; 23 | b--; 24 | continue; 25 | } 26 | 27 | fac = (fac * fac) % mod; 28 | b /= 2; 29 | } 30 | 31 | return res; 32 | } 33 | 34 | int main() 35 | { 36 | long n; 37 | cin >> n; 38 | while (n--) 39 | { 40 | ll a, b, c; 41 | cin >> a >> b >> c; 42 | 43 | ll p = exponent(b, c, O -1); //Fermat's Little Theorem 44 | ll res = exponent(a, p, O); 45 | 46 | cout << res << endl; 47 | } 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Mathematics/Fibonacci_Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll mat[2][2] = {{1, 1}, {1, 0}}; 35 | ll res[2][2] = {{1, 0}, {0, 1}}; 36 | 37 | void multiply(ll a[2][2], ll b[2][2]) 38 | { 39 | ll tmp[2][2] = {{0, 0}, {0, 0}}; 40 | fo(i, 0, 2) 41 | { 42 | fo(j, 0, 2) 43 | { 44 | fo(k, 0, 2) 45 | tmp[i][j] = (tmp[i][j] + a[i][k] * b[k][j]) % MOD; 46 | } 47 | } 48 | 49 | fo(i, 0, 2) fo(j, 0, 2) a[i][j] = tmp[i][j]; 50 | } 51 | 52 | void binPow(ll n) 53 | { 54 | while (n) 55 | { 56 | if (n & 1) 57 | multiply(res, mat); 58 | multiply(mat, mat); 59 | n >>= 1; 60 | } 61 | } 62 | 63 | void solution() 64 | { 65 | ll n; 66 | cin >> n; 67 | if (n == 0) 68 | cout << "0"; 69 | else 70 | { 71 | binPow(n); 72 | cout << res[0][1]; 73 | } 74 | } 75 | 76 | signed main() 77 | { 78 | fastIO; 79 | solution(); 80 | return 0; 81 | } -------------------------------------------------------------------------------- /Mathematics/Graph_Paths_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | void solution(ll testno) {} 59 | 60 | signed main() 61 | { 62 | fastIO; 63 | ll test = 1; 64 | cin >> test; 65 | fo(i, 1, test + 1) 66 | solution(i); 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Mathematics/Grundy's_Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 17 | 18 | typedef long long ll; 19 | typedef pair pii; 20 | typedef pair pll; 21 | typedef vector vi; 22 | typedef vector vll; 23 | typedef vector vb; 24 | typedef vector vvb; 25 | typedef vector vvi; 26 | typedef vector vvll; 27 | 28 | void __print(int x) {cerr << x;} 29 | void __print(long x) {cerr << x;} 30 | void __print(long long x) {cerr << x;} 31 | void __print(unsigned x) {cerr << x;} 32 | void __print(unsigned long x) {cerr << x;} 33 | void __print(unsigned long long x) {cerr << x;} 34 | void __print(float x) {cerr << x;} 35 | void __print(double x) {cerr << x;} 36 | void __print(long double x) {cerr << x;} 37 | void __print(char x) {cerr << '"' << x << '"';} 38 | void __print(const char *x) {cerr << '"' << x << '"';} 39 | void __print(const string &x) {cerr << '"' << x << '"';} 40 | void __print(bool x) {cerr << (x ? "true" : "false");} 41 | 42 | template 43 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 44 | template 45 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 46 | void _print() {cerr << "]" << endl;} 47 | template 48 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 49 | 50 | #ifndef ONLINE_JUDGE 51 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 52 | #else 53 | #define deb(x...) 54 | #endif 55 | 56 | const double PI = 3.1415926535897932384626; 57 | const ll oo = 1e18; 58 | 59 | void solution(ll testno) { 60 | ll n; 61 | cin >> n; 62 | // 63 | cout << endl; 64 | } 65 | 66 | signed main() 67 | { 68 | fastIO; 69 | ll test = 1; 70 | cin >> test; 71 | fo(i, 1, test + 1) 72 | solution(i); 73 | return 0; 74 | } -------------------------------------------------------------------------------- /Mathematics/Josephus_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | long joshephusFunc(long n, long k) 24 | { 25 | if (n == 1) 26 | return 1; 27 | if (k <= (n + 1) / 2) 28 | { 29 | if (2 * k > n) 30 | return (2 * k) % n; 31 | else 32 | return 2 * k; 33 | } 34 | long tmp = joshephusFunc(n / 2, k - (n + 1) / 2); 35 | if (n & 1) 36 | return 2 * tmp + 1; 37 | return 2 * tmp - 1; 38 | } 39 | 40 | void solve() 41 | { 42 | long n, k; 43 | cin >> n >> k; 44 | cout << joshephusFunc(n, k) << endl; 45 | } 46 | 47 | int main() 48 | { 49 | fast; 50 | long t; 51 | cin >> t; 52 | while (t--) 53 | solve(); 54 | return 0; 55 | } -------------------------------------------------------------------------------- /Mathematics/Nim_Game_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | ll n, x = 0, v; 37 | cin >> n; 38 | fo(i, 0, n) 39 | { 40 | cin >> v; 41 | x ^= v; 42 | } 43 | if (!x) 44 | cout << "second"; 45 | else 46 | cout << "first"; 47 | cout << endl; 48 | } 49 | 50 | signed main() 51 | { 52 | fastIO; 53 | long t; 54 | cin >> t; 55 | while (t--) 56 | solution(); 57 | return 0; 58 | } -------------------------------------------------------------------------------- /Mathematics/Nim_Game_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | ll n, x = 0, a; 37 | cin >> n; 38 | fo(i, 0, n) 39 | { 40 | cin >> a; 41 | x ^= (a % 4); 42 | } 43 | 44 | if (x) 45 | cout << "first\n"; 46 | else 47 | cout << "second\n"; 48 | } 49 | 50 | signed main() 51 | { 52 | fastIO; 53 | long t; 54 | cin >> t; 55 | while (t--) 56 | solution(); 57 | return 0; 58 | } -------------------------------------------------------------------------------- /Mathematics/Prime_Multiples.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | ll n, k, a[25]; 59 | 60 | void solution() { 61 | cin >> n >> k; 62 | fo(i, 0, k) cin >> a[i]; 63 | 64 | ll res = 0, lim = (1ll << k); 65 | for(ll i = 1; i < lim; ++i) { 66 | ll ct = n, mm = 1; 67 | for(ll j = 0; j < k; ++j) { 68 | if(i & mm) 69 | ct /= a[j]; 70 | mm <<= 1; 71 | } 72 | 73 | if(__builtin_popcount(i) & 1) 74 | res += ct; 75 | else 76 | res -= ct; 77 | } 78 | cout << res; 79 | } 80 | 81 | signed main() 82 | { 83 | fastIO; 84 | long t = 1; 85 | // cin >> t; 86 | while (t--) 87 | solution(); 88 | return 0; 89 | } -------------------------------------------------------------------------------- /Mathematics/Stair_Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | ll n, a, x = 0; 37 | cin >> n; 38 | 39 | fo(i, 0, n) 40 | { 41 | cin >> a; 42 | if(i & 1) 43 | x ^= a; 44 | } 45 | 46 | if (x) 47 | cout << "first\n"; 48 | else 49 | cout << "second\n"; 50 | } 51 | 52 | signed main() 53 | { 54 | fastIO; 55 | long t; 56 | cin >> t; 57 | while (t--) 58 | solution(); 59 | return 0; 60 | } -------------------------------------------------------------------------------- /Mathematics/Stick_Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | ll n, k; 37 | cin >> n >> k; 38 | vll a(k); 39 | fo(i, 0, k) cin >> a[i]; 40 | 41 | vb dp(n + 1, 0); 42 | 43 | fo(i, 1, n + 1) 44 | { 45 | fo(j, 0, k) 46 | { 47 | if (i - a[j] >= 0 && dp[i - a[j]] == 0) 48 | { 49 | dp[i] = 1; 50 | break; 51 | } 52 | } 53 | } 54 | 55 | fo(i, 1, n + 1) cout << (dp[i] ? 'W' : 'L'); 56 | } 57 | 58 | signed main() 59 | { 60 | fastIO; 61 | solution(); 62 | return 0; 63 | } -------------------------------------------------------------------------------- /Mathematics/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Mathematics/a.out -------------------------------------------------------------------------------- /Range Queries/Dynamic_Range_Minimum_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 200005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | template 24 | struct SegT 25 | { 26 | const T ID = INT_MAX; 27 | T minEl(T a, T b) { return min(a, b); } 28 | int n; 29 | vector seg; 30 | void init(int _n) 31 | { 32 | n = _n; 33 | seg.assign(2 * n, ID); 34 | } 35 | void pull(int p) { seg[p] = minEl(seg[2 * p], seg[2 * p + 1]); } 36 | void update(int p, T val) 37 | { 38 | seg[p += n] = val; 39 | for (p /= 2; p; p /= 2) 40 | pull(p); 41 | } 42 | T query(int l, int r) 43 | { 44 | T ra = ID, rb = ID; 45 | for (l += n, r += n + 1; l < r; l /= 2, r /= 2) 46 | { 47 | if (l & 1) 48 | ra = minEl(ra, seg[l++]); 49 | if (r & 1) 50 | rb = minEl(seg[--r], rb); 51 | } 52 | return minEl(ra, rb); 53 | } 54 | }; 55 | 56 | SegT st; 57 | 58 | int main() 59 | { 60 | int n, q; 61 | cin >> n >> q; 62 | st.init(n + 1); 63 | for (int i = 1; i <= n; ++i) 64 | { 65 | int a; 66 | cin >> a; 67 | st.update(i, a); 68 | } 69 | while (q--) 70 | { 71 | int t, a, b; 72 | cin >> t >> a >> b; 73 | if (t == 1) 74 | st.update(a, b); 75 | else 76 | cout << st.query(a, b) << endl; 77 | } 78 | return 0; 79 | } -------------------------------------------------------------------------------- /Range Queries/Dynamic_Range_Sum_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 200005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | template 24 | struct SegT 25 | { 26 | const T ID = 0; 27 | T comb(T a, T b) { return a + b; } 28 | int n; 29 | vector seg; 30 | void init(int _n) 31 | { 32 | n = _n; 33 | seg.assign(2 * n, ID); 34 | } 35 | void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); } 36 | void update(int p, T val) 37 | { 38 | seg[p += n] = val; 39 | for (p /= 2; p; p /= 2) 40 | pull(p); 41 | } 42 | T query(int l, int r) 43 | { 44 | T ra = ID, rb = ID; 45 | for (l += n, r += n + 1; l < r; l /= 2, r /= 2) 46 | { 47 | if (l & 1) 48 | ra = comb(ra, seg[l++]); 49 | if (r & 1) 50 | rb = comb(seg[--r], rb); 51 | } 52 | return comb(ra, rb); 53 | } 54 | }; 55 | 56 | SegT st; 57 | 58 | int main() 59 | { 60 | int n, q; 61 | cin >> n >> q; 62 | st.init(n + 1); 63 | for (int i = 1; i <= n; ++i) 64 | { 65 | int a; 66 | cin >> a; 67 | st.update(i, a); 68 | } 69 | while (q--) 70 | { 71 | int t, a, b; 72 | cin >> t >> a >> b; 73 | if (t == 1) 74 | st.update(a, b); 75 | else 76 | cout << st.query(a, b) << endl; 77 | } 78 | return 0; 79 | } -------------------------------------------------------------------------------- /Range Queries/Forest_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | void solve() 24 | { 25 | long n, q; 26 | cin >> n >> q; 27 | vector frst(n); 28 | fo(i, n) cin >> frst[i]; 29 | vector dp(n + 1, vi(n + 1, 0)); 30 | 31 | for (int i = 1; i <= n; ++i) 32 | for (int j = 1; j <= n; ++j) 33 | { 34 | if (frst[i - 1][j - 1] == '*') 35 | dp[i][j]++; 36 | dp[i][j] += (dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]); 37 | } 38 | 39 | while (q--) 40 | { 41 | long x1, y1, x2, y2; 42 | cin >> x1 >> y1 >> x2 >> y2; 43 | cout << dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1] << endl; 44 | } 45 | } 46 | 47 | int main() 48 | { 49 | fast; 50 | solve(); 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Range Queries/Range_Update_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll fenTree[2 * N], n, q, arr[2 * N]; 35 | 36 | ll sum(ll idx) 37 | { 38 | ll res = 0; 39 | for (; idx >= 0; idx = (idx & (idx + 1)) - 1) 40 | res += fenTree[idx]; 41 | return res; 42 | } 43 | 44 | void add(ll idx, ll val) 45 | { 46 | for (; idx < n; idx = (idx | (idx + 1))) 47 | fenTree[idx] += val; 48 | } 49 | 50 | void solution() {} 51 | 52 | signed main() 53 | { 54 | fastIO; 55 | mem(fenTree, 0); 56 | 57 | cin >> n >> q; 58 | fo(i, 0, n) cin >> arr[i]; 59 | 60 | while (q--) 61 | { 62 | ll query; 63 | cin >> query; 64 | if (query == 1) 65 | { 66 | ll lo, hi, val; 67 | cin >> lo >> hi >> val; 68 | add(lo - 1, val); 69 | if (hi < n) 70 | add(hi, -val); 71 | } 72 | else 73 | { 74 | ll ind; 75 | cin >> ind; 76 | cout << arr[ind - 1] + sum(ind - 1) << endl; 77 | } 78 | } 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Range Queries/Range_Xor_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | void solve() 24 | { 25 | ll n, q, x, l, r; 26 | cin >> n >> q; 27 | vll xors(n + 1, 0); 28 | fo(i, n) 29 | { 30 | cin >> x; 31 | xors[i + 1] = xors[i] ^ x; 32 | } 33 | 34 | while (q--) 35 | { 36 | cin >> l >> r; 37 | cout << (xors[r] ^ xors[l - 1]) << endl; 38 | } 39 | } 40 | 41 | int main() 42 | { 43 | fast; 44 | solve(); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Range Queries/Static_Range_Minimum_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | // Sparse Table 24 | long dp[20][200005]; 25 | 26 | int main() 27 | { 28 | fast; 29 | long n, q, x = 1; 30 | cin >> n >> q; 31 | fo(i, n) cin >> dp[0][i]; 32 | 33 | while ((1 << x) <= n) 34 | { 35 | long d = (1 << x); 36 | for (long i = 0; i < n - d + 1; ++i) 37 | dp[x][i] = min(dp[x - 1][i], dp[x - 1][i + d / 2]); 38 | x++; 39 | } 40 | 41 | while (q--) 42 | { 43 | long l, r; 44 | cin >> l >> r; 45 | long k = log2(r - l + 1); 46 | cout << min(dp[k][l - 1], dp[k][r - (1 << k)]) << endl; 47 | } 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /Range Queries/Static_Range_Sum_Queries.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | int main() 24 | { 25 | fast; 26 | long n, q; 27 | cin >> n >> q; 28 | vll a(n); 29 | fo(i, n) cin >> a[i]; 30 | fos(i, 1, n) a[i] += a[i - 1]; 31 | 32 | while (q--) 33 | { 34 | long l, r; 35 | cin >> l >> r; 36 | cout << a[r - 1] - (l < 2 ? 0 : a[l - 2]) << endl; 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Range Queries/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Range Queries/a.out -------------------------------------------------------------------------------- /Sorting and Searching/Apartments.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ios_base::sync_with_stdio(false); 17 | cin.tie(NULL); 18 | ll n, m, k, res = 0, i, j; 19 | cin >> n >> m >> k; 20 | vl a(n), b(m); 21 | for(int i = 0; i < n; ++i) 22 | cin >> a[i]; 23 | for(int i = 0; i < m; ++i) 24 | cin >> b[i]; 25 | sort(a.begin(), a.end()); 26 | sort(b.begin(), b.end()); 27 | for(i = 0, j = 0 ; i < n && j < m; ) 28 | { 29 | if(a[i] - b[j] > k) 30 | j++; 31 | else if(b[j] - a[i] > k) 32 | i++; 33 | else if(abs(a[i] - b[j]) <= k){ 34 | i++; 35 | j++; 36 | res++; 37 | } 38 | } 39 | cout << res << endl; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Sorting and Searching/Array_Division.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | vll a(2 * N); 35 | ll n, k; 36 | 37 | bool divideGroups(ll val) 38 | { 39 | int grps = 0; 40 | ll sum = 0; 41 | for (int i = 0; i < n; ++i) 42 | { 43 | if (a[i] > val) 44 | return false; 45 | if (sum + a[i] > val) 46 | { 47 | ++grps; 48 | sum = 0; 49 | } 50 | sum += a[i]; 51 | } 52 | if (sum > 0) 53 | grps++; 54 | return (grps <= k); 55 | } 56 | 57 | void solution() 58 | { 59 | cin >> n >> k; 60 | fo(i, 0, n) cin >> a[i]; 61 | 62 | ll lo = 0, hi = oo, ans = 0; 63 | while (lo <= hi) 64 | { 65 | ll mid = (lo + hi) / 2; 66 | if (divideGroups(mid)) 67 | { 68 | hi = mid - 1; 69 | ans = mid; 70 | } 71 | else 72 | lo = mid + 1; 73 | } 74 | cout << ans << endl; 75 | } 76 | 77 | signed main() 78 | { 79 | fastIO; 80 | solution(); 81 | return 0; 82 | } -------------------------------------------------------------------------------- /Sorting and Searching/Collecting_Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | long n; 37 | cin >> n; 38 | vl a(n); 39 | fo(i, 0, n) cin >> a[i]; 40 | 41 | vl b(n); 42 | fo(i, 0, n) b[a[i] - 1] = i; 43 | long res = 0; 44 | 45 | for (long i = 1; i < n; ++i) 46 | if (b[i] < b[i - 1]) 47 | res++; 48 | cout << res + 1; 49 | } 50 | 51 | signed main() 52 | { 53 | fastIO; 54 | solution(); 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Sorting and Searching/Collecting_Numbers_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | int giveDifference(vll &a, ll i1, ll i2) 35 | { 36 | if (i1 > i2) 37 | return giveDifference(a, i2, i1); 38 | 39 | int res = 0; 40 | if (i1 > 1 && a[i1] < a[i1 - 1]) 41 | res++; 42 | if (i1 < a.size() && a[i1] > a[i1 + 1]) 43 | res++; 44 | 45 | if (i2 - i1 > 1 && a[i2] < a[i2 - 1]) 46 | res++; 47 | if (i2 < a.size() && a[i2] > a[i2 + 1]) 48 | res++; 49 | 50 | return res; 51 | } 52 | 53 | void solution() 54 | { 55 | ll n, m; 56 | cin >> n >> m; 57 | vll a(n + 1); 58 | fo(i, 1, n + 1) cin >> a[i]; 59 | 60 | vll pos(n + 1); 61 | fo(i, 1, n + 1) pos[a[i]] = i; 62 | 63 | ll res = 1; 64 | fo(i, 2, n + 1) 65 | { 66 | if (pos[i] < pos[i - 1]) 67 | res++; 68 | } 69 | 70 | while (m--) 71 | { 72 | ll ai, bi; 73 | cin >> ai >> bi; 74 | 75 | ll i1 = pos[a[ai - 1]], i2 = pos[a[bi - 1]]; 76 | int diff1 = giveDifference(pos, a[ai], a[bi]); 77 | 78 | swap(pos[a[ai]], pos[a[bi]]); 79 | swap(a[ai], a[bi]); 80 | 81 | int diff2 = giveDifference(pos, a[bi], a[ai]); 82 | res += diff2 - diff1; 83 | cout << res << endl; 84 | } 85 | } 86 | 87 | signed main() 88 | { 89 | fastIO; 90 | solution(); 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Sorting and Searching/Concert_Tickets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | 15 | int main() 16 | { 17 | ll n, m, ticket, buyer; 18 | cin >> n >> m; 19 | multiset> tickets; 20 | for (int i = 0; i < n; ++i) 21 | { 22 | cin >> ticket; 23 | tickets.insert(ticket); 24 | } 25 | 26 | for (int i = 0; i < m; ++i) 27 | { 28 | cin >> buyer; 29 | auto itr = tickets.lower_bound(buyer); 30 | if (itr == tickets.end()) 31 | cout << "-1\n"; 32 | else 33 | { 34 | cout << *itr << endl; 35 | tickets.erase(itr); 36 | } 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Sorting and Searching/Distinct_Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define dis(n) cout<=0; --i) 11 | 12 | using namespace std; 13 | int main() 14 | { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(NULL); 17 | long n, i, curr = -1, count = 1; 18 | cin >> n; 19 | long a[n]; 20 | for(i = 0; i < n; ++i) 21 | cin >> a[i]; 22 | sort(a, a + n); 23 | curr = a[0]; 24 | for( i = 1; i < n; ++i) 25 | { 26 | if(a[i] != curr){ 27 | count++; 28 | curr = a[i]; 29 | } 30 | } 31 | cout << count << endl; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Sorting and Searching/Factory_Machines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | ll n, t; 25 | cin >> n >> t; 26 | vll k(n); 27 | fo(i, n) cin >> k[i]; 28 | 29 | ll lo = 0, hi = 1e18, ans = 0; 30 | while (lo <= hi) 31 | { 32 | ll mid = (lo + hi) / 2; 33 | ll asum = 0; 34 | fo(i, n) 35 | { 36 | asum += mid / k[i]; 37 | if (asum >= t) 38 | break; 39 | } 40 | if (asum >= t) 41 | { 42 | ans = mid; 43 | hi = mid - 1; 44 | } 45 | else 46 | lo = mid + 1; 47 | } 48 | cout << ans; 49 | return 0; 50 | } -------------------------------------------------------------------------------- /Sorting and Searching/Ferris_Wheel.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ios_base::sync_with_stdio(false); 17 | cin.tie(NULL); 18 | ll n, x, res = 0; 19 | cin >> n >> x; 20 | ll a[n], i, pos = 0, j; 21 | for(i = 0; i < n; ++i) 22 | cin >> a[i]; 23 | sort(a, a + n); 24 | for(i = n - 1 ; i >= 0; --i) 25 | if(a[0] + a[i] <= x){ 26 | pos = i; 27 | break; 28 | } 29 | res = n - 1 - pos; 30 | for(i = 0, j = pos; i <= j; ) 31 | { 32 | if(i == j){ 33 | res++; 34 | break; 35 | } 36 | if(a[i] + a[j] <= x){ 37 | i++; 38 | j--; 39 | res++; 40 | } 41 | else 42 | { 43 | j--; 44 | res++; 45 | } 46 | } 47 | cout << res << endl; 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Sorting and Searching/Josephus_Problem_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | 15 | int main() 16 | { 17 | long n; 18 | cin >> n; 19 | queue q; 20 | for(long i = 1; i <= n; ++i) 21 | q.push(i); 22 | 23 | while(!q.empty()) { 24 | long t = q.front(); 25 | q.pop(); 26 | q.push(t); 27 | t = q.front(); 28 | cout << t << " "; 29 | q.pop(); 30 | } 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Sorting and Searching/Josephus_Problem_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define ll long long 4 | #define N 100005 5 | #define M 10000005 6 | #define O 1000000007 7 | #define vi vector 8 | #define vl vector 9 | #define vb vector 10 | #define vll vector 11 | #define pii pair 12 | #define pll pair 13 | #define fo(i, N) for (long i = 0; i < N; ++i) 14 | #define fos(i, b, N) for (long i = b; i < N; ++i) 15 | #define forr(i, N) for (long i = N; i >= 0; --i) 16 | const double PI = 3.141592653589793238; 17 | const ll oo = 1e18; 18 | #define fast \ 19 | ios_base::sync_with_stdio(false); \ 20 | cin.tie(NULL); 21 | 22 | /* 23 | This problem is solved using set. 24 | Normal set in STL is implemented using BSTs which are unbalanced, giving O(n) time complexity 25 | Thus we use Red Black Trees which are auto balancing trees, giving O(log n) time complexity 26 | */ 27 | 28 | using namespace std; 29 | using namespace __gnu_pbds; 30 | 31 | typedef tree, rb_tree_tag, tree_order_statistics_node_update> indexed_set; 32 | 33 | int main() 34 | { 35 | fast; 36 | indexed_set s; 37 | long n, k; 38 | cin >> n >> k; 39 | for (int i = 1; i <= n; ++i) 40 | s.insert(i); 41 | 42 | int ind = k % n; 43 | while (n--) 44 | { 45 | auto y = s.find_by_order(ind); 46 | cout << *y << " "; 47 | s.erase(y); 48 | if (n) 49 | ind = (ind % n + k) % n; 50 | } 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Sorting and Searching/Max_Subarray_Sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n; 17 | cin >> n; 18 | vl a(n); 19 | fo(i, n) cin >> a[i]; 20 | long maxi = INT_MIN, sum = 0; 21 | fo(i, n) { 22 | sum += a[i]; 23 | if(sum > maxi) 24 | maxi = sum; 25 | if(sum < 0) 26 | sum = 0; 27 | } 28 | 29 | cout << maxi; 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Sorting and Searching/Maximum_Subarray_Sum_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | void solution() 35 | { 36 | ll n, a, b, val; 37 | cin >> n >> a >> b; 38 | vll pref(n + 1, 0); 39 | fo(i, 1, n + 1) 40 | { 41 | cin >> val; 42 | pref[i] = pref[i - 1] + val; 43 | } 44 | 45 | multiset curr; 46 | ll ans = -oo; 47 | fo(i, a, n + 1) 48 | { 49 | if (i > b) 50 | curr.erase(curr.find(pref[i - b - 1])); 51 | curr.insert(pref[i - a]); 52 | ans = max(ans, pref[i] - *curr.begin()); 53 | } 54 | cout << ans << endl; 55 | } 56 | 57 | signed main() 58 | { 59 | fastIO; 60 | solution(); 61 | return 0; 62 | } -------------------------------------------------------------------------------- /Sorting and Searching/Missing_Coin_Sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n; 17 | cin >> n; 18 | vll a(n); 19 | fo(i, n) cin >> a[i]; 20 | sort(a.begin(), a.end()); 21 | ll res = 1; 22 | 23 | if(a[0] != 1) 24 | cout << "1\n"; 25 | else 26 | { 27 | for(long i = 1; i < n; ++i) { 28 | if(a[i] <= res + 1) 29 | res += a[i]; 30 | else 31 | break; 32 | } 33 | cout << res + 1; 34 | } 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Sorting and Searching/Movie_Festival.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n; 17 | cin >> n; 18 | vector> a; 19 | 20 | for (int i = 0; i < n; ++i) 21 | { 22 | long x, y; 23 | cin >> x >> y; 24 | a.push_back(make_pair(y, x)); 25 | } 26 | 27 | sort(a.begin(), a.end()); 28 | 29 | long res = 1, curr = a[0].first; 30 | for (int i = 1; i < a.size(); ++i) 31 | { 32 | if (a[i].second >= curr) 33 | { 34 | res++; 35 | curr = a[i].first; 36 | } 37 | } 38 | 39 | cout << res << endl; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Sorting and Searching/Movie_Festival_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define plll pair 13 | #define fo(i, N) for (long i = 0; i < N; ++i) 14 | #define fos(i, b, N) for (long i = b; i < N; ++i) 15 | #define forr(i, N) for (long i = N; i >= 0; --i) 16 | const double PI = 3.141592653589793238; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | int main() 24 | { 25 | ll n, k, res = 0; 26 | cin >> n >> k; 27 | vector a(n); 28 | fo(i, n) cin >> a[i].second >> a[i].first; 29 | sort(a.begin(), a.end()); 30 | 31 | multiset end_time; 32 | fo(i, k) end_time.insert(0); 33 | 34 | for (long i = 0; i < n; ++i) 35 | { 36 | auto it = end_time.upper_bound(a[i].second); 37 | if (it == end_time.begin()) 38 | continue; 39 | 40 | end_time.erase(--it); 41 | end_time.insert(a[i].first); 42 | ++res; 43 | } 44 | cout << res; 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Sorting and Searching/Nearest_Smaller_Values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | fast; 25 | long n; 26 | cin >> n; 27 | vl a(n); 28 | fo(i, n) cin >> a[i]; 29 | 30 | stack s; 31 | 32 | for (long i = 0; i < n; ++i) 33 | { 34 | while (!s.empty() && s.top().first >= a[i]) 35 | s.pop(); 36 | 37 | if (s.empty()) 38 | cout << "0 "; 39 | else 40 | cout << s.top().second + 1 << " "; 41 | s.push(make_pair(a[i], i)); 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /Sorting and Searching/Nested_Ranges_Check.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | using namespace __gnu_pbds; 7 | 8 | #define N 100005 9 | #define MOD 1000000007 10 | #define ar array 11 | #define fo(i, b, n) for (long i = b; i < n; ++i) 12 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 13 | #define all(ar) ar.begin(), ar.end() 14 | #define rall(ar) ar.rbegin(), ar.rend() 15 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 16 | #define fi first 17 | #define se second 18 | #define pb push_back 19 | #define fastIO \ 20 | ios_base::sync_with_stdio(false); \ 21 | cin.tie(NULL); \ 22 | cout.precision(12); 23 | 24 | typedef long long ll; 25 | typedef pair pll; 26 | typedef pair plll; 27 | typedef vector vi; 28 | typedef vector vl; 29 | typedef vector vll; 30 | typedef vector vb; 31 | typedef vector vvb; 32 | typedef vector vvl; 33 | typedef vector vvll; 34 | 35 | const double PI = 3.141592653589793238; 36 | const ll oo = 1e18; 37 | 38 | template 39 | using ordered_set = tree, rb_tree_tag, tree_order_statistics_node_update>; 40 | 41 | bool cmp(ar a, ar b) 42 | { 43 | return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0]; 44 | } 45 | 46 | void solution() 47 | { 48 | ll n; 49 | cin >> n; 50 | vector> a(n); 51 | for (int i = 0; i < n; ++i) 52 | { 53 | int l, r; 54 | cin >> l >> r; 55 | a[i] = {l, r, i}; 56 | } 57 | sort(a.begin(), a.end(), cmp); 58 | vi ans1(n), ans2(n); 59 | ordered_set> os1, os2; 60 | 61 | for (int i = 0, j = n - 1; i < n; ++i, j--) 62 | { 63 | ans1[a[j][2]] = os1.order_of_key({a[j][1] + 1, -1}); 64 | ans2[a[i][2]] = i - os2.order_of_key({a[i][1], -1}); 65 | os1.insert({a[j][1], j}); 66 | os2.insert({a[i][1], i}); 67 | } 68 | 69 | for (int x : ans1) 70 | { 71 | if (x > 0) 72 | cout << "1 "; 73 | else 74 | cout << "0 "; 75 | } 76 | cout << endl; 77 | for (int x : ans2) 78 | { 79 | if (x > 0) 80 | cout << "1 "; 81 | else 82 | cout << "0 "; 83 | } 84 | cout << endl; 85 | } 86 | 87 | signed main() 88 | { 89 | fastIO; 90 | solution(); 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Sorting and Searching/Nested_Ranges_Count.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | using namespace __gnu_pbds; 7 | 8 | #define N 100005 9 | #define MOD 1000000007 10 | #define ar array 11 | #define fo(i, b, n) for (long i = b; i < n; ++i) 12 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 13 | #define all(ar) ar.begin(), ar.end() 14 | #define rall(ar) ar.rbegin(), ar.rend() 15 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 16 | #define fi first 17 | #define se second 18 | #define pb push_back 19 | #define fastIO \ 20 | ios_base::sync_with_stdio(false); \ 21 | cin.tie(NULL); \ 22 | cout.precision(12); 23 | 24 | typedef long long ll; 25 | typedef pair pll; 26 | typedef pair plll; 27 | typedef vector vi; 28 | typedef vector vl; 29 | typedef vector vll; 30 | typedef vector vb; 31 | typedef vector vvb; 32 | typedef vector vvl; 33 | typedef vector vvll; 34 | 35 | const double PI = 3.141592653589793238; 36 | const ll oo = 1e18; 37 | 38 | template 39 | using ordered_set = tree, rb_tree_tag, tree_order_statistics_node_update>; 40 | 41 | bool cmp(ar a, ar b) 42 | { 43 | return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0]; 44 | } 45 | 46 | void solution() 47 | { 48 | ll n; 49 | cin >> n; 50 | vector> a(n); 51 | for (int i = 0; i < n; ++i) 52 | { 53 | int l, r; 54 | cin >> l >> r; 55 | a[i] = {l, r, i}; 56 | } 57 | sort(a.begin(), a.end(), cmp); 58 | vi ans1(n), ans2(n); 59 | ordered_set> os1, os2; 60 | 61 | for (int i = 0, j = n - 1; i < n; ++i, j--) 62 | { 63 | ans1[a[j][2]] = os1.order_of_key({a[j][1] + 1, -1}); 64 | ans2[a[i][2]] = i - os2.order_of_key({a[i][1], -1}); 65 | os1.insert({a[j][1], j}); 66 | os2.insert({a[i][1], i}); 67 | } 68 | 69 | for (int x : ans1) 70 | cout << x << " "; 71 | cout << endl; 72 | for (int x : ans2) 73 | cout << x << " "; 74 | cout << endl; 75 | } 76 | 77 | signed main() 78 | { 79 | fastIO; 80 | solution(); 81 | return 0; 82 | } -------------------------------------------------------------------------------- /Sorting and Searching/Playlist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ios_base::sync_with_stdio(false); 17 | cin.tie(NULL); 18 | long n, k; 19 | cin >> n; 20 | vector a(n); 21 | map songs; 22 | long maxx = 0, curr = 0, j = 0; 23 | for (int i = 0; i < n; ++i) 24 | { 25 | cin >> k; 26 | a[i] = k; 27 | if (songs.find(k) == songs.end() || songs[k] == false) 28 | { 29 | songs[k] = true; 30 | curr++; 31 | maxx = max(curr, maxx); 32 | } 33 | else 34 | { 35 | while (a[j] != k) 36 | { 37 | songs[a[j]] = false; 38 | j++; 39 | } 40 | 41 | curr = i - j; 42 | j++; 43 | } 44 | } 45 | 46 | cout << maxx << endl; 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Sorting and Searching/Reading_Books.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | ll n; 25 | cin >> n; 26 | vll a(n); 27 | fo(i, n) cin >> a[i]; 28 | ll asum = 0, amax = 0; 29 | fo(i, n) 30 | { 31 | asum += a[i]; 32 | amax = max(amax, a[i]); 33 | } 34 | if (amax >= asum - amax) 35 | cout << 2 * amax; 36 | else 37 | cout << asum; 38 | cout << endl; 39 | return 0; 40 | } -------------------------------------------------------------------------------- /Sorting and Searching/Restaurant_Customers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n; 17 | cin >> n; 18 | vector> a; 19 | 20 | for (int i = 0; i < n; ++i) 21 | { 22 | long x, y; 23 | cin >> x >> y; 24 | a.push_back(make_pair(x, true)); 25 | a.push_back(make_pair(y, false)); 26 | } 27 | 28 | sort(a.begin(), a.end()); 29 | 30 | long res = INT_MIN, curr = 0; 31 | 32 | for (long i = 0; i < a.size(); ++i) 33 | { 34 | if (a[i].second == true) 35 | { 36 | curr++; 37 | res = max(curr, res); 38 | } 39 | else 40 | curr--; 41 | } 42 | 43 | cout << res << endl; 44 | return 0; 45 | } -------------------------------------------------------------------------------- /Sorting and Searching/Room_Allocation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | typedef pair ppll; 31 | 32 | const double PI = 3.141592653589793238; 33 | const ll oo = 1e18; 34 | 35 | struct Tourist 36 | { 37 | long beg, end, ind; 38 | }; 39 | 40 | struct TouristCmp 41 | { 42 | bool operator()(Tourist &a, Tourist &b) 43 | { 44 | return (a.end < b.end); 45 | } 46 | }; 47 | 48 | bool touristBegCmp(Tourist &a, Tourist &b) 49 | { 50 | return (a.beg < b.beg); 51 | } 52 | 53 | bool touristEndCmp(Tourist &a, Tourist &b) 54 | { 55 | return (a.end < b.end); 56 | } 57 | 58 | ll n; 59 | vector> v; 60 | vl ans; 61 | 62 | void solution() 63 | { 64 | cin >> n; 65 | v.resize(n); 66 | ans.resize(n); 67 | 68 | fo(i, 0, n) 69 | { 70 | cin >> v[i].fi.fi >> v[i].fi.se; 71 | v[i].se = i; 72 | } 73 | sort(all(v)); 74 | 75 | ll rooms = 0, last = 0; 76 | priority_queue, greater> pq; 77 | 78 | for (long i = 0; i < n; ++i) 79 | { 80 | if (pq.empty()) 81 | { 82 | last++; 83 | pq.push({v[i].fi.se, last}); 84 | ans[v[i].se] = last; 85 | } 86 | else 87 | { 88 | pll mini = pq.top(); 89 | if (mini.fi < v[i].fi.fi) 90 | { 91 | pq.pop(); 92 | pq.push({v[i].fi.se, mini.se}); 93 | ans[v[i].se] = mini.se; 94 | } 95 | else 96 | { 97 | last++; 98 | pq.push({v[i].fi.se, last}); 99 | ans[v[i].se] = last; 100 | } 101 | } 102 | rooms = max(rooms, ll(pq.size())); 103 | } 104 | 105 | cout << rooms << endl; 106 | fo(i, 0, n) cout << ans[i] << " "; 107 | } 108 | 109 | signed main() 110 | { 111 | fastIO; 112 | solution(); 113 | return 0; 114 | } -------------------------------------------------------------------------------- /Sorting and Searching/Sliding_Cost.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | #define fast \ 13 | ios_base::sync_with_stdio(false); \ 14 | cin.tie(NULL); 15 | 16 | using namespace std; 17 | 18 | multiset low; 19 | multiset up; 20 | long n, k; 21 | ll sLow = 0, sUp = 0; 22 | 23 | void ins(ll val) { 24 | ll a = *low.rbegin(); 25 | if(a < val) { 26 | up.insert(val); 27 | sUp += val; 28 | if(up.size() > k / 2) { 29 | ll tmp = *up.begin(); 30 | low.insert(tmp); 31 | sLow += tmp; 32 | up.erase(up.find(tmp)); 33 | sUp -= tmp; 34 | } 35 | } 36 | else { 37 | low.insert(val); 38 | sLow += val; 39 | if(low.size() > (k + 1) / 2) { 40 | ll tmp = *low.rbegin(); 41 | up.insert(tmp); 42 | sUp += tmp; 43 | low.erase(low.find(tmp)); 44 | sLow -= tmp; 45 | } 46 | } 47 | } 48 | 49 | void er(ll val) { 50 | if(up.find(val) != up.end()) { 51 | up.erase(up.find(val)); 52 | sUp -= val; 53 | } 54 | else { 55 | low.erase(low.find(val)); 56 | sLow -= val; 57 | } 58 | 59 | if(low.empty()) { 60 | ll tmp = *up.begin(); 61 | low.insert(tmp); 62 | sLow += tmp; 63 | up.erase(up.begin()); 64 | sUp -= tmp; 65 | } 66 | } 67 | 68 | ll med() { 69 | return (k % 2 == 0) ? 0 : *low.rbegin(); 70 | } 71 | 72 | int main() 73 | { 74 | fast; 75 | cin >> n >> k; 76 | vll a(n); 77 | fo(i, n) cin >> a[i]; 78 | 79 | low.insert(a[0]); 80 | sLow += a[0]; 81 | for(long i = 1; i < k; ++i) 82 | ins(a[i]); 83 | 84 | cout << sUp - sLow + med(); 85 | for(long i = k; i < n; ++i) { 86 | if(k == 1) { 87 | ins(a[i]); 88 | er(a[i - k]); 89 | } 90 | else { 91 | er(a[i - k]); 92 | ins(a[i]); 93 | } 94 | cout << " " << sUp - sLow + med(); 95 | } 96 | return 0; 97 | } -------------------------------------------------------------------------------- /Sorting and Searching/Sliding_Median.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | #define fast \ 13 | ios_base::sync_with_stdio(false); \ 14 | cin.tie(NULL); 15 | 16 | using namespace std; 17 | 18 | multiset low; 19 | multiset up; 20 | long n, k; 21 | 22 | 23 | void ins(ll val) { 24 | ll a = *low.rbegin(); 25 | if(a < val) { 26 | up.insert(val); 27 | if(up.size() > k / 2) { 28 | low.insert(*up.begin()); 29 | up.erase(up.begin()); 30 | } 31 | } 32 | else { 33 | low.insert(val); 34 | if(low.size() > (k + 1) / 2) { 35 | up.insert(*low.rbegin()); 36 | low.erase(low.find(*low.rbegin())); 37 | } 38 | } 39 | } 40 | 41 | void er(ll val) { 42 | if(up.find(val) != up.end()) 43 | up.erase(up.find(val)); 44 | else 45 | low.erase(low.find(val)); 46 | 47 | if(low.empty()) { 48 | low.insert(*up.begin()); 49 | up.erase(up.begin()); 50 | } 51 | } 52 | 53 | int main() 54 | { 55 | fast; 56 | cin >> n >> k; 57 | vll a(n); 58 | fo(i, n) cin >> a[i]; 59 | 60 | low.insert(a[0]); 61 | for(long i = 1; i < k; ++i) 62 | ins(a[i]); 63 | 64 | cout << *low.rbegin() << " "; 65 | for(long i = k; i < n; ++i) { 66 | if(k == 1) { 67 | ins(a[i]); 68 | er(a[i - k]); 69 | } 70 | else { 71 | er(a[i - k]); 72 | ins(a[i]); 73 | } 74 | cout << *low.rbegin() << " "; 75 | } 76 | return 0; 77 | } -------------------------------------------------------------------------------- /Sorting and Searching/Stick_Length.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n; 17 | cin >> n; 18 | vl a(n); 19 | fo(i, n) cin >> a[i]; 20 | sort(a.begin(), a.end()); 21 | 22 | ll mid = n / 2, res = 0; 23 | fo(i, n) res += abs(a[mid] - a[i]); 24 | cout << res; 25 | return 0; 26 | } -------------------------------------------------------------------------------- /Sorting and Searching/Subarray_Distinct_Values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n, k; 35 | vl a; 36 | map mp; 37 | 38 | void solution() 39 | { 40 | cin >> n >> k; 41 | a.resize(n); 42 | fo(i, 0, n) cin >> a[i]; 43 | 44 | long dist = 0, i = 0, j = 0, res = 0; 45 | 46 | while (j < n) 47 | { 48 | if (mp[a[j]] == 0) 49 | dist++; 50 | mp[a[j]]++; 51 | 52 | if (dist > k) 53 | { 54 | while (dist > k) 55 | { 56 | if (mp[a[i]] == 1) 57 | dist--; 58 | mp[a[i]]--; 59 | i++; 60 | } 61 | } 62 | res += j - i + 1; 63 | j++; 64 | } 65 | cout << res; 66 | } 67 | 68 | signed main() 69 | { 70 | fastIO; 71 | solution(); 72 | return 0; 73 | } -------------------------------------------------------------------------------- /Sorting and Searching/Subarray_Divisibility.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | int main() 24 | { 25 | fast; 26 | ll n, ps = 0; 27 | cin >> n; 28 | vll a(n); 29 | a[ps] = 1; 30 | 31 | for (long i = 0; i < n; ++i) 32 | { 33 | ll t; 34 | cin >> t; 35 | ps += t; 36 | a[(ps % n + n) % n]++; 37 | } 38 | ll ans = 0; 39 | for (ll x : a) 40 | ans += x * (x - 1) / 2; 41 | cout << ans; 42 | return 0; 43 | } -------------------------------------------------------------------------------- /Sorting and Searching/Subarray_Sums_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ll n, x; 17 | cin >> n >> x; 18 | vll a(n); 19 | fo(i, n) cin >> a[i]; 20 | 21 | ll tsum = 0, i = 0, res = 0, j = 0; 22 | while (i < n && tsum < x) 23 | tsum += a[i++]; 24 | 25 | if (tsum == x) 26 | res++; 27 | 28 | while (i <= n) 29 | { 30 | if (tsum < x) 31 | tsum += a[i++]; 32 | else 33 | tsum -= a[j++]; 34 | 35 | if (tsum == x) 36 | res++; 37 | } 38 | 39 | cout << res; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Sorting and Searching/Subarray_Sums_II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ll n, x; 17 | cin >> n >> x; 18 | vll a(n); 19 | fo(i, n) cin >> a[i]; 20 | 21 | ll res = 0; 22 | ll prefix_sum = 0; 23 | map sums; 24 | sums[0] = 1; 25 | 26 | for (ll num : a) 27 | { 28 | prefix_sum += num; 29 | res += sums[prefix_sum - x]; 30 | sums[prefix_sum]++; 31 | } 32 | cout << res << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Sorting and Searching/Sum_Of_Two_Values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long n, x, i, j; 17 | cin >> n >> x; 18 | pair a[n]; 19 | for(i = 0; i < n; ++i) { 20 | cin >> a[i].first; 21 | a[i].second = i + 1; 22 | } 23 | sort(a, a + n); 24 | for(i = 0, j = n - 1; i < j;) { 25 | if(a[i].first + a[j].first == x) 26 | break; 27 | else if(a[i].first + a[j].first > x) 28 | j--; 29 | else 30 | i++; 31 | } 32 | if(i < j) 33 | cout << a[i].second << " " << a[j].second; 34 | else 35 | cout << "IMPOSSIBLE"; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Sorting and Searching/Sum_of_Four_Values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | 15 | pair sop(pair *a, ll start, ll end, ll x) { 16 | while(start < end) { 17 | if(a[start].first + a[end].first == x) 18 | return make_pair(start, end); 19 | else if(a[start].first + a[end].first < x) 20 | start++; 21 | else 22 | end--; 23 | } 24 | 25 | return make_pair(-1, -1); 26 | } 27 | 28 | int main() 29 | { 30 | ll n, x, i, j; 31 | cin >> n >> x; 32 | pair a[n]; 33 | for(i = 0; i < n; ++i) { 34 | cin >> a[i].first; 35 | a[i].second = i + 1; 36 | } 37 | sort(a, a + n); 38 | 39 | for(i = 0; i < n; ++i) { 40 | for(j = i + 1; j < n; ++j) { 41 | if(a[i].first + a[j].first < x) { 42 | ll diff = x - (a[i].first + a[j].first); 43 | pair val = sop(a, i + 1, j - 1, diff); 44 | 45 | if(val.first != -1) { 46 | cout << a[i].second << " " << a[j].second << " " << a[val.first].second << " " << a[val.second].second; 47 | return 0; 48 | } 49 | } 50 | } 51 | } 52 | 53 | cout << "IMPOSSIBLE"; 54 | return 0; 55 | } -------------------------------------------------------------------------------- /Sorting and Searching/Sum_of_Three_Values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | 15 | ll bsearch(pair *a, ll start, ll end, ll x) { 16 | if(start > end) 17 | return -1; 18 | 19 | ll mid = (start + end) / 2; 20 | if(a[mid].first == x) 21 | return mid; 22 | 23 | if(a[mid].first > x) 24 | return bsearch(a, start, mid - 1, x); 25 | else 26 | return bsearch(a, mid + 1, end, x); 27 | } 28 | 29 | int main() 30 | { 31 | ll n, x, i, j; 32 | cin >> n >> x; 33 | pair a[n]; 34 | for(i = 0; i < n; ++i) { 35 | cin >> a[i].first; 36 | a[i].second = i + 1; 37 | } 38 | sort(a, a + n); 39 | 40 | for(i = 0; i < n; ++i) { 41 | for(j = i + 1; j < n; ++j) { 42 | if(a[i].first + a[j].first < x) { 43 | ll diff = x - (a[i].first + a[j].first); 44 | ll val = bsearch(a, i + 1, j - 1, diff); 45 | if(val != -1) { 46 | cout << a[i].second << " " << a[j].second << " " << a[val].second; 47 | return 0; 48 | } 49 | } 50 | } 51 | } 52 | 53 | cout << "IMPOSSIBLE"; 54 | return 0; 55 | } -------------------------------------------------------------------------------- /Sorting and Searching/Tasks_and_Deadlines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | #define fast \ 17 | ios_base::sync_with_stdio(false); \ 18 | cin.tie(NULL); 19 | 20 | using namespace std; 21 | 22 | int main() 23 | { 24 | long n; 25 | cin >> n; 26 | vector d(n); 27 | fo(i, n) cin >> d[i].first >> d[i].second; 28 | sort(d.begin(), d.end()); 29 | long time = 0, res = 0; 30 | fo(i, n) 31 | { 32 | time += d[i].first; 33 | res += d[i].second - time; 34 | } 35 | cout << res; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Sorting and Searching/Towers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout << n << endl 9 | #define fo(i, N) for (int i = 0; i < N; ++i) 10 | #define fos(i, b, N) for (int i = b; i < N; ++i) 11 | #define forr(i, N) for (i = N; i >= 0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | ios_base::sync_with_stdio(false); 17 | cin.tie(NULL); 18 | long n, t; 19 | cin >> n; 20 | multiset> a; 21 | 22 | for (int i = 0; i < n; ++i) 23 | { 24 | cin >> t; 25 | auto itr = a.upper_bound(t); 26 | if (itr == a.end()) 27 | a.insert(t); 28 | else 29 | { 30 | a.insert(itr, t); 31 | a.erase(itr); 32 | } 33 | } 34 | 35 | cout << a.size(); 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Sorting and Searching/Traffic_Lights.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000007 5 | #define O 1000000009 6 | #define vll vector 7 | #define vl vector 8 | #define dis(n) cout<=0; --i) 12 | 13 | using namespace std; 14 | int main() 15 | { 16 | long x, n; 17 | cin >> x >> n; 18 | multiset> m, sizes; 19 | vl a(n); 20 | fo(i, n) cin >> a[i]; 21 | m.insert(0); 22 | m.insert(x); 23 | sizes.insert(x); 24 | 25 | for(long i = 0; i < n; ++i) { 26 | auto it1 = m.upper_bound(a[i]); 27 | auto it2 = it1; 28 | --it1; 29 | m.insert(a[i]); 30 | 31 | auto si = sizes.find(*it2 - *it1); 32 | sizes.erase(si); 33 | sizes.insert(a[i] - *it1); 34 | sizes.insert(*it2 - a[i]); 35 | auto itr = sizes.end(); 36 | --itr; 37 | cout << *itr << " "; 38 | } 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Sorting and Searching/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Sorting and Searching/a.out -------------------------------------------------------------------------------- /String Algorithms/Finding_Borders.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | #define F first 16 | #define S second 17 | const double PI = 3.141592653589793238; 18 | const ll oo = 1e18; 19 | #define fast \ 20 | ios_base::sync_with_stdio(false); \ 21 | cin.tie(NULL); 22 | 23 | using namespace std; 24 | 25 | void solve() 26 | { 27 | string s; 28 | cin >> s; 29 | long n = s.size(); 30 | vl lps(n, 0); 31 | 32 | for (long i = 1; i < n; ++i) 33 | { 34 | long j = lps[i - 1]; 35 | while (j > 0 && s[i] != s[j]) 36 | j = lps[j - 1]; 37 | if (s[i] == s[j]) 38 | j++; 39 | lps[i] = j; 40 | } 41 | 42 | vl res; 43 | long j = n - 1; 44 | while (j > 0 && lps[j] > 0) 45 | { 46 | res.push_back(lps[j]); 47 | if (lps[j - 1] > lps[j]) 48 | break; 49 | j = lps[j] - 1; 50 | } 51 | for (long i = res.size() - 1; i >= 0; --i) 52 | cout << res[i] << " "; 53 | } 54 | 55 | int main() 56 | { 57 | fast; 58 | solve(); 59 | return 0; 60 | } -------------------------------------------------------------------------------- /String Algorithms/Finding_Periods.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | signed main() 35 | { 36 | fastIO; 37 | string s; 38 | cin >> s; 39 | ll n = s.size(), x = 0, y = 0; 40 | 41 | vll z(n, 0); 42 | fo(i, 1, n) 43 | { 44 | z[i] = max(0ll, min(z[i - x], y - i + 1)); 45 | while (i + z[i] < n && s[z[i]] == s[i + z[i]]) 46 | { 47 | x = i; 48 | y = i + z[i]; 49 | z[i]++; 50 | } 51 | } 52 | fo(i, 1, n) if (z[i] + i == n) cout << i << ' '; 53 | cout << n << endl; 54 | return 0; 55 | } -------------------------------------------------------------------------------- /String Algorithms/Minimal_Rotation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | // Booth's Algorithm 35 | 36 | string s; 37 | 38 | signed main() 39 | { 40 | fastIO; 41 | cin >> s; 42 | s = s + s; 43 | ll n = s.size(), i = 0, ans = 0; 44 | 45 | while (i < n / 2) 46 | { 47 | ans = i; 48 | ll k = i, j = i + 1; 49 | while (j < n && s[j] >= s[k]) 50 | { 51 | if (s[j] == s[k]) 52 | k++; 53 | if (s[j] > s[k]) 54 | k = i; 55 | ++j; 56 | } 57 | while (i <= k) 58 | i += j - k; 59 | } 60 | cout << s.substr(ans, n / 2); 61 | return 0; 62 | } -------------------------------------------------------------------------------- /String Algorithms/String_Matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | int rabin_karp_count(string &s, string &p) 24 | { 25 | const int f = 31; // mutiplicative constant 26 | int ns = s.size(), np = p.size(), res = 0; 27 | 28 | vll p_pow(max(ns, np)); 29 | p_pow[0] = 1; 30 | for (long i = 1; i < p_pow.size(); ++i) // generating powers of f 31 | p_pow[i] = (p_pow[i - 1] * f) % O; 32 | 33 | vll h(ns + 1, 0); 34 | for (long i = 0; i < ns; ++i) // generating hash of sample string 35 | h[i + 1] = (h[i] + (s[i] - 'a' + 1) * p_pow[i]) % O; 36 | ll hp = 0; 37 | for (long i = 0; i < np; ++i) // calculating hash value of pattern 38 | hp = (hp + (p[i] - 'a' + 1) * p_pow[i]) % O; 39 | 40 | for (long i = 0; i + np - 1 < ns; ++i) // counting substrings with same hash value 41 | { 42 | ll tmp = (h[i + np] + O - h[i]) % O; 43 | if (tmp == hp * p_pow[i] % O) 44 | res++; 45 | } 46 | return res; 47 | } 48 | 49 | void solve() 50 | { 51 | string s, p; 52 | cin >> s >> p; 53 | cout << rabin_karp_count(s, p); 54 | } 55 | 56 | int main() 57 | { 58 | fast; 59 | solve(); 60 | return 0; 61 | } -------------------------------------------------------------------------------- /String Algorithms/Word_Combinations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define N 100005 4 | #define M 10000005 5 | #define O 1000000007 6 | #define vi vector 7 | #define vl vector 8 | #define vb vector 9 | #define vll vector 10 | #define pii pair 11 | #define pll pair 12 | #define fo(i, N) for (long i = 0; i < N; ++i) 13 | #define fos(i, b, N) for (long i = b; i < N; ++i) 14 | #define forr(i, N) for (long i = N; i >= 0; --i) 15 | const double PI = 3.141592653589793238; 16 | const ll oo = 1e18; 17 | #define fast \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); 20 | 21 | using namespace std; 22 | 23 | int trie[1000005][26]; 24 | int stop[1000005]; 25 | int dp[5005]; 26 | int ct = 0; 27 | 28 | void insert(string s) 29 | { 30 | int node = 0; 31 | for (int i = 0; i < s.size(); ++i) 32 | { 33 | if (!trie[node][s[i] - 'a']) 34 | trie[node][s[i] - 'a'] = ++ct; 35 | node = trie[node][s[i] - 'a']; 36 | } 37 | stop[node] = 1; 38 | } 39 | string s; 40 | 41 | int search(int x) 42 | { 43 | int node = 0, ans = 0; 44 | for (int i = x; i < s.size(); ++i) 45 | { 46 | if (!trie[node][s[i] - 'a']) 47 | return ans; 48 | node = trie[node][s[i] - 'a']; 49 | if (stop[node]) 50 | { 51 | ans = (ans + dp[i + 1]) % O; 52 | } 53 | } 54 | return ans; 55 | } 56 | 57 | void solve() 58 | { 59 | cin >> s; 60 | long k; 61 | cin >> k; 62 | while (k--) 63 | { 64 | string x; 65 | cin >> x; 66 | insert(x); 67 | } 68 | dp[s.size()] = 1; 69 | for (int i = s.size() - 1; i >= 0; --i) 70 | dp[i] = search(i); 71 | cout << dp[0]; 72 | } 73 | 74 | int main() 75 | { 76 | fast; 77 | solve(); 78 | return 0; 79 | } -------------------------------------------------------------------------------- /String Algorithms/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/String Algorithms/a.out -------------------------------------------------------------------------------- /Tree Algorithms/Fixed-Length_Paths_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 16 | 17 | typedef long long ll; 18 | typedef pair pii; 19 | typedef pair pll; 20 | typedef vector vi; 21 | typedef vector vll; 22 | typedef vector vb; 23 | typedef vector vvb; 24 | typedef vector vvi; 25 | typedef vector vvll; 26 | 27 | void __print(int x) {cerr << x;} 28 | void __print(long x) {cerr << x;} 29 | void __print(long long x) {cerr << x;} 30 | void __print(unsigned x) {cerr << x;} 31 | void __print(unsigned long x) {cerr << x;} 32 | void __print(unsigned long long x) {cerr << x;} 33 | void __print(float x) {cerr << x;} 34 | void __print(double x) {cerr << x;} 35 | void __print(long double x) {cerr << x;} 36 | void __print(char x) {cerr << '"' << x << '"';} 37 | void __print(const char *x) {cerr << '"' << x << '"';} 38 | void __print(const string &x) {cerr << '"' << x << '"';} 39 | void __print(bool x) {cerr << (x ? "true" : "false");} 40 | 41 | template 42 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 43 | template 44 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 45 | void _print() {cerr << "]" << endl;} 46 | template 47 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 48 | 49 | #ifndef ONLINE_JUDGE 50 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 51 | #else 52 | #define deb(x...) 53 | #endif 54 | 55 | const double PI = 3.1415926535897932384626; 56 | const ll oo = 1e18; 57 | 58 | void solution(ll testno) {} 59 | 60 | signed main() 61 | { 62 | fastIO; 63 | ll test = 1; 64 | cin >> test; 65 | fo(i, 1, test + 1) 66 | solution(i); 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Tree Algorithms/Fixed_Length_Paths_I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout << fixed << setprecision(6); 17 | 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | typedef pair pll; 22 | typedef vector vi; 23 | typedef vector vll; 24 | typedef vector vb; 25 | typedef vector vvb; 26 | typedef vector vvi; 27 | typedef vector vvll; 28 | 29 | void __print(int x) {cerr << x;} 30 | void __print(long x) {cerr << x;} 31 | void __print(long long x) {cerr << x;} 32 | void __print(unsigned x) {cerr << x;} 33 | void __print(unsigned long x) {cerr << x;} 34 | void __print(unsigned long long x) {cerr << x;} 35 | void __print(float x) {cerr << x;} 36 | void __print(double x) {cerr << x;} 37 | void __print(long double x) {cerr << x;} 38 | void __print(char x) {cerr << '"' << x << '"';} 39 | void __print(const char *x) {cerr << '"' << x << '"';} 40 | void __print(const string &x) {cerr << '"' << x << '"';} 41 | void __print(bool x) {cerr << (x ? "true" : "false");} 42 | 43 | template 44 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 45 | template 46 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 47 | void _print() {cerr << "]" << endl;} 48 | template 49 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 50 | 51 | #ifndef ONLINE_JUDGE 52 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 53 | #else 54 | #define deb(x...) 55 | #endif 56 | 57 | const double PI = 3.1415926535897932384626; 58 | const ll oo = 9e18; 59 | const double EPS = 1e-6; 60 | 61 | void solution(int testno) { 62 | // 63 | } 64 | 65 | signed main() 66 | { 67 | fastIO; 68 | int test = 1; 69 | cin >> test; 70 | clock_t begin, end; 71 | 72 | fo(i,1,test+1) { 73 | begin = clock(); 74 | solution(i); 75 | end = clock(); 76 | cerr << "[ Case :- " << i << " | Time Taken :- " << ((ld)end - (ld)begin) / CLOCKS_PER_SEC << " ]" << endl; 77 | } 78 | return 0; 79 | } -------------------------------------------------------------------------------- /Tree Algorithms/Subordinates.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100005 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, val, sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define fastIO \ 16 | ios_base::sync_with_stdio(false); \ 17 | cin.tie(NULL); \ 18 | cout.precision(12); 19 | 20 | typedef long long ll; 21 | typedef pair pll; 22 | typedef pair plll; 23 | typedef vector vi; 24 | typedef vector vl; 25 | typedef vector vll; 26 | typedef vector vb; 27 | typedef vector vvb; 28 | typedef vector vvl; 29 | typedef vector vvll; 30 | 31 | const double PI = 3.141592653589793238; 32 | const ll oo = 1e18; 33 | 34 | ll n; 35 | vl gr[2 * N], ans(2 * N, 0); 36 | 37 | long dfs(long s) 38 | { 39 | for (auto i : gr[s]) 40 | ans[s] += dfs(i) + 1; 41 | return ans[s]; 42 | } 43 | 44 | void solution() 45 | { 46 | ll tmp; 47 | cin >> n; 48 | fo(i, 2, n + 1) 49 | { 50 | cin >> tmp; 51 | gr[tmp].pb(i); 52 | } 53 | dfs(1); 54 | fo(i, 1, n + 1) cout << ans[i] << " "; 55 | } 56 | 57 | signed main() 58 | { 59 | fastIO; 60 | solution(); 61 | return 0; 62 | } -------------------------------------------------------------------------------- /Tree Algorithms/Tree_Diameter.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define deb(x) cout << #x << '=' << x << endl; 16 | #define deb2(x, y) cout << #x << '=' << x << ',' << #y << '=' << y << endl; 17 | #define fastIO \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); \ 20 | cout.precision(12); 21 | 22 | typedef long long ll; 23 | typedef pair pii; 24 | typedef pair pll; 25 | typedef vector vi; 26 | typedef vector vll; 27 | typedef vector vb; 28 | typedef vector vvb; 29 | typedef vector vvi; 30 | typedef vector vvll; 31 | 32 | const double PI = 3.1415926535897932384626; 33 | const ll oo = 1e18; 34 | 35 | ll n, u, v; 36 | vll adj[2 * N]; 37 | 38 | ll dfs(ll ver, ll par, ll &longest) 39 | { 40 | ll res = 0; 41 | 42 | priority_queue pq; 43 | for (auto &ed : adj[ver]) 44 | { 45 | if (ed == par) 46 | continue; 47 | ll tmp = 0; 48 | res = max(res, dfs(ed, ver, tmp)); 49 | pq.push(tmp); 50 | } 51 | 52 | if (!pq.empty()) 53 | { 54 | longest = 1 + pq.top(); 55 | pq.pop(); 56 | } 57 | longest = max(longest, 1ll); 58 | 59 | res = max(res, longest + (!pq.empty() ? pq.top() : 0ll)); 60 | return res; 61 | } 62 | 63 | void solution() 64 | { 65 | cin >> n; 66 | fo(i, 1, n) 67 | { 68 | cin >> u >> v; 69 | adj[u].pb(v); 70 | adj[v].pb(u); 71 | } 72 | ll longest = 0; 73 | cout << dfs(1, -1, longest) - 1; 74 | } 75 | 76 | signed main() 77 | { 78 | fastIO; 79 | long t = 1; 80 | // cin >> t; 81 | while (t--) 82 | solution(); 83 | return 0; 84 | } -------------------------------------------------------------------------------- /Tree Algorithms/Tree_Matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define fo(i, b, n) for (long i = b; i < n; ++i) 8 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 9 | #define all(ar) ar.begin(), ar.end() 10 | #define rall(ar) ar.rbegin(), ar.rend() 11 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 12 | #define fi first 13 | #define se second 14 | #define pb push_back 15 | #define deb(x) cout << #x << '=' << x << endl; 16 | #define deb2(x, y) cout << #x << '=' << x << ', ' << #y << '=' << y << endl; 17 | #define fastIO \ 18 | ios_base::sync_with_stdio(false); \ 19 | cin.tie(NULL); \ 20 | cout.precision(12); 21 | 22 | typedef long long ll; 23 | typedef pair pii; 24 | typedef pair pll; 25 | typedef vector vi; 26 | typedef vector vll; 27 | typedef vector vb; 28 | typedef vector vvb; 29 | typedef vector vvi; 30 | typedef vector vvll; 31 | 32 | const double PI = 3.1415926535897932384626; 33 | const ll oo = 1e18; 34 | 35 | vll adj[2 * N]; 36 | ll dp[2 * N][2], n, u, v; 37 | 38 | void dfs(ll vt, ll par) 39 | { 40 | for (auto &to : adj[vt]) 41 | { 42 | if (to == par) 43 | continue; 44 | dfs(to, vt); 45 | dp[vt][0] += max(dp[to][0], dp[to][1]); 46 | } 47 | 48 | for (auto &to : adj[vt]) 49 | { 50 | if (to == par) 51 | continue; 52 | // 1 2 3 4 53 | dp[vt][1] = max(dp[vt][1], dp[to][0] + 1 + dp[vt][0] - max(dp[to][0], dp[to][1])); 54 | } 55 | } 56 | 57 | /* 58 | 1 - maximum set with to as root without selecting any child of to 59 | 2 - the extra added edge into set 60 | 3 - the maximum set without selecting any child of vt 61 | 4 - the value which was added to [3] while calculating [3] 62 | */ 63 | 64 | void solution() 65 | { 66 | cin >> n; 67 | fo(i, 1, n) 68 | { 69 | cin >> u >> v; 70 | adj[u - 1].pb(v - 1); 71 | adj[v - 1].pb(u - 1); 72 | } 73 | dfs(0, -1); 74 | cout << max(dp[0][0], dp[0][1]); 75 | } 76 | 77 | signed main() 78 | { 79 | fastIO; 80 | long t = 1; 81 | // cin >> t; 82 | while (t--) 83 | solution(); 84 | return 0; 85 | } -------------------------------------------------------------------------------- /Tree Algorithms/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MojoAlpha/CSES-Problemset/b682028e0b6005c5bdb47b13ca2a9baeb8b3c840/Tree Algorithms/a.out -------------------------------------------------------------------------------- /format.txt: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define N 100002 6 | #define MOD 1000000007 7 | #define MOD2 998244353 8 | #define fo(i, b, n) for (long i = b; i < n; ++i) 9 | #define rfo(i, b, n) for (long i = b; i >= n; --i) 10 | #define all(ar) ar.begin(), ar.end() 11 | #define rall(ar) ar.rbegin(), ar.rend() 12 | #define mem(ar, val) memset(ar, (val), sizeof(ar)) 13 | #define fi first 14 | #define se second 15 | #define pb push_back 16 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(12); 17 | 18 | typedef long long ll; 19 | typedef pair pii; 20 | typedef pair pll; 21 | typedef vector vi; 22 | typedef vector vll; 23 | typedef vector vb; 24 | typedef vector vvb; 25 | typedef vector vvi; 26 | typedef vector vvll; 27 | 28 | void __print(int x) {cerr << x;} 29 | void __print(long x) {cerr << x;} 30 | void __print(long long x) {cerr << x;} 31 | void __print(unsigned x) {cerr << x;} 32 | void __print(unsigned long x) {cerr << x;} 33 | void __print(unsigned long long x) {cerr << x;} 34 | void __print(float x) {cerr << x;} 35 | void __print(double x) {cerr << x;} 36 | void __print(long double x) {cerr << x;} 37 | void __print(char x) {cerr << '"' << x << '"';} 38 | void __print(const char *x) {cerr << '"' << x << '"';} 39 | void __print(const string &x) {cerr << '"' << x << '"';} 40 | void __print(bool x) {cerr << (x ? "true" : "false");} 41 | 42 | template 43 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 44 | template 45 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 46 | void _print() {cerr << "]" << endl;} 47 | template 48 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 49 | 50 | #ifndef ONLINE_JUDGE 51 | #define deb(x...) cerr << "[" << #x << "] = ["; _print(x) 52 | #else 53 | #define deb(x...) 54 | #endif 55 | 56 | const double PI = 3.1415926535897932384626; 57 | const ll oo = 1e18; 58 | const double EPS = 1e-6; 59 | 60 | void solution(ll testno) {} 61 | 62 | signed main() 63 | { 64 | fastIO; 65 | ll test = 1; 66 | cin >> test; 67 | fo(i, 1, test + 1) { 68 | solution(i); 69 | cout << endl; 70 | } 71 | return 0; 72 | } --------------------------------------------------------------------------------