├── Sorting and Searching
    ├── 26_movie_festival_2.cpp
    ├── 25_sliding_cost.cpp
    ├── 16_reading_books.cpp
    ├── 08_maximum_subaray_sum.cpp
    ├── 01_distinct_numbers.cpp
    ├── 22_subarray_divisibility.cpp
    ├── 21_subarray_sums_2.cpp
    ├── 09_stick_lengths.cpp
    ├── 11_towers.cpp
    ├── 19_nearest_smaller_values.cpp
    ├── 15_tasks_and_deadlines.cpp
    ├── 20_subarray_sums_1.cpp
    ├── 24_sliding_median.cpp
    ├── 07_sum_of_two_values.cpp
    ├── 06_movie_festival.cpp
    ├── 03_ferris_wheel.cpp
    ├── 10_playlist.cpp
    ├── 04_concert_tickets.cpp
    ├── 12_traffic_lights.cpp
    ├── 17_sum_of_three_values.cpp
    ├── 27_maximum_subarray_sum_2.cpp
    ├── 05_restaurant_customers.cpp
    ├── 02_apartments.cpp
    ├── 18_sum_of_four_values.cpp
    ├── 23_array_divison.cpp
    ├── 14_factory_machines.cpp
    └── 13_room_allocation.cpp
├── .gitignore
├── Guide-to-Competitive-Programming-Learning-and-improving-Algorithms-through-Contests.pdf
├── String Algorithms
    ├── 04_finding_periods.cpp
    ├── 03_finding_borders.cpp
    ├── 05_minimal_rotation.cpp
    ├── 02_string_matching.cpp
    └── 01_word_combinations.cpp
├── Introductory Problems
    ├── 10_trailing_zeros.cpp
    ├── 02_missing_number.cpp
    ├── 09_bit_strings.cpp
    ├── 07_two_knights.cpp
    ├── 03_repetitions.cpp
    ├── 01_weird_algorithm.cpp
    ├── 04_increasing_array.cpp
    ├── 05_permutations.cpp
    ├── 13_creating_strings_1.cpp
    ├── temp.cpp
    ├── 12_palindrome_reorder.cpp
    ├── 14_apple_division.cpp
    ├── 11_coin_piles.cpp
    ├── 08_two_sets.cpp
    ├── 06_number_spiral.cpp
    └── 15_chessboard_nd_queens.cpp
├── README.md
├── Dynamic Programming
    ├── 01_dice_combinations.cpp
    ├── 05_removing_digits.cpp
    ├── 14_increasing_subsequence.cpp
    ├── 04_coin_combinations_2.cpp
    ├── 11_money_sums.cpp
    ├── 15_projects.cpp
    ├── 10_rectangle_cutting.cpp
    ├── 13_two_sets_2.cpp
    ├── 07_book_shop.cpp
    ├── 12_removal_game.cpp
    ├── 03_coin_combinations_1.cpp
    ├── 09_edit_distance.cpp
    ├── 06_grid_paths.cpp
    ├── 02_minimizing_coins.cpp
    └── 08_array_description.cpp
└── Path Finding Algorithms
    ├── dijkistra_algo.cpp
    └── floyd_warshall_algo.cpp


/Sorting and Searching/26_movie_festival_2.cpp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | Sorting and Searching/.vscode/settings.json
3 | Dynamic Programming/.vscode/settings.json
4 | 


--------------------------------------------------------------------------------
/Guide-to-Competitive-Programming-Learning-and-improving-Algorithms-through-Contests.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ravi-kr-singh/CSES_Competitive_Programming/HEAD/Guide-to-Competitive-Programming-Learning-and-improving-Algorithms-through-Contests.pdf


--------------------------------------------------------------------------------
/String Algorithms/04_finding_periods.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | A period of a string is a prefix that can be used to generate the whole string by repeating the prefix. The last repetition may be partial. For example, the periods of abcabca are abc, abcabc and abcabca.
 4 | 
 5 | Your task is to find all period lengths of a string.
 6 | 
 7 | Input
 8 | 
 9 | The only input line has a string of length n consisting of characters a–z.
10 | 
11 | Output
12 | 
13 | Print all period lengths in increasing order.
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example
18 | 
19 | Input:
20 | abcabca
21 | 
22 | Output:
23 | 3 6 7
24 | */


--------------------------------------------------------------------------------
/Introductory Problems/10_trailing_zeros.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to calculate the number of trailing zeros in the factorial n!.
 4 | 
 5 | For example, 20!=2432902008176640000 and it has 4 trailing zeros.
 6 | 
 7 | Input
 8 | 
 9 | The only input line has an integer n.
10 | 
11 | Output
12 | 
13 | Print the number of trailing zeros in n!.
14 | 
15 | Constraints
16 | 1≤n≤10^9
17 | Example
18 | 
19 | Input:
20 | 20
21 | 
22 | Output:
23 | 4
24 | 
25 | */
26 | 
27 | #include<iostream>
28 | 
29 | using namespace std;
30 | 
31 | int main(){
32 |     int n;
33 |     cin>>n;
34 | 
35 |     long long ans=0;
36 |     while(n>0){
37 |         ans+=n/5;
38 |         n/=5;
39 |     }
40 |     cout<<ans;
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/String Algorithms/03_finding_borders.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | A border of a string is a prefix that is also a suffix of the string but not the whole string. For example, the borders of abcababcab are ab and abcab.
 4 | 
 5 | Your task is to find all border lengths of a given string.
 6 | 
 7 | Input
 8 | 
 9 | The only input line has a string of length n consisting of characters a–z.
10 | 
11 | Output
12 | 
13 | Print all border lengths of the string in increasing order.
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example
18 | 
19 | Input:
20 | abcababcab
21 | 
22 | Output:
23 | 2 5
24 | */
25 | 
26 | #include<iostream>
27 | using namespace std;
28 | 
29 | int main(){
30 |     string str;
31 |     cin>>str;
32 |     int n = str.size();
33 | 
34 |     
35 | 
36 | 
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## CSES Problem Set Solutions
 2 | 
 3 | These are solutions of 200 problems mentioned on https://cses.fi/problemset/ in C++.
 4 | It is a finnish competitive programming site.
 5 | 
 6 | ### Introductory Problems
 7 | 1. Weird Algorithm
 8 | 2. Missing Number  
 9 | 3. Repetitions
10 | 4. Increasing Array
11 | 5. Permutations
12 | 6. Number Spiral
13 | 7. Two Knights
14 | 8. Two Sets
15 | 9. Bit Strings
16 | 10. Trailing Zeros
17 | 11. Coin Piles
18 | 12. Palindrome Reorder
19 | 13. Creating Strings I
20 | 14. Apple Division
21 | 15. Chessboard and Queens
22 | 16. Grid Paths
23 | 
24 | ### Sorting and Searching
25 | 1. Distinct Numbers
26 | 2. Apartments
27 | 3. Ferris Wheel
28 | 4. Concert Tickets
29 | 5. Restaurant Customers
30 | 6. Movie Festival
31 | 7. Sum of Two Values
32 | 8. Maximum Subarray Sum
33 | 
34 | 


--------------------------------------------------------------------------------
/String Algorithms/05_minimal_rotation.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | A rotation of a string can be generated by moving characters one after another from beginning to end. For example, the rotations of acab are acab, caba, abac, and baca.
 3 | 
 4 | Your task is to determine the lexicographically minimal rotation of a string.
 5 | 
 6 | Input
 7 | 
 8 | The only input line contains a string of length n. Each character is one of a–z.
 9 | 
10 | Output
11 | 
12 | Print the lexicographically minimal rotation.
13 | 
14 | Constraints
15 | 1≤n≤10^6
16 | Example
17 | 
18 | Input:
19 | acab
20 | 
21 | Output:
22 | abac
23 | */
24 | 
25 | #include<iostream>
26 | #include<algorithm>
27 | using namespace std;
28 | 
29 | 
30 | int main(){
31 |     string str;
32 |     cin>>str;
33 |     next_permutation(str.begin(),str.end());
34 |     cout<<str;
35 | 
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/Sorting and Searching/25_sliding_cost.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array of n integers. Your task is to calculate for each window of k elements, from left to right, the minimum total cost of making all elements equal.
 4 | 
 5 | You can increase or decrease each element with cost x where x is the difference between the new and the original value. The total cost is the sum of such costs.
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains two integers n and k: the number of elements and the size of the window.
10 | 
11 | Then there are n integers x1,x2,…,xn: the contents of the array.
12 | 
13 | Output
14 | 
15 | Output n−k+1 values: the costs.
16 | 
17 | Constraints
18 | 1≤k≤n≤2⋅105
19 | 1≤xi≤109
20 | Example
21 | 
22 | Input:
23 | 8 3
24 | 2 4 3 5 8 1 2 1
25 | 
26 | Output:
27 | 2 2 5 7 7 1
28 | */


--------------------------------------------------------------------------------
/Introductory Problems/02_missing_number.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given all numbers between 1,2,…,n except one. Your task is to find the missing number.
 4 | 
 5 | Input
 6 | 
 7 | The first input line contains an integer n.
 8 | 
 9 | The second line contains n−1 numbers. Each number is distinct and between 1 and n (inclusive).
10 | 
11 | Output
12 | 
13 | Print the missing number.
14 | 
15 | Constraints
16 | 2≤n≤2⋅10^5
17 | Example
18 | 
19 | Input:
20 | 5
21 | 2 3 1 5
22 | 
23 | Output:
24 | 4
25 | 
26 | */
27 | 
28 | #include<iostream>
29 | 
30 | using namespace std;
31 | 
32 | 
33 | int main(){
34 |     int n;
35 |     cin>>n;
36 |     int* arr=new int[n+1]{0};
37 |     for(int i=1;i<n;i++){
38 |         int t;
39 |         cin>>t;
40 |         arr[t]++;
41 |     }
42 |     for(int i=1;i<=n;i++){
43 |         if(arr[i]==0){
44 |             cout<<i;
45 |             return 0;
46 |         }
47 |     }
48 | 
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/Sorting and Searching/16_reading_books.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n books, and Kotivalo and Justiina are going to read them all. For each book, you know the time it takes to read it.
 4 | 
 5 | They both read each book from beginning to end, and they cannot read a book at the same time. What is the minimum total time required?
 6 | 
 7 | Input
 8 | 
 9 | The first input line has an integer n: the number of books.
10 | 
11 | The second line has n integers t1,t2,…,tn: the time required to read each book.
12 | 
13 | Output
14 | 
15 | Print one integer: the minimum total time.
16 | 
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤ti≤10^9
20 | Example
21 | 
22 | Input:
23 | 3
24 | 2 8 3
25 | 
26 | Output:
27 | 16
28 | */
29 | 
30 | #include<iostream>
31 | using namespace std;
32 | 
33 | int main(){
34 |     int n;
35 |     cin>>n;
36 |     int* books = new int[n];
37 |     for(int i=0;i<n;i++)
38 |         cin>>books[i];
39 |     
40 | 
41 | 
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Introductory Problems/09_bit_strings.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to calculate the number of bit strings of length n.
 4 | 
 5 | For example, if n=3, the correct answer is 8, because the possible bit strings are 000, 001, 010, 011, 100, 101, 110, and 111.
 6 | 
 7 | Input
 8 | 
 9 | The only input line has an integer n.
10 | 
11 | Output
12 | 
13 | Print the result modulo 10^9+7.
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example
18 | 
19 | Input:
20 | 3
21 | 
22 | Output:
23 | 8
24 | 
25 | */
26 | 
27 | #include<iostream>
28 | using namespace std;
29 | 
30 | #define Limit 1000000007
31 | 
32 | long long find_ans(int n){
33 |     if(n==0)
34 |         return 1;
35 |     
36 |     long long ans=find_ans(n/2);
37 |     ans*=ans;
38 |     ans%=Limit;
39 |     if(n&1){
40 |         ans*=2;
41 |         ans%=Limit;
42 |     }
43 |     return ans;
44 | }
45 | 
46 | int main(){
47 |     int n;
48 |     cin>>n;
49 |     cout<<find_ans(n);
50 | 
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/Introductory Problems/07_two_knights.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to count for k=1,2,…,n the number of ways two knights can be placed on a k×k chessboard so that they do not attack each other.
 4 | 
 5 | Input
 6 | 
 7 | The only input line contains an integer n.
 8 | 
 9 | Output
10 | 
11 | Print n integers: the results.
12 | 
13 | Constraints
14 | 1≤n≤10000
15 | Example
16 | 
17 | Input:
18 | 8
19 | 
20 | Output:
21 | 0
22 | 6
23 | 28
24 | 96
25 | 252
26 | 550
27 | 1056
28 | 1848
29 | 
30 | */
31 | 
32 | #include<iostream>
33 | using namespace std;
34 | 
35 | int m=0;
36 | int f=0;
37 | 
38 | long long number_of_ways(long long t){
39 |     long long total_ways=(t*(t-1))/2;
40 |     long long ans=total_ways-(8*f);    
41 |     m++;
42 |     f+=m;
43 |     return ans;
44 | 
45 | }
46 | 
47 | int main(){
48 |     int n;
49 |     cin>>n;
50 |     cout<<0<<endl;
51 |     for(int i=2;i<=n;i++){
52 |         cout<<number_of_ways(i*i)<<endl;
53 |     }
54 | 
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Sorting and Searching/08_maximum_subaray_sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n integers, your task is to find the maximum sum of values in a contiguous, nonempty subarray.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the size of the array.
 8 | 
 9 | The second line has n integers x1,x2,…,xn: the array values.
10 | 
11 | Output
12 | 
13 | Print one integer: the maximum subarray sum.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | −10^9≤xi≤10^9
18 | Example
19 | 
20 | Input:
21 | 8
22 | -1 3 -2 5 3 -5 2 2
23 | 
24 | Output:
25 | 9
26 | */
27 | 
28 | #include<iostream>
29 | using namespace std;
30 | 
31 | int main(){
32 |     int n;
33 |     cin>>n;
34 |     int* arr = new int[n];
35 |     for(int i=0;i<n;i++)
36 |         cin>>arr[i];
37 |     
38 |     long long ans = arr[0];
39 |     long long temp = arr[0];
40 |     for(int i=1;i<n;i++){
41 |         long long num = arr[i];
42 |         temp = max(num,num+temp);
43 |         ans = max(ans,temp);
44 |     }
45 |     cout<<ans;
46 | 
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/Introductory Problems/03_repetitions.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Time limit: 1.00 s Memory limit: 512 MB
 4 | You are given a DNA sequence: a string consisting of characters A, C, G, and T. Your task is to find the longest repetition in the sequence. This is a maximum-length substring containing only one type of character.
 5 | 
 6 | Input
 7 | 
 8 | The only input line contains a string of n characters.
 9 | 
10 | Output
11 | 
12 | Print one integer: the length of the longest repetition.
13 | 
14 | Constraints
15 | 1≤n≤10^6
16 | Example
17 | 
18 | Input:
19 | ATTCGGGA
20 | 
21 | Output:
22 | 3
23 | 
24 | */
25 | 
26 | #include<iostream>
27 | #include<string>
28 | using namespace std;
29 | 
30 | int main(){
31 |     string sequence;
32 |     getline(cin,sequence);
33 | 
34 |     int ans=1;
35 |     int temp=1;
36 |     for(int i=1;i<sequence.size();i++){
37 |         if(sequence[i]==sequence[i-1])
38 |             temp++;
39 |         else{
40 |             ans=max(ans,temp);
41 |             temp=1;
42 |         }
43 |     }
44 |     ans=max(ans,temp);
45 |     cout<<ans;
46 | 
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Sorting and Searching/01_distinct_numbers.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given a list of n integers, and your task is to calculate the number of distinct values in the list.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the number of values.
 8 | 
 9 | The second line has n integers x1,x2,…,xn.
10 | 
11 | Output
12 | 
13 | Print one integers: the number of distinct values.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤xi≤10^9
18 | Example
19 | 
20 | Input:
21 | 5
22 | 2 3 2 2 3
23 | 
24 | Output:
25 | 2
26 | */
27 | 
28 | #include<iostream>
29 | #include<algorithm>
30 | using namespace std;
31 | 
32 | int main(){
33 |     int n;
34 |     cin>>n;
35 |     int* arr = new int[n];
36 |     for(int i=0;i<n;i++)
37 |         cin>>arr[i];
38 |     sort(arr,arr+n);
39 |     
40 |     int count = 1;
41 |     int i = 1;
42 |     while(i<n){
43 |         while(i<n && arr[i]==arr[i-1])
44 |             i++;
45 |         if(i==n)
46 |             break;
47 |         count++;
48 |         i++;
49 |     }
50 | 
51 |     cout<<count;
52 | 
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/Dynamic Programming/01_dice_combinations.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to count the number of ways to construct sum n by throwing a dice one or more times. Each throw produces an outcome between 1 and 6.
 4 | 
 5 | For example, if n=3, there are 4 ways:
 6 | 1+1+1
 7 | 1+2
 8 | 2+1
 9 | 3
10 | Input
11 | 
12 | The only input line has an integer n.
13 | 
14 | Output
15 | 
16 | Print the number of ways modulo 109+7.
17 | 
18 | Constraints
19 | 1≤n≤10^6
20 | Example
21 | 
22 | Input:
23 | 3
24 | 
25 | Output:
26 | 4
27 | */
28 | 
29 | #include<iostream>
30 | #include<vector>
31 | using namespace std;
32 | 
33 | int find_ways(int i,int* dp){
34 |     if(i<0)
35 |         return 0;
36 |     if(dp[i]!=0)
37 |         return dp[i];
38 |     else{
39 |         dp[i] = 0;
40 |         for(int j=1;j<=6;j++){
41 |             dp[i] += find_ways(i-j,dp);
42 |             dp[i] = dp[i] % 1000000007;
43 |         }
44 |         return dp[i];
45 | 
46 |     }
47 | }
48 | 
49 | int main(){
50 |     int n;
51 |     cin>>n;
52 |     int* dp = new int[n+1]{1};
53 |     cout<<find_ways(n,dp);
54 | 
55 | }


--------------------------------------------------------------------------------
/Dynamic Programming/05_removing_digits.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an integer n. On each step, you may substract from it any one-digit number that appears in it.
 4 | 
 5 | How many steps are required to make the number equal to 0?
 6 | 
 7 | Input
 8 | 
 9 | The only input line has an integer n.
10 | 
11 | Output
12 | 
13 | Print one integer: the minimum number of steps.
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example
18 | 
19 | Input:
20 | 27
21 | 
22 | Output:
23 | 5
24 | 
25 | Explanation: An optimal solution is 27→20→18→10→9→0
26 | */
27 | 
28 | #include<iostream>
29 | #include<vector>
30 | #include<climits>
31 | using namespace std;
32 | 
33 | int min_steps_required(int n,vector<int>& dp){
34 |     if(dp[n]!=-1)
35 |         return dp[n];
36 |     
37 |     int digit = INT_MIN;
38 |     for(int i=n;i>0;i/=10)
39 |         digit = max(digit,i%10);
40 |     
41 |     dp[n] = 1+min_steps_required(n-digit,dp);
42 |     return dp[n];
43 | }
44 | 
45 | int main(){
46 |     int n;
47 |     cin>>n;
48 |     vector<int> dp(n+1,-1);
49 |     dp[0] = 0;
50 |     cout<<min_steps_required(n,dp);
51 | 
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Introductory Problems/01_weird_algorithm.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Consider an algorithm that takes as input a positive integer n. If n is even, the algorithm divides it by two, and if n is odd, the algorithm multiplies it by three and adds one. The algorithm repeats this, until n is one. For example, the sequence for n=3 is as follows:
 4 | 3→10→5→16→8→4→2→1
 5 | 
 6 | Your task is to simulate the execution of the algorithm for a given value of n.
 7 | 
 8 | Input
 9 | 
10 | The only input line contains an integer n.
11 | 
12 | Output
13 | 
14 | Print a line that contains all values of n during the algorithm.
15 | 
16 | Constraints
17 | 1≤n≤10^6
18 | Example
19 | 
20 | Input:
21 | 3
22 | 
23 | Output:
24 | 3 10 5 16 8 4 2 1
25 | 
26 | */
27 | 
28 | 
29 | #include<iostream>
30 | 
31 | using namespace std;
32 | 
33 | void weird(long long n){
34 |     while(n!=1){
35 |         cout<<n<<" ";
36 |         if(n&1){
37 |             n*=3;
38 |             n++;
39 |         }
40 |         else
41 |             n/=2;
42 |     }
43 |     cout<<n;
44 | }
45 | 
46 | 
47 | int main(){
48 |     long long n;
49 |     cin>>n;
50 |     weird(n);
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/Introductory Problems/04_increasing_array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array of n integers. You want to modify the array so that it is increasing, i.e., every element is at least as large as the previous element.
 4 | 
 5 | On each turn, you may increase the value of any element by one. What is the minimum number of turns required?
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains an integer n: the size of the array.
10 | 
11 | Then, the second line contains n integers x1,x2,…,xn: the contents of the array.
12 | 
13 | Output
14 | 
15 | Print the minimum number of turns.
16 | 
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤xi≤10^9
20 | Example
21 | 
22 | Input:
23 | 5
24 | 3 2 5 1 7
25 | 
26 | Output:
27 | 5
28 | 
29 | */
30 | 
31 | #include<iostream>
32 | #include<climits>
33 | using namespace std;
34 | 
35 | int main(){
36 |     int n;
37 |     cin>>n;
38 |     int* arr=new int[n];
39 |     for(int i=0;i<n;i++)
40 |         cin>>arr[i];
41 | 
42 |     long long ans=0;
43 |     int big=arr[0];
44 |     
45 |     for(int i=1;i<n;i++){
46 |         big=max(big,arr[i]);
47 |         ans+=big-arr[i];
48 |     }
49 |     cout<<ans;
50 |     return 0;
51 | }


--------------------------------------------------------------------------------
/Sorting and Searching/22_subarray_divisibility.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n integers, your task is to count the number of subarrays where the sum of values is divisible by n.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the size of the array.
 8 | 
 9 | The next line has n integers a1,a2,…,an: the contents of the array.
10 | 
11 | Output
12 | 
13 | Print one integer: the required number of subarrays.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | −109≤ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 5
22 | 3 1 2 7 4
23 | 
24 | Output:
25 | 1
26 | */
27 | 
28 | #include<iostream>
29 | #include<map>
30 | using namespace std;
31 | 
32 | int main(){
33 |     int n;
34 |     cin>>n;
35 |     int* arr = new int[n];
36 |     for(int i=0;i<n;i++){
37 |         cin>>arr[i];
38 |     }
39 |     map<long long,int> freqSum;
40 |     
41 |     long long curr_sum = 0;
42 |     long long count = 0;
43 | 
44 |     for(int i=0;i<n;i++){
45 |         curr_sum += arr[i];
46 |         
47 |         int remainder = ((curr_sum % n) + n) % n;
48 | 
49 |         if(remainder == 0)
50 |             count++;
51 |         
52 |         count += freqSum[remainder];
53 | 
54 |         freqSum[remainder]++;
55 |         
56 |     }
57 |     cout<<count<<endl;
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Sorting and Searching/21_subarray_sums_2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n integers, your task is to count the number of subarrays having sum x.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has two integers n and x: the size of the array and the target sum x.
 8 | 
 9 | The next line has n integers a1,a2,…,an: the contents of the array.
10 | 
11 | Output
12 | 
13 | Print one integer: the required number of subarrays.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | −109≤x,ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 5 7
22 | 2 -1 3 5 -2
23 | 
24 | Output:
25 | 2
26 | */
27 | 
28 | #include<iostream>
29 | #include<map>
30 | using namespace std;
31 | 
32 | int main(){
33 | 
34 |     int n,x;
35 |     cin>>n>>x;
36 | 
37 |     int* arr = new int[n];
38 |     for(int i=0;i<n;i++)
39 |         cin>>arr[i];
40 | 
41 |     long long curr_sum = 0;
42 |     long long count = 0;
43 |     map<long long,int> freqSum;
44 | 
45 |     
46 |     for(int i=0;i<n;i++){
47 |         curr_sum += arr[i];
48 | 
49 |         if(curr_sum == x)
50 |             count++;
51 | 
52 |         //if(freqSum.find(curr_sum-x) != freqSum.end())
53 |             count += freqSum[curr_sum-x];
54 | 
55 |         freqSum[curr_sum]++;
56 | 
57 |     }
58 | 
59 | 
60 |     cout<<count;
61 | 
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/Sorting and Searching/09_stick_lengths.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n sticks with some lengths. Your task is to modify the sticks so that each stick has the same length.
 4 | 
 5 | You can either lengthen and shorten each stick. Both operations cost x where x is the difference between the new and original length.
 6 | 
 7 | What is the minimum total cost?
 8 | 
 9 | Input
10 | 
11 | The first input line contains an integer n: the number of sticks.
12 | 
13 | Then there are n integers: p1,p2,…,pn: the lengths of the sticks.
14 | 
15 | Output
16 | 
17 | Print one integer: the minimum total cost.
18 | 
19 | Constraints
20 | 1≤n≤2⋅10^5
21 | 1≤pi≤10^9
22 | Example
23 | 
24 | Input:
25 | 5
26 | 2 3 1 5 2
27 | 
28 | Output:
29 | 5
30 | */
31 | 
32 | #include<iostream>
33 | #include<algorithm>
34 | #include<cmath>
35 | using namespace std;
36 | 
37 | 
38 | int main(){
39 |     int n;
40 |     cin>>n;
41 |     int* arr = new int[n];
42 |     for(int i=0;i<n;i++){
43 |         cin>>arr[i];
44 |     }
45 | 
46 |     nth_element(arr,arr+n/2,arr+n);  // Linear Time
47 | 
48 |     int temp = arr[n/2];
49 |     //cout<<temp<<endl;
50 |     long long ans = 0;
51 |     for(int i=0;i<n;i++)
52 |         ans += abs(temp-arr[i]);
53 |     
54 |     cout<<ans<<endl;
55 | 
56 | 
57 | 
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Sorting and Searching/11_towers.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given n cubes in a certain order, and your task is to build towers using them. Whenever two cubes are one on top of the other, the upper cube must be smaller than the lower cube.
 4 |  
 5 | You must process the cubes in the given order. You can always either place the cube on top of an existing tower, or begin a new tower. What is the minimum possible number of towers?
 6 |  
 7 | Input
 8 |  
 9 | The first input line contains an integer n: the number of cubes.
10 |  
11 | The next line contains n integers k1,k2,…,kn: the sizes of the cubes.
12 |  
13 | Output
14 |  
15 | Print one integer: the minimum number of towers.
16 |  
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤ki≤10^9
20 | Example
21 |  
22 | Input:
23 | 5
24 | 3 8 2 1 5
25 |  
26 | Output:
27 | 2
28 | */
29 |  
30 | #include<iostream>
31 | #include<set>
32 | 
33 | using namespace std;
34 |  
35 | 
36 |  
37 | int main(){
38 |     int n;
39 |     cin>>n;
40 | 
41 |     multiset<int> nums;
42 | 
43 |     for(int i=0;i<n;i++){
44 |         int x;
45 |         cin>>x;
46 |         auto it = nums.upper_bound(x);
47 |         if(it == nums.end())
48 |             nums.insert(x);
49 |         else{
50 |             nums.erase(it);
51 |             nums.insert(x);
52 |         }
53 |     }
54 |     
55 |     cout<<nums.size();
56 |  
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Sorting and Searching/19_nearest_smaller_values.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n integers, your task is to find for each array position the nearest position to its left having a smaller value.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the size of the array.
 8 | 
 9 | The second line has n integers x1,x2,…,xn: the array values.
10 | 
11 | Output
12 | 
13 | Print n integers: for each array position the nearest position with a smaller value. If there is no such position, print 0.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤xi≤10^9
18 | Example
19 | 
20 | Input:
21 | 8
22 | 2 5 1 4 8 3 2 5
23 | 
24 | Output:
25 | 0 1 0 3 4 3 3 7
26 | */
27 | 
28 | #include<iostream>
29 | #include<stack>
30 | #include<utility>
31 | #include<vector>
32 | using namespace std;
33 | 
34 | int main(){
35 |     int n;
36 |     cin>>n;
37 |     vector<pair<int,int>> arr(n);
38 |     stack<pair<int,int>> store;
39 |     for(int i=0;i<n;i++){
40 |         cin>>arr[i].first;
41 |         arr[i].second = i+1;
42 |     }
43 |     
44 |    
45 |     for(int i=0;i<n;i++){
46 |         while(!store.empty() && store.top().first >= arr[i].first )
47 |             store.pop();
48 |         if(store.empty())
49 |             cout<<"0 ";
50 |         else
51 |             cout<<store.top().second<<" ";
52 |         store.push(arr[i]);
53 |     }
54 |     
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Dynamic Programming/14_increasing_subsequence.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array containing n integers. Your task is to determine the longest increasing subsequence in the array, i.e., the longest subsequence where every element is larger than the previous one.
 4 | 
 5 | A subsequence is a sequence that can be derived from the array by deleting some elements without changing the order of the remaining elements.
 6 | 
 7 | Input
 8 | 
 9 | The first line contains an integer n: the size of the array.
10 | 
11 | After this there are n integers x1,x2,…,xn: the contents of the array.
12 | 
13 | Output
14 | 
15 | Print the length of the longest increasing subsequence.
16 | 
17 | Constraints
18 | 1≤n≤2⋅105
19 | 1≤xi≤10^9
20 | Example
21 | 
22 | Input:
23 | 8
24 | 7 3 5 3 6 2 9 8
25 | 
26 | Output:
27 | 4
28 | */
29 | 
30 | #include<iostream>
31 | using namespace std;
32 | 
33 | int main(){
34 |     int n;
35 |     cin>>n;
36 |     int* arr = new int[n];
37 |     for(int i=0;i<n;i++){
38 |         cin>>arr[i];
39 |     }
40 |     int dp[n];
41 |     dp[0] = 1;
42 |     int ans = 1;
43 |     for(int i=1;i<n;i++){
44 |         dp[i] = 1;
45 |         for(int j=0;j<i;j++){
46 |             if(arr[i]>arr[j] && dp[j]>=dp[i])
47 |                 dp[i] = dp[j] + 1;
48 |         }
49 |         ans = max(ans,dp[i]);
50 |     }
51 |     cout<<ans<<" ";
52 | 
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/Introductory Problems/05_permutations.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | A permutation of integers 1,2,…,n is called beautiful if there are no adjacent elements whose difference is 1.
 4 | 
 5 | Given n, construct a beautiful permutation if such a permutation exists.
 6 | 
 7 | Input
 8 | 
 9 | The only input line contains an integer n.
10 | 
11 | Output
12 | 
13 | Print a beautiful permutation of integers 1,2,…,n. If there are several solutions, you may print any of them. If there are no solutions, print "NO SOLUTION".
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example 1
18 | 
19 | Input:
20 | 5
21 | 
22 | Output:
23 | 4 2 5 3 1
24 | 
25 | Example 2
26 | 
27 | Input:
28 | 3
29 | 
30 | Output:
31 | NO SOLUTION
32 | 
33 | */
34 | 
35 | #include<iostream>
36 | 
37 | using namespace std;
38 | 
39 | int main(){
40 |     int n;
41 |     cin>>n;
42 |     if(n==1)
43 |         cout<<n;
44 |     else if(n<4)
45 |         cout<<"NO SOLUTION";
46 |     else if(n==4){
47 |         cout<<"2 4 1 3";
48 |     }
49 |     else{
50 |         int* arr=new int[n];
51 |         int i=0;
52 |         int t=1;
53 |         while(i<n){
54 |             arr[i]=t;
55 |             t++;
56 |             i+=2;
57 |         }
58 |         i=1;
59 |         while(i<n){
60 |             arr[i]=t;
61 |             t++;
62 |             i+=2;
63 |         }
64 |         for(int i=0;i<n;i++)
65 |             cout<<arr[i]<<" ";
66 |     }
67 | 
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/Dynamic Programming/04_coin_combinations_2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Consider a money system consisting of n coins. Each coin has a positive integer value. Your task is to calculate the number of distinct ordered ways you can produce a money sum x using the available coins.
 4 |  
 5 | For example, if the coins are {2,3,5} and the desired sum is 9, there are 3 ways:
 6 | 2+2+5
 7 | 3+3+3
 8 | 2+2+2+3
 9 | Input
10 |  
11 | The first input line has two integers n and x: the number of coins and the desired sum of money.
12 |  
13 | The second line has n distinct integers c1,c2,…,cn: the value of each coin.
14 |  
15 | Output
16 |  
17 | Print one integer: the number of ways modulo 109+7.
18 |  
19 | Constraints
20 | 1≤n≤100
21 | 1≤x≤10^6
22 | 1≤ci≤10^6
23 | Example
24 |  
25 | Input:
26 | 3 9
27 | 2 3 5
28 |  
29 | Output:
30 | 3
31 | */
32 |  
33 | #include<iostream>
34 | using namespace std;
35 |  
36 | int distinct_ways(int* coins, int n, int sum){
37 |     int dp[sum+1]{0}; 
38 |     dp[0] = 1; 
39 |     for(int i=0;i<n;i++) 
40 |         for(int j=coins[i];j<=sum;j++){
41 |             dp[j] += dp[j-coins[i]]; 
42 |             dp[j] %= 1000000007;
43 |         }
44 |     return dp[sum]; 
45 | }
46 |  
47 | int main(){
48 |     int n,x;
49 |     cin>>n>>x;
50 |     int* coins = new int[n];
51 |     for(int i=0;i<n;i++)
52 |         cin>>coins[i];
53 |     cout<<distinct_ways(coins,n,x);
54 |     
55 |  
56 |    
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Dynamic Programming/11_money_sums.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You have n coins with certain values. Your task is to find all money sums you can create using these coins.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the number of coins.
 8 | 
 9 | The next line has n integers x1,x2,…,xn: the values of the coins.
10 | 
11 | Output
12 | 
13 | First print an integer k: the number of distinct money sums. After this, print all possible sums in increasing order.
14 | 
15 | Constraints
16 | 1≤n≤100
17 | 1≤xi≤1000
18 | Example
19 | 
20 | Input:
21 | 4
22 | 4 2 5 2
23 | 
24 | Output:
25 | 9
26 | 2 4 5 6 7 8 9 11 13
27 | */
28 | 
29 | #include<iostream>
30 | #include<set>
31 | #include<vector>
32 | using namespace std;
33 | 
34 | int main(){
35 |     int n;
36 |     cin>>n;
37 |     int* coins = new int[n];
38 |     for(int i=0;i<n;i++)
39 |         cin>>coins[i];
40 |     
41 |     set<int> answer;
42 | 
43 |     answer.insert(coins[0]);
44 |   
45 |     for(int j=1;j<n;j++){
46 |         vector<int> temp(answer.size());
47 |         int i=0;
48 |         for(auto it=answer.begin();it!=answer.end();it++){
49 |             temp[i] = coins[j]+(*it);
50 |             i++;
51 |         }
52 |         for(i=0;i<temp.size();i++)
53 |             answer.insert(temp[i]);
54 |         answer.insert(coins[j]);
55 |     }
56 |     cout<<answer.size()<<endl;
57 |     for(auto it=answer.begin();it!=answer.end();it++)
58 |         cout<<(*it)<<" ";
59 | 
60 |     return 0;
61 | }


--------------------------------------------------------------------------------
/Introductory Problems/13_creating_strings_1.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given a string, your task is to generate all different strings that can be created using its characters.
 4 | 
 5 | Input
 6 | 
 7 | The only input line has a string of length n. Each character is between a–z.
 8 | 
 9 | Output
10 | 
11 | First print an integer k: the number of strings. Then print k lines: the strings in alphabetical order.
12 | 
13 | Constraints
14 | 1≤n≤8
15 | Example
16 | 
17 | Input:
18 | aabac
19 | 
20 | Output:
21 | 20
22 | aaabc
23 | aaacb
24 | aabac
25 | aabca
26 | aacab
27 | aacba
28 | abaac
29 | abaca
30 | abcaa
31 | acaab
32 | acaba
33 | acbaa
34 | baaac
35 | baaca
36 | bacaa
37 | bcaaa
38 | caaab
39 | caaba
40 | cabaa
41 | cbaaa
42 | */
43 | 
44 | #include<iostream>
45 | #include<string>
46 | #include<algorithm>
47 | using namespace std;
48 |  
49 | int factorial(int n){
50 |     if(n==0 || n==1)
51 |         return 1;
52 |     return n*factorial(n-1);
53 | }
54 |  
55 | int main(){
56 |     string str;
57 |     getline(cin,str);
58 |     int n=str.size();
59 |     int* freq=new int[26]{0};
60 |     for(int i=0;i<n;i++)
61 |         freq[str[i]-97]++;
62 |     int count=factorial(n);
63 |     for(int i=0;i<26;i++){
64 |         if(freq[i]>1)
65 |             count/=factorial(freq[i]);
66 |     }
67 |     sort(str.begin(),str.end());
68 |     cout<<count<<endl<<str<<endl;
69 |   
70 |     while(next_permutation(str.begin(),str.end()))
71 |         cout<<str<<endl;
72 |   
73 |  
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Sorting and Searching/15_tasks_and_deadlines.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You have to process n tasks. Each task has a duration and a deadline, and you will process the tasks in some order one after another. Your reward for a task is d−f where d is its deadline and f is your finishing time. (The starting time is 0, and you have to process all tasks even if a task would yield negative reward.)
 4 | 
 5 | What is your maximum reward if you act optimally?
 6 | 
 7 | Input
 8 | 
 9 | The first input line has an integer n: the number of tasks.
10 | 
11 | After this, there are n lines that describe the tasks. Each line has two integers a and d: the duration and deadline of the task.
12 | 
13 | Output
14 | 
15 | Print one integer: the maximum reward.
16 | 
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤a,d≤10^6
20 | Example
21 | 
22 | Input:
23 | 3
24 | 6 10
25 | 8 15
26 | 5 12
27 | 
28 | Output:
29 | 2
30 | */
31 | 
32 | #include<iostream>
33 | #include<vector>
34 | #include<utility>
35 | #include<algorithm>
36 | using namespace std;
37 | 
38 | int main(){
39 |     int n;
40 |     cin>>n;
41 |     vector<pair<int,int>> tasks(n);
42 |     for(int i=0;i<n;i++)
43 |         cin>>tasks[i].first>>tasks[i].second;
44 |     sort(tasks.begin(),tasks.end()); // Shortest job first
45 | 
46 |     long long ans = 0;  
47 |     long long finish = 0;
48 |     for(int i=0;i<n;i++){
49 |         finish += tasks[i].first;
50 |         ans += tasks[i].second - finish;
51 |     }
52 |     cout<<ans;
53 | 
54 | 
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Sorting and Searching/20_subarray_sums_1.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n positive integers, your task is to count the number of subarrays having sum x.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has two integers n and x: the size of the array and the target sum x.
 8 | 
 9 | The next line has n integers a1,a2,…,an: the contents of the array.
10 | 
11 | Output
12 | 
13 | Print one integer: the required number of subarrays.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤x,ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 5 7
22 | 2 4 1 2 7
23 | 
24 | Output:
25 | 3
26 | */
27 | 
28 | #include<iostream>
29 | 
30 | using namespace std;
31 | 
32 | int main(){
33 | 
34 |     int n,x;
35 |     cin>>n>>x;
36 | 
37 |     int* arr = new int[n];
38 |     for(int i=0;i<n;i++)
39 |         cin>>arr[i];
40 | 
41 |     int curr_sum = 0;
42 |     int left = 0;
43 |     int right = -1;
44 |     int count = 0;
45 |     while(left<n && right <n){
46 |         if(curr_sum < x){
47 |             right ++;
48 |             if(right < n)
49 |                 curr_sum += arr[right];
50 |           
51 |         }
52 |         else if(curr_sum > x){
53 |             curr_sum -= arr[left];
54 |             left ++;
55 |         }
56 |         else{
57 |             count ++;
58 |             right ++;
59 |             curr_sum -= arr[left];
60 |             if(right < n)
61 |                 curr_sum += arr[right];
62 |             left++;
63 |             
64 |         }
65 |     }
66 | 
67 | 
68 |     cout<<count;
69 | 
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/Introductory Problems/temp.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | 
 4 | using namespace std;
 5 | 
 6 | string s = "??????R??????U???????????R??????????????LD????D?";
 7 | int g[7][7];
 8 | 
 9 | int f(int y, int x, int i, char m) {
10 |   if (i == 48) return 1;
11 |   if (g[6][0]) return 0;
12 |   if (m == 'L' && (x == 0 || g[y][x-1]) && y > 0 && y < 6 && !g[y-1][x] && !g[y+1][x]) return 0;
13 |   if (m == 'R' && (x == 6 || g[y][x+1]) && y > 0 && y < 6 && !g[y-1][x] && !g[y+1][x]) return 0;
14 |   if (m == 'U' && (y == 0 || g[y-1][x]) && x > 0 && x < 6 && !g[y][x-1] && !g[y][x+1]) return 0;
15 |   if (m == 'D' && (y == 6 || g[y+1][x]) && x > 0 && x < 6 && !g[y][x-1] && !g[y][x+1]) return 0;
16 |   if (s[i] == '?') {
17 |     int r[] = {-1, 0, 1, 0};
18 |     int c[] = {0, -1, 0, 1};
19 |     int k = 0;
20 |     for (int j = 0; j < 4; j++) {
21 |       int yy = y + r[j];
22 |       int xx = x + c[j];
23 |       if (yy < 0 || yy > 6) continue;
24 |       if (xx < 0 || xx > 6) continue;
25 |       if (g[yy][xx]) continue;
26 |       g[yy][xx] = true;
27 |       k += f(yy, xx, i + 1, "ULDR"[j]);
28 |       g[yy][xx] = false;
29 |     }
30 |     return k;
31 |   }
32 |   if (s[i] == 'L') x--;
33 |   else if (s[i] == 'R') x++;
34 |   else if (s[i] == 'U') y--;
35 |   else if (s[i] == 'D') y++;
36 |   if (x < 0 || x > 6) return 0;
37 |   if (y < 0 || y > 6) return 0;
38 |   if (g[y][x]) return 0;
39 |   g[y][x] = true;
40 |   int k = f(y, x, i + 1, s[i]);
41 |   g[y][x] = false;
42 |   return k;
43 | }
44 | 
45 | 
46 | int main() {
47 |  
48 |   g[0][0] = true;
49 |   cout << f(0, 0, 0, 0) << endl;
50 | }


--------------------------------------------------------------------------------
/Sorting and Searching/24_sliding_median.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | You are given an array of n integers. Your task is to calculate the median of each window of k elements, from left to right.
 3 | 
 4 | The median is the middle element when the elements are sorted. If the number of elements is even, there are two possible medians and we assume that the median is the smaller of them.
 5 | 
 6 | Input
 7 | 
 8 | The first input line contains two integers n and k: the number of elements and the size of the window.
 9 | 
10 | Then there are n integers x1,x2,…,xn: the contents of the array.
11 | 
12 | Output
13 | 
14 | Print n−k+1 values: the medians.
15 | 
16 | Constraints
17 | 1≤k≤n≤2⋅10^5
18 | 1≤xi≤10^9
19 | Example
20 | 
21 | Input:
22 | 8 3
23 | 2 4 3 5 8 1 2 1
24 | 
25 | Output:
26 | 3 4 5 5 2 1
27 | */
28 | 
29 | #include<iostream>
30 | #include<vector>
31 | #include<algorithm>
32 | #include<utility>
33 | using namespace std;
34 | 
35 | 
36 | 
37 | int main(){
38 |     int n,k;
39 |     cin>>n>>k;
40 |     vector<pair<int,int>> arr(n);
41 |     for(int i=0;i<n;i++){
42 |         cin>>arr[i].first;
43 |         arr[i].second = i;
44 |     }
45 |     
46 | 
47 |     nth_element(arr.begin(),arr.begin()+(k-1)/2,arr.begin()+k);
48 |     cout<<arr[(k-1)/2].first<<" ";
49 | 
50 | 
51 |     for(int i=k;i<n;i++){
52 |         nth_element(arr.begin()+i-k+1,arr.begin()+i-k+1+(k-1)/2,arr.begin()+i+1);
53 |         pair<int,int> temp = arr[i-k+1+(k-1)/2];
54 |         cout<<temp.first<<" ";
55 |         arr[i-k+1+(k-1)/2] = arr[temp.second];
56 |         arr[temp.second] = temp;
57 |     
58 |     }
59 |     
60 | 
61 | 
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/Sorting and Searching/07_sum_of_two_values.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array of n integers, and your task is to find two values (at distinct positions) whose sum is x.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has two integers n and x: the array size and the target sum.
 8 | 
 9 | The second line has n integers a1,a2,…,an: the array values.
10 | 
11 | Output
12 | 
13 | Print two integers: the positions of the values. If there are several solutions, you may print any of them. If there are no solutions, print IMPOSSIBLE.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤x,ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 4 8
22 | 2 7 5 1
23 | 
24 | Output:
25 | 2 4
26 | */
27 | 
28 | #include<iostream>
29 | #include<algorithm>
30 | #include<vector>
31 | #include<utility>
32 | using namespace std;
33 | 
34 | int main(){
35 |     int n,x;
36 |     cin>>n>>x;
37 |     vector<pair<int,int>> arr(n);
38 |     for(int i=1;i<=n;i++){
39 |         cin>>arr[i-1].first;
40 |         arr[i-1].second = i;
41 |     }
42 |     sort(arr.begin(),arr.end());
43 | 
44 |     int start=0;
45 |     int end = n-1;
46 |     bool flag = true;
47 |     while(end>start){
48 |         if(arr[start].first + arr[end].first == x){
49 |             cout<<arr[start].second<<" "<<arr[end].second;
50 |             flag = false;
51 |             break;
52 |         }
53 |         else if(arr[start].first + arr[end].first > x){
54 |             end--;
55 |         }
56 |         else
57 |             start++;
58 |     }
59 | 
60 |     if(flag)
61 |         cout<<"IMPOSSIBLE";
62 |         
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/Sorting and Searching/06_movie_festival.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | In a movie festival n movies will be shown. You know the starting and ending time of each movie. What is the maximum number of movies you can watch entirely?
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the number of movies.
 8 | 
 9 | After this, there are n lines that describe the movies. Each line has two integers a and b: the starting and ending times of a movie.
10 | 
11 | Output
12 | 
13 | Print one integer: the maximum number of movies.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤a<b≤10^9
18 | Example
19 | 
20 | Input:
21 | 3
22 | 3 5
23 | 4 9
24 | 5 8
25 | 
26 | Output:
27 | 2
28 | */
29 | 
30 | #include<iostream>
31 | #include<vector>
32 | #include<algorithm>
33 | #include<utility>
34 | 
35 | using namespace std;
36 | 
37 | bool compf(pair<int,int> a ,pair<int,int> b){
38 |     if(a.second != b.second)
39 |         return a.second < b.second;
40 |     return a.first > b.first;
41 | }
42 | 
43 | int max_movies(vector<pair<int,int>>& timings,int& n){
44 |     sort(timings.begin(),timings.end(),compf);
45 | 
46 |     int count = 1;
47 |     int temp = timings[0].second;
48 |     for(int i=1;i<n;i++){
49 |         if(timings[i].first>= temp){
50 |             count ++ ;
51 |             temp = timings[i].second;
52 |         }
53 |     }
54 |     return count;
55 |     
56 | }
57 | 
58 | int main(){
59 |     int n;
60 |     cin>>n;
61 |     vector<pair<int,int>> timings(n);
62 |     for(int i=0;i<n;i++){
63 |         cin>>timings[i].first>>timings[i].second;
64 |     }
65 |     cout<<max_movies(timings,n);
66 | 
67 |     return 0;
68 | }


--------------------------------------------------------------------------------
/Dynamic Programming/15_projects.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n projects you can attend. For each project, you know its starting and ending days and the amount of money you would get as reward. You can only attend one project during a day.
 4 | 
 5 | What is the maximum amount of money you can earn?
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains an integer n: the number of projects.
10 | 
11 | After this, there are n lines. Each such line has three integers ai, bi, and pi: the starting day, the ending day, and the reward.
12 | 
13 | Output
14 | 
15 | Print one integer: the maximum amount of money you can earn.
16 | 
17 | Constraints
18 | 1≤n≤2⋅105
19 | 1≤ai≤bi≤10^9
20 | 1≤pi≤10^9
21 | Example
22 | 
23 | Input:
24 | 4
25 | 2 4 4
26 | 3 6 6
27 | 6 8 2
28 | 5 7 3
29 | 
30 | Output:
31 | 7
32 | */
33 | 
34 | #include<iostream>
35 | #include<vector>
36 | using namespace std;
37 | 
38 | struct triplet{
39 |     int start;
40 |     int end;
41 |     int reward;
42 | 
43 |     triplet(){
44 |         
45 |     }
46 |     triplet(int a,int b,int c){
47 |         start = a;
48 |         end = b;
49 |         reward = c;
50 |     }
51 |     void input(int a,int b,int c){
52 |         start = a;
53 |         end = b;
54 |         reward = c;
55 |     }
56 | 
57 | };
58 | 
59 | int main(){
60 |     int n;
61 |     cin>>n;
62 | 
63 |     /*vector<triplet> projects(n);
64 |     for(int i=0;i<n;i++)
65 |         cin>>projects[i].start>>projects[i].end>>projects[i].reward;*/
66 | 
67 |     triplet temp;
68 |     temp.input(1,2,3);
69 |     cout<<endl<<temp.start<<" "<<temp.end<<" "<<temp.reward;
70 |     
71 |     
72 | 
73 |     return 0;
74 | }


--------------------------------------------------------------------------------
/Dynamic Programming/10_rectangle_cutting.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an a×b rectangle, your task is to cut it into squares. On each move you can select a rectangle and cut it into two rectangles in such a way that all side lengths remain integers. What is the minimum possible number of moves?
 4 |  
 5 | Input
 6 |  
 7 | The only input line has two integers a and b.
 8 |  
 9 | Output
10 |  
11 | Print one integer: the minimum number of moves.
12 |  
13 | Constraints
14 | 1≤a,b≤500
15 | Example
16 |  
17 | Input:
18 | 3 5
19 |  
20 | Output:
21 | 3
22 | */
23 |  
24 | #include<iostream>
25 | #include<vector>
26 | #include<climits>
27 | using namespace std;
28 |  
29 | int main(){
30 |     int a,b;
31 |     cin>>a>>b;
32 |     if(a>b){
33 |         int temp = a;
34 |         a = b;
35 |         b = temp;
36 |     }
37 |     vector<vector<int>> dp(a+1,vector<int>(b+1,0));
38 |  
39 |     
40 |  
41 |     dp[1][1] = 0;
42 |  
43 |  
44 |     for(int i=2;i<=b;i++)
45 |         dp[1][i] = i-1;
46 |  
47 |     for(int i=2;i<=a;i++){
48 |         for(int j=i+1;j<=b;j++){
49 |             dp[i][j] = INT_MAX;
50 |             for(int k=1;k<i;k++)
51 |                 dp[i][j] =  min(dp[i][j] ,1+dp[min(k,j)][max(k,j)]+dp[i-k][j]);
52 |             for(int k=1;k<j;k++)
53 |                 dp[i][j] = min(dp[i][j] , 1+dp[min(i,k)][max(i,k)]+dp[min(i,j-k)][max(i,j-k)]);
54 |             
55 |         }
56 |     }
57 |     /*cout<<endl;
58 |     for(int i=1;i<=a;i++){
59 |         for(int j=1;j<=b;j++)
60 |             cout<<dp[i][j]<<" ";
61 |         cout<<endl;
62 |     }
63 |     cout<<endl;*/
64 |     
65 |     cout<<dp[a][b];
66 |  
67 |   
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/Dynamic Programming/13_two_sets_2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to count the number of ways numbers 1,2,…,n can be divided into two sets of equal sum.
 4 |  
 5 | For example, if n=7, there are four solutions:
 6 | {1,3,4,6} and {2,5,7}
 7 | {1,2,5,6} and {3,4,7}
 8 | {1,2,4,7} and {3,5,6}
 9 | {1,6,7} and {2,3,4,5}
10 | Input
11 |  
12 | The only input line contains an integer n.
13 |  
14 | Output
15 |  
16 | Print the answer modulo 10^9+7.
17 |  
18 | Constraints
19 | 1≤n≤500
20 | Example
21 |  
22 | Input:
23 | 7
24 |  
25 | Output:
26 | 4
27 | */
28 |  
29 | #include<iostream>
30 | #include<vector>
31 | using namespace std;
32 |  
33 | int number_of_ways(int i,int sum1,vector<vector<int>>& dp,int& n, int& s){
34 |  
35 |     if(sum1 == s)
36 |         return 1;   
37 |  
38 |     if(i > n || sum1 >s)
39 |         return 0;
40 |     
41 |  
42 |     if(dp[i][sum1]!= -1)
43 |         return dp[i][sum1];
44 |  
45 |    
46 |     dp[i][sum1] = number_of_ways(i+1,sum1+i,dp,n,s);
47 |  
48 |     dp[i][sum1] += number_of_ways(i+1,sum1,dp,n,s);
49 |     dp[i][sum1] %= 1000000007;
50 |    
51 |     return dp[i][sum1];
52 |  
53 | }
54 |  
55 | int main(){
56 |     int n;
57 |     cin>>n;
58 |     int s = (n*(n+1))/2;
59 |     if(s&1){
60 |         cout<<0;
61 |     }
62 |     else{
63 |         s /= 2;
64 |         vector<vector<int>> dp(n+1,vector<int>(s+1,-1));
65 |         long long temp = number_of_ways(1,0,dp,n,s);
66 |         long long inverse = 500000004;  // MMMI(Modular Multiplicative inverse) of 2 in 10^9+7 
67 |         long long answer = (temp * inverse) % 1000000007;
68 |         cout<<answer;
69 |     }
70 |     
71 |  
72 |     return 0;
73 | }


--------------------------------------------------------------------------------
/Introductory Problems/12_palindrome_reorder.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given a string, your task is to reorder its letters in such a way that it becomes a palindrome (i.e., it reads the same forwards and backwards).
 4 | 
 5 | Input
 6 | 
 7 | The only input line has a string of length n consisting of characters A–Z.
 8 | 
 9 | Output
10 | 
11 | Print a palindrome consisting of the characters of the original string. You may print any valid solution. If there are no solutions, print "NO SOLUTION".
12 | 
13 | Constraints
14 | 1≤n≤10^6
15 | Example
16 | 
17 | Input:
18 | AAAACACBA
19 | 
20 | Output:
21 | AACABACAA
22 | */
23 | 
24 | #include<iostream>
25 | #include<string>
26 | using namespace std;
27 | 
28 | string find_palindrome(int* freq){
29 |     string ans;
30 |     char middle_element;
31 |     bool flag = true;
32 |     for(int i=0;i<26;i++){
33 |         if ((freq[i]&1) && flag){
34 |             middle_element = i + 'A';
35 |             flag = false;
36 |             freq[i]--;
37 |         }
38 |         else if (freq[i]&1)
39 |             return "NO SOLUTION";
40 | 
41 |         while(freq[i]>0){
42 |             ans.push_back(i+'A');
43 |             freq[i] -= 2;
44 |         }
45 |         
46 |     }
47 |     string final_ans = ans;
48 |     if(!flag)
49 |         final_ans.push_back(middle_element);
50 |     for(int i=ans.size()-1;i>=0;i--)
51 |         final_ans.push_back(ans[i]);
52 |     return final_ans;
53 | }
54 | 
55 | int main(){
56 | 
57 |     string str;
58 |     getline(cin,str);
59 |     int* arr = new int[26]{0};
60 |     for(int i=0;i<str.size();i++){
61 |         arr[str[i]-'A']++;
62 |     }
63 |     cout<<find_palindrome(arr);
64 | 
65 | }


--------------------------------------------------------------------------------
/String Algorithms/02_string_matching.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given a string and a pattern, your task is to count the number of positions where the pattern occurs in the string.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has a string of length n, and the second input line has a pattern of length m. Both of them consist of characters a–z.
 8 | 
 9 | Output
10 | 
11 | Print one integer: the number of occurrences.
12 | 
13 | Constraints
14 | 1≤n,m≤10^6
15 | Example
16 | 
17 | Input:
18 | saippuakauppias
19 | pp
20 | 
21 | Output:
22 | 2
23 | */
24 | 
25 | #include<iostream>
26 | #include<string>
27 | using namespace std;
28 | 
29 | int main(){
30 |     string str,pattern;
31 |     cin>>str>>pattern;
32 | 
33 |     int n = str.size();
34 |     int m = pattern.size();
35 |     
36 | 
37 |     int* lps = new int[m]{-1};
38 |     int j = 0;
39 |     for(int i=1;i<m;i++){
40 |         if(pattern[i] == pattern[j]){
41 |             lps[i] = j;
42 |             j++;
43 |         }
44 |         else{
45 |             lps[i] = -1;
46 |             j = 0;
47 |         }
48 |     }
49 | 
50 |     int i = 0;
51 |     j = 0;
52 |     int count = 0;
53 |     while(i < n){
54 |         if(j < m && str[i] == pattern[j]){
55 |             i++;
56 |             j++;
57 |         }
58 |         else{
59 |             if(j == m)
60 |                 count ++;
61 |             if(j > 0 ){
62 |                 int temp = j;
63 |                 j = lps[j-1] + 1;
64 |                 if(temp != j)
65 |                     i--;
66 |             }
67 |             i++;
68 |         }
69 |     }
70 | 
71 |     if(j == m)
72 |         count ++;
73 | 
74 |     cout<<count;
75 | 
76 |     return 0;
77 | }


--------------------------------------------------------------------------------
/Introductory Problems/14_apple_division.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n apples with known weights. Your task is to divide the apples into two groups so that the difference between the weights of the groups is minimal.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has an integer n: the number of apples.
 8 | 
 9 | The next line has n integers p1,p2,…,pn: the weight of each apple.
10 | 
11 | Output
12 | 
13 | Print one integer: the minimum difference between the weights of the groups.
14 | 
15 | Constraints
16 | 1≤n≤20
17 | 1≤pi≤109
18 | Example
19 | 
20 | Input:
21 | 5
22 | 3 2 7 4 1
23 | 
24 | Output:
25 | 1
26 | 
27 | Explanation: Group 1 has weights 2, 3 and 4 (total weight 9), and group 2 has weights 1 and 7 (total weight 8).
28 | */
29 | 
30 | #include<iostream>
31 | #include<cmath>
32 | using namespace std;
33 | 
34 | long long min_difference(int* arr,int size,long long sum){
35 |     int limit = pow(2,size);
36 |     long long ans = sum;
37 |     for(int i=1;i<limit-1;i++){
38 |         int temp = i;
39 |         long long sum1 = 0;
40 |         long long sum2 = 0;
41 |         for(int j=size-1;j>=0;j--){
42 |             int t = temp&1;
43 |             if(t == 1){
44 |                 sum1 += arr[j];
45 |             }
46 |             else{
47 |                 sum2 += arr[j];
48 |             }
49 |             temp /= 2;
50 |         }
51 |         ans = min(ans,abs(sum1-sum2));
52 |     }
53 |     return ans;
54 | }
55 | 
56 | int main(){
57 |     int n;
58 |     cin>>n;
59 |     int* arr = new int[n];
60 |     long long sum = 0;
61 |     for(int i=0;i<n;i++){
62 |         cin>>arr[i];
63 |         sum += arr[i];
64 |     }
65 |     cout<<min_difference(arr,n,sum);
66 | 
67 | 
68 | }


--------------------------------------------------------------------------------
/Sorting and Searching/03_ferris_wheel.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n children who want to go to a Ferris wheel, and your task is to find a gondola for each child.
 4 | 
 5 | Each gondola may have one or two children in it, and in addition, the total weight in a gondola may not exceed x. You know the weight of every child.
 6 | 
 7 | What is the minimum number of gondolas needed for the children?
 8 | 
 9 | Input
10 | 
11 | The first input line contains two integers n and x: the number of children and the maximum allowed weight.
12 | 
13 | The next line contains n integers p1,p2,…,pn: the weight of each child.
14 | 
15 | Output
16 | 
17 | Print one integer: the minimum number of gondolas.
18 | 
19 | Constraints
20 | 1≤n≤2⋅10^5
21 | 1≤x≤10^9
22 | 1≤pi≤x
23 | Example
24 | 
25 | Input:
26 | 4 10
27 | 7 2 3 9
28 | 
29 | Output:
30 | 3
31 | */
32 | 
33 | #include<iostream>
34 | #include<algorithm>
35 | using namespace std;
36 | 
37 | int min_gondolas_required(int* childWts,int& n,int& x){
38 |     sort(childWts,childWts+n);
39 |     int count = 0;
40 |     int start = 0;
41 |     int end = n - 1;
42 |     while(end>start){
43 |         if(childWts[end]<=x){
44 |             if(childWts[end]+childWts[start]<=x){
45 |                 start++;
46 |             }
47 |             end--;
48 |             count++;
49 |         }
50 |         else{
51 |             end--;
52 |         }
53 |     }
54 |     if(end == start)
55 |         count++;
56 |     return count;
57 | }
58 | 
59 | int main(){
60 |     int n,x;
61 |     cin>>n>>x;
62 |     int* childWeights = new int[n];
63 |     for(int i=0;i<n;i++)
64 |         cin>>childWeights[i];
65 |     cout<<min_gondolas_required(childWeights,n,x);
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/Dynamic Programming/07_book_shop.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are in a book shop which sells n different books. You know the price and number of pages of each book.
 4 | 
 5 | You have decided that the total price of your purchases will be at most x. What is the maximum number of pages you can buy? You can buy each book at most once.
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains two integers n and x: the number of books and the maximum total price.
10 | 
11 | The next line contains n integers h1,h2,…,hn: the price of each book.
12 | 
13 | The last line contains n integers s1,s2,…,sn: the number of pages of each book.
14 | 
15 | Output
16 | 
17 | Print one integer: the maximum number of pages.
18 | 
19 | Constraints
20 | 1≤n≤1000
21 | 1≤x≤10^5
22 | 1≤hi,si≤1000
23 | Example
24 | 
25 | Input:
26 | 4 10
27 | 4 8 5 3
28 | 5 12 8 1
29 | 
30 | Output:
31 | 13
32 | 
33 | Explanation: You can buy books 1 and 3. Their price is 4+5=9 and the number of pages is 5+8=13.
34 | */ 
35 | 
36 | #include<iostream>
37 | using namespace std;
38 | 
39 | int main(){
40 | 
41 |     int n,x;
42 |     cin>>n>>x;
43 |     int* price = new int[n];
44 |     int* pages = new int[n];
45 | 
46 |     for(int i=0;i<n;i++)
47 |         cin>>price[i];
48 | 
49 |     for(int i=0;i<n;i++)
50 |         cin>>pages[i];
51 |     
52 |     int dp[n+1][x+1];
53 | 
54 |     for(int i=0;i<=n;i++){
55 |         for(int j=0;j<=x;j++){
56 |             if(j == 0 || i == 0)
57 |                 dp[i][j] = 0;
58 |             else if(price[i-1] <= j)
59 |                 dp[i][j] = max(pages[i-1]+dp[i-1][j-price[i-1]],dp[i-1][j]);
60 |             
61 |             else
62 |                 dp[i][j] = dp[i-1][j];
63 |         }
64 |     }
65 | 
66 |     cout<<dp[n][x];
67 |     
68 | 
69 | 
70 | }


--------------------------------------------------------------------------------
/Introductory Problems/11_coin_piles.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You have two coin piles containing a and b coins. On each move, you can either remove one coin from the left pile and two coins from the right pile, or two coins from the left pile and one coin from the right pile.
 4 | 
 5 | Your task is to efficiently find out if you can empty both the piles.
 6 | 
 7 | Input
 8 | 
 9 | The first input line has an integer t: the number of tests.
10 | 
11 | After this, there are t lines, each of which has two integers a and b: the numbers of coins in the piles.
12 | 
13 | Output
14 | 
15 | For each test, print "YES" if you can empty the piles and "NO" otherwise.
16 | 
17 | Constraints
18 | 1≤t≤10^5
19 | 0≤a,b≤10^9
20 | Example
21 | 
22 | Input:
23 | 3
24 | 2 1
25 | 2 2
26 | 3 3
27 | 
28 | Output:
29 | YES
30 | NO
31 | YES
32 | 
33 | */
34 | 
35 | #include<iostream>
36 | using namespace std;
37 | 
38 | int main(){
39 | 
40 |     int t;
41 |     cin>>t;
42 |     while(t--){
43 |         int a,b;
44 |         cin>>a>>b;
45 |         /*
46 |             x is the total number of moves--> 2 from A and 1 from B.
47 |             y is the total number of moves--> 2 from B and 1 from A.
48 |             Therefore,
49 |             a = 2x + y
50 |             b = x + 2y
51 |             On solving for x and y,
52 |             x = (2a - b)/3;
53 |             y = (2b - a)/3;
54 |             if x and y comes out to be integer then answer is YES
55 |             otherwise no;
56 |         */
57 | 
58 |         if((2*a-b)>=0 && (2*a-b)%3==0 && (2*b-a)>=0 && (2*b-a)%3==0)
59 |             cout<<"YES"<<endl;
60 |         else
61 |             cout<<"NO"<<endl;
62 | 
63 |     }
64 | 
65 | 
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/Sorting and Searching/10_playlist.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given a playlist of a radio station since its establishment. The playlist has a total of n songs.
 4 | 
 5 | What is the longest sequence of successive songs where each song is unique?
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains an integer n: the number of songs.
10 | 
11 | The next line has n integers k1,k2,…,kn: the id number of each song.
12 | 
13 | Output
14 | 
15 | Print the length of the longest sequence of unique songs.
16 | 
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤ki≤10^9
20 | Example
21 | 
22 | Input:
23 | 8
24 | 1 2 1 3 2 7 4 2
25 | 
26 | Output:
27 | 5
28 | */
29 | 
30 | #include<iostream>
31 | #include<algorithm>
32 | #include<set>
33 | #include<iterator>
34 | using namespace std;
35 | 
36 | int freq_of_num(int& element,multiset<int>& set_sorted){
37 |     auto itLow = set_sorted.lower_bound(element);
38 |     if(itLow == set_sorted.end())
39 |         return 0;
40 |     auto itHigh = set_sorted.upper_bound(element);
41 |     return distance(itLow,itHigh);
42 | 
43 | }
44 | 
45 | int main(){
46 |     int n;
47 |     cin>>n;
48 |     int* arr = new int[n];
49 |     multiset<int> set_sorted;
50 |   
51 |     for(int i=0;i<n;i++)
52 |         cin>>arr[i];
53 |     
54 | 
55 |     int left = 0;
56 |     int right = 0;
57 |     int ans = 1;
58 |     while(left<n && right<n){
59 | 
60 |         if(freq_of_num(arr[right],set_sorted) == 0){
61 |             set_sorted.insert(arr[right]);
62 |             right++;        
63 |         }
64 |         else{
65 |             ans = max(right-left,ans);
66 |             set_sorted.erase(arr[left]);
67 |             left++;
68 |         }
69 |     }
70 |     ans = max(right-left,ans);
71 |     cout<<ans;
72 | 
73 | 
74 | 
75 |     return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/Sorting and Searching/04_concert_tickets.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n concert tickets available, each with a certain price. Then, m customers arrive, one after another.
 4 | 
 5 | Each customer announces the maximum price he or she is willing to pay for a ticket, and after this, they will get a ticket with the nearest possible price such that it does not exceed the maximum price.
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains integers n and m: the number of tickets and the number of customers.
10 | 
11 | The next line contains n integers h1,h2,…,hn: the price of each ticket.
12 | 
13 | The last line contains m integers t1,t2,…,tm: the maximum price for each customer.
14 | 
15 | Output
16 | 
17 | Print, for each customer, the price that they will pay for their ticket. After this, the ticket cannot be purchased again.
18 | 
19 | If a customer cannot get any ticket, print −1.
20 | 
21 | Constraints
22 | 1≤n,m≤2⋅10^5
23 | 1≤hi,ti≤10^9
24 | Example
25 | 
26 | Input:
27 | 5 3
28 | 5 3 7 8 5
29 | 4 8 3
30 | 
31 | Output:
32 | 3
33 | 8
34 | -1
35 | */
36 | 
37 | #include<iostream>
38 | #include<set>
39 | using namespace std;
40 | 
41 | int main(){
42 |     int n,m;
43 |     cin>>n>>m;
44 |     multiset<int> tktPrice;
45 |     int* maxPrice = new int[m];
46 | 
47 |     for(int i=0;i<n;i++){
48 |         int temp;
49 |         cin>>temp;
50 |         tktPrice.insert(temp);
51 |     }
52 |     for(int i=0;i<m;i++)
53 |         cin>>maxPrice[i];
54 |     
55 | 
56 |     for(int i=0;i<m;i++){
57 |         auto it = tktPrice.upper_bound(maxPrice[i]);
58 |         if(it == tktPrice.begin())
59 |             cout<<"-1"<<endl;
60 |         else{
61 |             it--;
62 |             cout<<(*it)<<endl;
63 |             tktPrice.erase(it);
64 |         }
65 |     }
66 |     
67 |     
68 | }


--------------------------------------------------------------------------------
/Dynamic Programming/12_removal_game.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There is a list of n numbers and two players who move alternately. On each move, a player removes either the first or last number from the list, and their score increases by that number. Both players try to maximize their scores.
 4 | 
 5 | What is the maximum possible score for the first player when both players play optimally?
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains an integer n: the size of the list.
10 | 
11 | The next line has n integers x1,x2,…,xn: the contents of the list.
12 | 
13 | Output
14 | 
15 | Print the maximum possible score for the first player.
16 | 
17 | Constraints
18 | 1≤n≤5000
19 | −10^9≤xi≤10^9
20 | Example
21 | 
22 | Input:
23 | 4
24 | 4 5 1 3
25 | 
26 | Output:
27 | 8
28 | */
29 | 
30 | #include<iostream>
31 | using namespace std;
32 | 
33 | int main(){
34 |     int n;
35 |     cin>>n;
36 |     long long* arr = new long long[n];
37 |     for(int i=0;i<n;i++)
38 |         cin>>arr[i];
39 |     
40 |     long long dp[n][n];
41 |     for(int i=0;i<n;i++)
42 |         dp[i][i] = arr[i];
43 |     
44 |     for(int i=0;i<n-1;i++)
45 |         dp[i][i+1] = max(arr[i],arr[i+1]);
46 | 
47 |     for(int i=2;i<n;i++){
48 |         for(int j=0;j<n-i;j++){
49 |             long long x = min(arr[j]+dp[j+2][j+i],arr[j]+dp[j+1][j+i-1]);
50 |             long long y = min(dp[j][j+i-2]+arr[j+i],dp[j+1][j+i-1]+arr[j+i]);
51 |             dp[j][j+i] = max(x,y);
52 |         }
53 |     }
54 |     //cout<<endl;
55 |     cout<<dp[0][n-1];
56 |     //cout<<endl<<endl;
57 | 
58 |     /*for(int i=0;i<n;i++){
59 |         for(int j=0;j<n;j++)
60 |         if(j<i){
61 |             cout<<"\t";
62 |         }
63 |         else{
64 |             cout<<dp[i][j]<<"\t";
65 |         }
66 |         cout<<endl;
67 |     }*/
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/Dynamic Programming/03_coin_combinations_1.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Consider a money system consisting of n coins. Each coin has a positive integer value. Your task is to calculate the number of distinct ways you can produce a money sum x using the available coins.
 4 | 
 5 | For example, if the coins are {2,3,5} and the desired sum is 9, there are 8 ways:
 6 | 2+2+5
 7 | 2+5+2
 8 | 5+2+2
 9 | 3+3+3
10 | 2+2+2+3
11 | 2+2+3+2
12 | 2+3+2+2
13 | 3+2+2+2
14 | Input
15 | 
16 | The first input line has two integers n and x: the number of coins and the desired sum of money.
17 | 
18 | The second line has n distinct integers c1,c2,…,cn: the value of each coin.
19 | 
20 | Output
21 | 
22 | Print one integer: the number of ways modulo 109+7.
23 | 
24 | Constraints
25 | 1≤n≤100
26 | 1≤x≤10^6
27 | 1≤ci≤10^6
28 | Example
29 | 
30 | Input:
31 | 3 9
32 | 2 3 5
33 | 
34 | Output:
35 | 8
36 | */
37 | 
38 | #include<iostream>
39 | #include<algorithm>
40 | using namespace std;
41 | 
42 | long long number_of_ways(int sum,int* coins,int& n,long long* dp,bool* isVisited){
43 | 
44 |     if(isVisited[sum])
45 |         return dp[sum];
46 |     
47 |     dp[sum] = 0;
48 |     for(int i=0;i<n;i++){
49 |         if(sum-coins[i] < 0)
50 |             break;
51 |         dp[sum] += number_of_ways(sum-coins[i],coins,n,dp,isVisited);
52 |         dp[sum] %= 1000000007;
53 |     }
54 |     isVisited[sum] = true;
55 |     return dp[sum];
56 | 
57 | }
58 | 
59 | 
60 | int main(){
61 |     int n,x;
62 |     cin>>n>>x;
63 |     int* coins = new int[n];
64 |     for(int i=0;i<n;i++)
65 |         cin>>coins[i];
66 | 
67 |     sort(coins,coins+n);
68 | 
69 |     long long* dp = new long long[x+1];
70 |     bool* isVisited = new bool[x+1]{false};
71 | 
72 |     dp[0] = 1;
73 |     isVisited[0] = true;
74 |     cout<<number_of_ways(x,coins,n,dp,isVisited);
75 | 
76 | 
77 |     return 0;
78 | }


--------------------------------------------------------------------------------
/Dynamic Programming/09_edit_distance.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | The edit distance between two strings is the minimum number of operations required to transform one string into the other.
 4 | 
 5 | The allowed operations are:
 6 | Add one character to the string.
 7 | Remove one character from the string.
 8 | Replace one character in the string.
 9 | For example, the edit distance between LOVE and MOVIE is 2, because you can first replace L with M, and then add I.
10 | 
11 | Your task is to calculate the edit distance between two strings.
12 | 
13 | Input
14 | 
15 | The first input line has a string that contains n characters between A–Z.
16 | 
17 | The second input line has a string that contains m characters between A–Z.
18 | 
19 | Output
20 | 
21 | Print one integer: the edit distance between the strings.
22 | 
23 | Constraints
24 | 1≤n,m≤5000
25 | Example
26 | 
27 | Input:
28 | LOVE
29 | MOVIE
30 | 
31 | Output:
32 | 2
33 | */
34 | 
35 | #include<iostream>
36 | #include<string>
37 | #include<vector>
38 | using namespace std;
39 | 
40 | int main(){
41 |     string str1,str2;
42 |     getline(cin,str1);
43 |     getline(cin,str2);
44 | 
45 |     int size1=str1.size();
46 |     int size2=str2.size();
47 | 
48 |     vector<vector<int>> dp(size1+1,vector<int>(size2+1,0));
49 | 
50 | 
51 |     for(int i=size1-1;i>=0;i--){
52 |         dp[i][size2] = size1 -i;
53 |     }
54 |     for(int i=size2-1;i>=0;i--){
55 |         dp[size1][i] = size2 - i;
56 |     }
57 | 
58 |     for(int i=size1-1;i>=0;i--){
59 |         for(int j=size2-1;j>=0;j--){
60 |             if(str1[i] == str2[j]){
61 |                 dp[i][j] = dp[i+1][j+1];
62 |             }
63 |             else{
64 |                 dp[i][j] = 1 + min(dp[i][j+1],dp[i+1][j]);
65 |                 dp[i][j] = min(dp[i][j],1+dp[i+1][j+1]);
66 |             }
67 |         }
68 |     }
69 |     cout<<dp[0][0];
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/Sorting and Searching/12_traffic_lights.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There is a street of length x whose positions are numbered 0,1,…,x. Initially there are no traffic lights, but n sets of traffic lights are added to the street one after another.
 4 | 
 5 | Your task is to calculate the length of the longest passage without traffic lights after each addition.
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains two integers x and n: the length of the street and the number of sets of traffic lights.
10 | 
11 | Then, the next line contains n integers p1,p2,…,pn: the position of each set of traffic lights. Each position is distinct.
12 | 
13 | Output
14 | 
15 | Print the length of the longest passage without traffic lights after each addition.
16 | 
17 | Constraints
18 | 1≤x≤10^9
19 | 1≤n≤2⋅10^5
20 | 0<pi<x
21 | Example
22 | 
23 | Input:
24 | 8 3
25 | 3 6 2
26 | 
27 | Output:
28 | 5 3 3
29 | */
30 | 
31 | #include<iostream>
32 | #include<set>
33 | #include<climits>
34 | using namespace std;
35 | 
36 | int main(){
37 |     int x,n;
38 |     cin>>x>>n;
39 |     set<int> lights;
40 |     lights.insert(0);
41 |     lights.insert(x);
42 | 
43 |     multiset<int> maxDistances;
44 |     maxDistances.insert(x);
45 | 
46 | 
47 |     for(int i=0;i<n;i++){
48 |         int pos;
49 |         cin>>pos;
50 |         lights.insert(pos);
51 |         
52 |         auto it1 = lights.upper_bound(pos);
53 |         auto it2 = it1;
54 |         it2--;
55 |         auto currentLightPos = it2;
56 |         it2--;
57 |         int temp = (*it1)-(*it2);
58 |         auto distIterator = maxDistances.lower_bound(temp);
59 |         maxDistances.erase(distIterator);
60 |         maxDistances.insert((*currentLightPos)-(*it2));
61 |         maxDistances.insert((*it1)-(*currentLightPos));
62 |         cout<<(*maxDistances.rbegin())<<" ";     
63 |         
64 |     }
65 |     
66 | 
67 | 
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/Sorting and Searching/17_sum_of_three_values.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array of n integers, and your task is to find three values (at distinct positions) whose sum is x.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has two integers n and x: the array size and the target sum.
 8 | 
 9 | The second line has n integers a1,a2,…,an: the array values.
10 | 
11 | Output
12 | 
13 | Print three integers: the positions of the values. If there are several solutions, you may print any of them. If there are no solutions, print IMPOSSIBLE.
14 | 
15 | Constraints
16 | 1≤n≤5000
17 | 1≤x,ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 4 8
22 | 2 7 5 1
23 | 
24 | Output:
25 | 1 3 4
26 | */
27 | 
28 | #include<iostream>
29 | #include<algorithm>
30 | #include<vector>
31 | #include<utility>
32 | using namespace std;
33 | 
34 | void find_ans(vector<pair<int,int>>& arr,int& n,int& x){
35 |     for(int i=n-1;i>=0;i--){
36 |         int required_sum = x - arr[i].first;
37 |         if(required_sum>0){
38 |             int start = 0;
39 |             int end = i-1;
40 |             while(start<end){
41 |                 if(arr[start].first + arr[end].first == required_sum){
42 |                     cout<<arr[start].second<<" "<<arr[end].second<<" "<<arr[i].second;
43 |                     return;
44 |                 }
45 |                 else if(arr[start].first + arr[end].first > required_sum)
46 |                     end--;
47 |                 else
48 |                     start++;
49 |                 
50 |             }
51 |         }
52 |     }
53 |     cout<<"IMPOSSIBLE";
54 | }
55 | 
56 | int main(){
57 |     int n,x;
58 |     cin>>n>>x;
59 |     vector<pair<int,int>> arr(n);
60 | 
61 |     for(int i=0;i<n;i++){
62 |         cin>>arr[i].first;
63 |         arr[i].second = i+1;
64 |     }
65 |     sort(arr.begin(),arr.end());
66 | 
67 |     find_ans(arr,n,x);
68 | 
69 |     return 0;
70 | }


--------------------------------------------------------------------------------
/Sorting and Searching/27_maximum_subarray_sum_2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Given an array of n integers, your task is to find the maximum sum of values in a contiguous subarray with length between a and b.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has three integers n, a and b: the size of the array and the minimum and maximum subarray length.
 8 | 
 9 | The second line has n integers x1,x2,…,xn: the array values.
10 | 
11 | Output
12 | 
13 | Print one integer: the maximum subarray sum.
14 | 
15 | Constraints
16 | 1≤n≤2⋅10^5
17 | 1≤a≤b≤n
18 | −10^9≤xi≤10^9
19 | Example
20 | 
21 | Input:
22 | 8 1 2
23 | -1 3 -2 5 3 -5 2 2
24 | 
25 | Output:
26 | 8
27 | */
28 | 
29 | #include<iostream>
30 | using namespace std;
31 | 
32 | int main(){
33 |     int n,a,b;
34 |     cin>>n>>a>>b;
35 |     int* arr = new int[n];
36 |     for(int i=0;i<n;i++)
37 |         cin>>arr[i];
38 |     
39 |     int start = 0;
40 |     long long local_sum = 0;
41 |     long long max_sum = 0;
42 |     for(int i=0;i<n;i++){
43 |         int length = i-start+1;
44 |         if(length < a){
45 |             local_sum += arr[i];
46 |         }
47 |         else if(length > b){
48 |             local_sum += arr[i];
49 |             local_sum -= arr[start];
50 |             start ++;
51 |             if(length>=a && length <=b)
52 |                     max_sum = max(max_sum,local_sum);
53 |         }
54 |         else{
55 |             if(arr[i]+local_sum >= arr[i]){
56 |                 local_sum += arr[i];
57 |                 max_sum = max(max_sum,local_sum);
58 |             }
59 |             else{
60 |                 local_sum = arr[i];
61 |                 start = i;
62 |                 length = i-start+1;
63 |                 if(length>=a && length <=b)
64 |                     max_sum = max(max_sum,local_sum);
65 |             }
66 |         }
67 |  
68 |         
69 |     }
70 |     cout<<max_sum;
71 |     return 0;
72 | }


--------------------------------------------------------------------------------
/Dynamic Programming/06_grid_paths.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Consider an n×n grid whose squares may have traps. It is not allowed to move to a square with a trap.
 4 | 
 5 | Your task is to calculate the number of paths from the upper-left square to the lower-right square where you only can move right or down.
 6 | 
 7 | Input
 8 | 
 9 | The first input line has an integer n: the size of the grid.
10 | 
11 | After this, there are n lines that describe the grid. Each line has n characters: . denotes an empty cell, and * denotes a trap.
12 | 
13 | Output
14 | 
15 | Print the number of paths modulo 109+7.
16 | 
17 | Constraints
18 | 1≤n≤1000
19 | Example
20 | 
21 | Input:
22 | 4
23 | ....
24 | .*..
25 | ...*
26 | *...
27 | 
28 | Output:
29 | 3
30 | */
31 | 
32 | #include<iostream>
33 | #include<vector>
34 | using namespace std;
35 | 
36 | int main(){
37 |     int n;
38 |     cin>>n;
39 |     vector<vector<char>> grid(n,vector<char>(n));
40 |     vector<vector<long long>> dp(n,vector<long long>(n,0));
41 | 
42 |     for(int i=0;i<n;i++){
43 |         for(int j=0;j<n;j++)
44 |             cin>>grid[i][j];
45 |     }
46 | 
47 |     if(grid[n-1][n-1] == '*'){
48 |         cout<<"0";
49 |         return 0;
50 |     }
51 | 
52 |     dp[n-1][n-1] = 1;
53 |     for(int i=n-2;i>=0;i--){
54 |         if(grid[n-1][i] != '*')
55 |             dp[n-1][i] = dp[n-1][i+1];
56 |     }
57 | 
58 | 
59 |     for(int i=n-2;i>=0;i--){
60 |         if(grid[i][n-1] != '*')
61 |             dp[i][n-1] = dp[i+1][n-1];  
62 |     }
63 |  
64 |     for(int i=n-2;i>=0;i--){
65 |         for(int j=n-2;j>=0;j--){
66 |             if(grid[i][j] != '*')
67 |                 dp[i][j] = (dp[i][j+1] + dp[i+1][j]) % 1000000007;
68 |         }
69 |     }
70 | 
71 |     /*cout<<endl;
72 |     for(int i=0;i<n;i++){
73 |         for(int j=0;j<n;j++){
74 |             cout<<dp[i][j]<<" ";
75 |         }
76 |         cout<<endl;
77 |     }*/
78 | 
79 |     cout<<dp[0][0];
80 | 
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/Introductory Problems/08_two_sets.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Your task is to divide the numbers 1,2,…,n into two sets of equal sum.
 4 | 
 5 | Input
 6 | 
 7 | The only input line contains an integer n.
 8 | 
 9 | Output
10 | 
11 | Print "YES", if the division is possible, and "NO" otherwise.
12 | 
13 | After this, if the division is possible, print an example of how to create the sets. First, print the number of elements in the first set followed by the elements themselves in a separate line, and then, print the second set in a similar way.
14 | 
15 | Constraints
16 | 1≤n≤10^6
17 | Example 1
18 | 
19 | Input:
20 | 7
21 | 
22 | Output:
23 | YES
24 | 4
25 | 1 2 4 7
26 | 3
27 | 3 5 6
28 | 
29 | Example 2
30 | 
31 | Input:
32 | 6
33 | 
34 | Output:
35 | NO
36 | 
37 | */
38 | 
39 | #include<iostream>
40 | #include<vector>
41 | using namespace std;
42 | 
43 | int main(){
44 |     int n;
45 |     cin>>n;
46 |     long long sum=n;
47 |     sum*=sum+1;
48 |     sum/=2;
49 |     if(sum&1)   //odd
50 |         cout<<"NO";
51 |     else{
52 |         sum/=2;
53 | 
54 |         cout<<"YES\n";
55 |         vector<vector<int>> nums(2,vector<int>(n+1,1));
56 |         for(int i=1;i<=n;i++){
57 |             nums[0][i]=i;
58 |           
59 |         }
60 |         int i=n;
61 |         int size=0;
62 |         while(sum>0){
63 |             if(i<=sum){
64 |                 nums[1][i]=0;
65 |                 sum-=i;
66 |                 i--;
67 |             }
68 |             else{
69 |                 nums[1][sum]=0;
70 |                 sum=0;
71 |             }
72 |             size++;
73 |         }
74 |       
75 |         cout<<size<<endl;
76 |         for(int i=1;i<=n;i++){
77 |             if(nums[1][i]==0)
78 |                 cout<<i<<" ";
79 |         }
80 |         cout<<endl<<n-size<<endl;
81 |         for(int i=1;i<=n;i++){
82 |             if(nums[1][i]==1)
83 |                 cout<<i<<" ";
84 |         }
85 | 
86 |     }
87 | 
88 | 
89 |     return 0;
90 | }


--------------------------------------------------------------------------------
/Dynamic Programming/02_minimizing_coins.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | Consider a money system consisting of n coins. Each coin has a positive integer value. Your task is to produce a sum of money x using the available coins in such a way that the number of coins is minimal.
 4 | 
 5 | For example, if the coins are {1,5,7} and the desired sum is 11, an optimal solution is 5+5+1 which requires 3 coins.
 6 | 
 7 | Input
 8 | 
 9 | The first input line has two integers n and x: the number of coins and the desired sum of money.
10 | 
11 | The second line has n distinct integers c1,c2,…,cn: the value of each coin.
12 | 
13 | Output
14 | 
15 | Print one integer: the minimum number of coins. If it is not possible to produce the desired sum, print −1.
16 | 
17 | Constraints
18 | 1≤n≤100
19 | 1≤x≤10^6
20 | 1≤ci≤10^6
21 | Example
22 | 
23 | Input:
24 | 3 11
25 | 1 5 7
26 | 
27 | Output:
28 | 3
29 | */
30 | 
31 | #include<iostream>
32 | #include<vector>
33 | #include<algorithm>
34 | #include<climits>
35 | using namespace std;
36 | 
37 | int minimum_coins(int sum,int* coins,int* dp,vector<bool>& isVisited,int& n){
38 |     
39 | 
40 |     if(isVisited[sum])
41 |         return dp[sum];
42 |     
43 |     dp[sum] = INT_MAX;
44 |     bool flag = true;
45 |     for(int i=0;i<n;i++){
46 |         if(sum-coins[i] < 0){
47 |             break;
48 |         }
49 |         int temp = minimum_coins(sum-coins[i],coins,dp,isVisited,n);
50 |         if(temp != -1){
51 |             dp[sum] = min(dp[sum],1+temp);
52 |             flag = false;
53 |         }
54 |     }
55 |     isVisited[sum] = true;
56 |     if(flag)
57 |         dp[sum] = -1;
58 |     return dp[sum];
59 | }
60 | 
61 | int main(){
62 |     int n,x;
63 |     cin>>n>>x;
64 |     int* coins = new int[n];
65 |     for(int i=0;i<n;i++){
66 |         cin>>coins[i];
67 |     }
68 |     sort(coins,coins+n);;
69 |     int* dp = new int[x+1];
70 |     dp[0] = 0;
71 |     vector<bool> isVisited(x+1,false);
72 |     isVisited[0] = true;
73 |     cout<<minimum_coins(x,coins,dp,isVisited,n);
74 | 
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/Sorting and Searching/05_restaurant_customers.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given the arrival and leaving times of n customers in a restaurant.
 4 | 
 5 | What was the maximum number of customers?
 6 | 
 7 | Input
 8 | 
 9 | The first input line has an integer n: the number of customers.
10 | 
11 | After this, there are n lines that describe the customers. Each line has two integers a and b: the arrival and leaving times of a customer.
12 | 
13 | You may assume that all arrival and leaving times are distinct.
14 | 
15 | Output
16 | 
17 | Print one integer: the maximum number of customers.
18 | 
19 | Constraints
20 | 1≤n≤2⋅10^5
21 | 1≤a<b≤10^9
22 | Example
23 | 
24 | Input:
25 | 3
26 | 5 8
27 | 2 4
28 | 3 9
29 | 
30 | Output:
31 | 2
32 | */
33 | 
34 | #include<iostream>
35 | #include<utility>
36 | #include<vector>
37 | #include<algorithm>
38 | using namespace std;
39 | 
40 | 
41 | 
42 | int max_customers(vector<pair<int,int>>& customerAtTimes,int& n){
43 | 
44 |     sort(customerAtTimes.begin(),customerAtTimes.end());
45 | 
46 | 
47 |     int ans = 1;
48 | 
49 |     for(int i=1;i<n;i++){
50 |         while(i<n && customerAtTimes[i].first == customerAtTimes[i-1].first){
51 |             customerAtTimes[i].second += customerAtTimes[i-1].second;
52 |             i++;
53 |         }
54 |         ans = max(ans,customerAtTimes[i-1].second);
55 |         if(i<n){
56 |             customerAtTimes[i].second += customerAtTimes[i-1].second;
57 |             ans = max(ans,customerAtTimes[i].second);
58 |         }
59 |     }
60 |     return ans;
61 |     
62 | 
63 | 
64 | }
65 | 
66 | int main(){
67 |     int n;
68 |     cin>>n;
69 | 
70 |     vector<pair<int,int>> customerAtTimes(2*n);
71 | 
72 |     int j = 0;
73 |     for(int i=0;i<n;i++){
74 |         cin>>customerAtTimes[j].first;
75 |         customerAtTimes[j].second = 1;
76 |         j++;
77 |         cin>>customerAtTimes[j].first;
78 |         customerAtTimes[j].second = -1;
79 |         j++;
80 |     }
81 |     n *=2;
82 |     cout<<max_customers(customerAtTimes,n);
83 | 
84 |     return 0;
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/Introductory Problems/06_number_spiral.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | A number spiral is an infinite grid whose upper-left square has number 1. Here are the first five layers of the spiral:
 4 | 
 5 |         1   2   9   10  25
 6 |         4   3   8   11  24
 7 |         5   6   7   12  23
 8 |         16  15  14  13  22
 9 |         17  18  19  20  21
10 | 
11 | Your task is to find out the number in row y and column x.
12 | 
13 | Input
14 | 
15 | The first input line contains an integer t: the number of tests.
16 | 
17 | After this, there are t lines, each containing integers y and x.
18 | 
19 | Output
20 | 
21 | For each test, print the number in row y and column x.
22 | 
23 | Constraints
24 | 1≤t≤10^5
25 | 1≤y,x≤10^9
26 | Example
27 | 
28 | Input:
29 | 3
30 | 2 3
31 | 1 1
32 | 4 2
33 | 
34 | Output:
35 | 8
36 | 1
37 | 15
38 | 
39 | */
40 | 
41 | #include<iostream>
42 | using namespace std;
43 | 
44 | long long find_number(long long& row,long long& col){
45 |         long long t=max(row,col)-1;
46 |         long long lower_limit=(t*t)+1;
47 |         long long upper_limit=(t+1)*(t+1); 
48 | 
49 |         if(row>=col){
50 |                    
51 |                 if(row&1)   //odd numbered L shaped
52 |                         return lower_limit+col-1;
53 |                 return upper_limit-col+1;
54 |         }
55 |         else{
56 |               
57 |                 if(col&1)   //odd numbered L shaped
58 |                         return upper_limit-row+1;
59 |                 return lower_limit+row-1;
60 |         }
61 | 
62 |         
63 | }
64 | 
65 | 
66 | int main(){
67 | 
68 |         int t;
69 |         cin>>t;
70 |         while(t--){
71 |                 long long y,x;
72 |                 cin>>y>>x;
73 |                 cout<<find_number(y,x)<<endl;
74 | 
75 |         }
76 |         
77 |         // Printing 5*5 matrix
78 |         /*cout<<endl<<endl;
79 |         for(int i=1;i<6;i++){
80 |                 for(int j=1;j<6;j++)
81 |                         cout<<find_number(i,j)<<" ";
82 |                 cout<<endl;
83 |         }
84 |         */
85 | 
86 | 
87 | 
88 |         return 0;
89 | }


--------------------------------------------------------------------------------
/Sorting and Searching/02_apartments.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | There are n applicants and m free apartments. Your task is to distribute the apartments so that as many applicants as possible will get an apartment.
 4 | 
 5 | Each applicant has a desired apartment size, and they will accept any apartment whose size is close enough to the desired size.
 6 | 
 7 | Input
 8 | 
 9 | The first input line has three integers n, m, and k: the number of applicants, the number of apartments, and the maximum allowed difference.
10 | 
11 | The next line contains n integers a1,a2,…,an: the desired apartment size of each applicant. If the desired size of an applicant is x, he or she will accept any apartment whose size is between x−k and x+k.
12 | 
13 | The last line contains m integers b1,b2,…,bm: the size of each apartment.
14 | 
15 | Output
16 | 
17 | Print one integer: the number of applicants who will get an apartment.
18 | 
19 | Constraints
20 | 1≤n,m≤2⋅10^5
21 | 0≤k≤10^9
22 | 1≤ai,bi≤10^9
23 | Example
24 | 
25 | Input:
26 | 4 3 5
27 | 60 45 80 60
28 | 30 60 75
29 | 
30 | Output:
31 | 2
32 | */
33 | 
34 | #include<iostream>
35 | #include<algorithm>
36 | #include<math.h>
37 | using namespace std;
38 | 
39 | int num_of_successful_applicants(int* person,int& n,int* flats,int& m,int& k){
40 |     sort(person,person+n);
41 |     sort(flats,flats+m);
42 |     int ans = 0;
43 |     int j = 0;
44 |     int i = 0;
45 |     while(i<m && j<n){
46 |         if(person[j]-flats[i]>k){
47 |             i++;
48 |         }
49 |         else if(person[j]-flats[i]<(-1*k)){
50 |             j++;
51 |         }
52 |         else{
53 |             i++;
54 |             j++;
55 |             ans++;
56 |         }
57 |     }
58 |     return ans;
59 | 
60 | }
61 | 
62 | int main(){
63 |     int n,m,k;
64 |     cin>>n>>m>>k;
65 |     int* applicants = new int[n];
66 |     int* apartments = new int[m];
67 |     for(int i=0;i<n;i++)
68 |         cin>>applicants[i];
69 |     
70 |     for(int i=0;i<m;i++)
71 |         cin>>apartments[i];
72 | 
73 |     cout<<num_of_successful_applicants(applicants,n,apartments,m,k);
74 | 
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/String Algorithms/01_word_combinations.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given a string of length n and a dictionary containing k words. In how many ways can you create the string using the words?
 4 |  
 5 | Input
 6 |  
 7 | The first input line has a string containing n characters between a–z.
 8 |  
 9 | The second line has an integer k: the number of words in the dictionary.
10 |  
11 | Finally there are k lines describing the words. Each word is unique and consists of characters a–z.
12 |  
13 | Output
14 |  
15 | Print the number of ways modulo 109+7.
16 |  
17 | Constraints
18 | 1≤n≤5000
19 | 1≤k≤10^5
20 | the total length of the words is at most 106
21 | Example
22 |  
23 | Input:
24 | ababc
25 | 4
26 | ab
27 | abab
28 | c
29 | cb
30 |  
31 | Output:
32 | 2
33 |  
34 | Explanation: The possible ways are ab+ab+c and abab+c.
35 | */
36 |  
37 | #include<iostream>
38 | #include<string>
39 | #include<vector>
40 | #include<algorithm>
41 | using namespace std;
42 |  
43 | bool isValidWordforString(string& a,string& b,int index){
44 |     
45 |     for(int i=0;i<a.size();i++){
46 |         if(a[i] != b[index])
47 |             return false;
48 |         index ++;
49 |     }
50 |     return true;
51 | }
52 |  
53 | int number_of_ways(vector<string>& words,int& k,int index,string& str,vector<int>& dp){
54 |  
55 |     if(dp[index]!= -1)
56 |         return dp[index];
57 |  
58 |     dp[index] = 0 ;
59 |     for(int i=0;i<k;i++){
60 |         if(words[i].size() > (str.size()-index))
61 |             break;
62 |         if(isValidWordforString(words[i],str,index)){
63 |             dp[index] += number_of_ways(words,k,index+words[i].size(),str,dp);
64 |             dp[index] %= 1000000007;
65 |         }
66 |     }
67 |     return dp[index];
68 |  
69 | }
70 | 
71 | bool compf(string& a,string& b){
72 |     return a.size()<b.size();
73 | }
74 |  
75 | int main(){
76 |     string str;
77 |     cin>>str;
78 |     int k;
79 |     cin>>k;
80 |     vector<string> words(k);
81 |     vector<int> dp(str.size()+1,-1);
82 |     dp[str.size()] = 1;
83 |     for(int i=0;i<k;i++)
84 |         cin>>words[i];
85 |     sort(words.begin(),words.end(),compf);
86 |     cout<<number_of_ways(words,k,0,str,dp);
87 |  
88 |  
89 |  
90 | }


--------------------------------------------------------------------------------
/Sorting and Searching/18_sum_of_four_values.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array of n integers, and your task is to find four values (at distinct positions) whose sum is x.
 4 | 
 5 | Input
 6 | 
 7 | The first input line has two integers n and x: the array size and the target sum.
 8 | 
 9 | The second line has n integers a1,a2,…,an: the array values.
10 | 
11 | Output
12 | 
13 | Print four integers: the positions of the values. If there are several solutions, you may print any of them. If there are no solutions, print IMPOSSIBLE.
14 | 
15 | Constraints
16 | 1≤n≤1000
17 | 1≤x,ai≤10^9
18 | Example
19 | 
20 | Input:
21 | 8 15
22 | 3 2 5 8 1 3 2 3
23 | 
24 | Output:
25 | 2 4 6 7
26 | */
27 | 
28 | #include<iostream>
29 | #include<algorithm>
30 | #include<vector>
31 | #include<utility>
32 | using namespace std;
33 | 
34 | void find_ans(vector<pair<int,int>>& arr,int& n,int& x){
35 |     for(int i=n-1;i>2;i--){
36 |         int sum_remaining = x - arr[i].first;
37 |         if(sum_remaining > 0){
38 |             for(int j=i-1;j>1;j--){  
39 |                 int sum_remaining_1 = sum_remaining - arr[j].first;
40 |                 if(sum_remaining_1 > 0){
41 |                     int start = 0;
42 |                     int end = j-1;
43 |                     while(start<end){
44 |                         if(arr[start].first + arr[end].first == sum_remaining_1){
45 |                             cout<<arr[start].second<<" "<<arr[end].second<<" "<<arr[j].second<<" "<<arr[i].second;
46 |                             return;
47 |                         }
48 |                         else if(arr[start].first + arr[end].first > sum_remaining_1)
49 |                             end--;
50 |                         else
51 |                             start++;
52 |                 
53 |                     }
54 |                 }
55 |             }
56 |         }
57 |         
58 |     }
59 |     cout<<"IMPOSSIBLE";
60 | }
61 | 
62 | int main(){
63 |     int n,x;
64 |     cin>>n>>x;
65 |     vector<pair<int,int>> arr(n);
66 | 
67 |     for(int i=0;i<n;i++){
68 |         cin>>arr[i].first;
69 |         arr[i].second = i+1;
70 |     }
71 |     sort(arr.begin(),arr.end());
72 | 
73 |     find_ans(arr,n,x);
74 | 
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/Sorting and Searching/23_array_divison.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You are given an array containing n positive integers.
 4 | 
 5 | Your task is to divide the array into k subarrays so that the maximum sum in a subarray is as small as possible.
 6 | 
 7 | Input
 8 | 
 9 | The first input line contains two integers n and k: the size of the array and the number of subarrays in the division.
10 | 
11 | The next line contains n integers x1,x2,…,xn: the contents of the array.
12 | 
13 | Output
14 | 
15 | Print one integer: the maximum sum in a subarray in the optimal division.
16 | 
17 | Constraints
18 | 1≤n≤2⋅10^5
19 | 1≤k≤n
20 | 1≤xi≤10^9
21 | Example
22 | 
23 | Input:
24 | 5 3
25 | 2 4 7 3 5
26 | 
27 | Output:
28 | 8
29 | 
30 | Explanation: An optimal division is [2,4],[7],[3,5] where the sums of the subarrays are 6,7,8. The largest sum is the last sum 8.
31 | */
32 | 
33 | #include<iostream>
34 | using namespace std;
35 | 
36 | 
37 | bool isSolutionPossible(long long& mid,int* arr,int& n,int& k){
38 | 
39 |     int count = 1;
40 |     long long curr_sum = 0;
41 |     for(int i=0;i<n;i++){
42 |         curr_sum += arr[i];
43 |         if(arr[i] > mid)
44 |             return false;
45 |         if(curr_sum > mid){
46 |             count ++;
47 |             curr_sum = arr[i];
48 |             if(count > k)
49 |                 return false;
50 |         }           
51 |     }
52 |     return true;
53 | 
54 | }
55 | 
56 | long long divide_array_optimally(int* arr,int& n,int& k,long long& start,long long& end){
57 | 
58 |     long long maxSum = end;
59 |     while(start<=end){
60 |         long long mid = start + (end - start)/2;
61 |         if(isSolutionPossible(mid,arr,n,k)){
62 |             end = mid - 1;
63 |             maxSum = mid;
64 |         }
65 |         else{
66 |             start = mid + 1;
67 |         }
68 | 
69 |     }
70 |     return maxSum;
71 | }
72 | 
73 | int main(){
74 |     int n,k;
75 |     cin>>n>>k;
76 | 
77 |     int* arr = new int[n];
78 |     long long min_element = 1;
79 |     long long max_element = 0;
80 |     for(int i=0;i<n;i++){
81 |         cin>>arr[i];
82 |         max_element += arr[i];
83 |     }
84 |     
85 |     cout<<divide_array_optimally(arr,n,k,min_element,max_element);
86 | 
87 |     return 0;
88 | }


--------------------------------------------------------------------------------
/Dynamic Programming/08_array_description.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Time limit: 1.00 s Memory limit: 512 MB
 3 | You know that an array has n integers between 1 and m, and the difference between two adjacent values is at most 1.
 4 | 
 5 | Given a description of the array where some values may be unknown, your task is to count the number of arrays that match the description.
 6 | 
 7 | Input
 8 | 
 9 | The first input line has two integers n and m: the array size and the upper bound for each value.
10 | 
11 | The next line has n integers x1,x2,…,xn: the contents of the array. Value 0 denotes an unknown value.
12 | 
13 | Output
14 | 
15 | Print one integer: the number of arrays modulo 109+7.
16 | 
17 | Constraints
18 | 1≤n≤10^5
19 | 1≤m≤100
20 | 0≤xi≤m
21 | Example
22 | 
23 | Input:
24 | 3 5
25 | 2 0 2
26 | 
27 | Output:
28 | 3
29 | 
30 | Explanation: The arrays [2,1,2], [2,2,2] and [2,3,2] match the description.
31 | */
32 | 
33 | #include<iostream>
34 | #include<vector>
35 | using namespace std;
36 | 
37 | 
38 | 
39 | int main(){
40 |     int n,m;
41 |     cin>>n>>m;
42 |     int* arr = new int[n];
43 |     for(int i=0;i<n;i++)
44 |         cin>>arr[i];
45 |     
46 |     vector<vector<int>> dp(n,vector<int>(m,0));
47 |     
48 |     if(arr[n-1] == 0){
49 |         for(int i=0;i<m;i++)
50 |             dp[n-1][i] = 1;
51 |     }
52 |     else
53 |         dp[n-1][arr[n-1]-1] = 1;
54 |     
55 |     for(int i=n-2;i>=0;i--){
56 |         for(int j=m-1;j>=0;j--){
57 |             if(arr[i] == j+1 || arr[i] == 0){
58 |                 if(j-1 >= 0){
59 |                     dp[i][j] += dp[i+1][j-1];
60 |                     dp[i][j] %= 1000000007;
61 |                 }
62 |                 if(j+1 < m){
63 |                     dp[i][j] += dp[i+1][j+1];
64 |                     dp[i][j] %= 1000000007;
65 |                 }
66 |                 dp[i][j] += dp[i+1][j];
67 |                 dp[i][j] %= 1000000007;
68 |             }
69 |         }
70 |     }
71 |     int arr_count = 0;
72 |     if(arr[0] == 0){
73 |         for(int i=0;i<m;i++){
74 |             arr_count += dp[0][i];
75 |             arr_count %= 1000000007;
76 |         }
77 |     }
78 |     else
79 |         arr_count = dp[0][arr[0]-1];
80 |     
81 |     cout<<arr_count;
82 |     /*cout<<endl<<endl;
83 | 
84 |     for(int i=0;i<n;i++){
85 |         for(int j=0;j<m+1;j++)
86 |             cout<<dp[i][j]<<"  ";
87 |         cout<<endl;
88 |     }
89 |     */
90 |     return 0;
91 | }


--------------------------------------------------------------------------------
/Path Finding Algorithms/dijkistra_algo.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<unordered_map>
 3 | #include<vector>
 4 | #include<utility>
 5 | #include<climits>
 6 | using namespace std;
 7 | 
 8 | int find_min(vector<int>& min_distances,vector<bool>& isVisited,int& total_nodes){
 9 |     
10 |     int index = -1;
11 |     int value = INT_MAX;
12 |     for(int i=1;i<=total_nodes;i++){
13 |         if(!isVisited[i] && min_distances[i] <= value){
14 |             value = min_distances[i];
15 |             index = i;
16 |         }
17 |     }
18 |     return index;
19 |     
20 | }
21 | 
22 | void dijkistra_algo(unordered_map<int,vector<pair<int,int>>>& graph,int total_nodes,int starting_node){
23 |     
24 |     vector<int> min_distances(total_nodes+1,INT_MAX);
25 |     min_distances[starting_node] = 0;
26 |     
27 |     vector<bool> isVisited(total_nodes+1,false);
28 |     
29 |     
30 |     for(int i=0;i<total_nodes-1;i++){
31 |         
32 |         int node_index = find_min(min_distances,isVisited,total_nodes);
33 |         isVisited[node_index] = true;
34 |         
35 |         for(int j=0;j<graph[node_index].size();j++){
36 |             if(!isVisited[graph[node_index][j].first] && min_distances[node_index]<INT_MAX && min_distances[node_index]+graph[node_index][j].second < min_distances[graph[node_index][j].first]){
37 |                 min_distances[graph[node_index][j].first] = min_distances[node_index] + graph[node_index][j].second;
38 |                 
39 |             }
40 |         }
41 |         
42 |     }
43 |     
44 |     for(int i=1;i<=total_nodes;i++){
45 |         if(min_distances[i] == INT_MAX)
46 |             cout<<"Shortest distance between starting node "<<starting_node<<" and node "<<i<<" : Not Possible !"<<endl;
47 |         else
48 |             cout<<"Shortest distance between starting node "<<starting_node<<" and node "<<i<<" : "<<min_distances[i]<<endl;
49 |     }
50 |     
51 | }
52 | 
53 | 
54 | int main(){
55 |     
56 |     unordered_map<int,vector<pair<int,int>>> graph;
57 |     graph[1].push_back({2,12});
58 |     graph[1].push_back({3,3});
59 |     graph[1].push_back({4,9});
60 |     graph[2].push_back({7,23});
61 |     graph[2].push_back({6,2});
62 |     graph[2].push_back({5,15});
63 |     graph[3].push_back({7,10});
64 |     graph[3].push_back({6,5});
65 |     graph[3].push_back({1,3});
66 |     graph[3].push_back({5,7});
67 |     graph[4].push_back({7,41});
68 |     graph[4].push_back({1,9});
69 |     graph[5].push_back({7,12});
70 |     graph[5].push_back({3,7});
71 |     graph[5].push_back({2,15});
72 |     graph[6].push_back({7,1});
73 |     graph[6].push_back({2,2});
74 |     graph[7].push_back({4,41});
75 |     graph[7].push_back({6,1});
76 |     
77 |     int total_nodes = 7;
78 |     int starting_node = 1;
79 |     dijkistra_algo(graph,total_nodes,starting_node);
80 |     
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/Introductory Problems/15_chessboard_nd_queens.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Time limit: 1.00 s Memory limit: 512 MB
  3 | Your task is to place eight queens on a chessboard so that no two queens are attacking each other. As an additional challenge, each square is either free or reserved, and you can only place queens on the free squares. However, the reserved squares do not prevent queens from attacking each other.
  4 | 
  5 | How many possible ways are there to place the queens?
  6 | 
  7 | Input
  8 | 
  9 | The input has eight lines, and each of them has eight characters. Each square is either free (.) or reserved (*).
 10 | 
 11 | Output
 12 | 
 13 | Print one integer: the number of ways you can place the queens.
 14 | 
 15 | Example
 16 | 
 17 | Input:
 18 | ........
 19 | ........
 20 | ..*.....
 21 | ........
 22 | ........
 23 | .....**.
 24 | ...*....
 25 | ........
 26 | 
 27 | Output:
 28 | 65
 29 | */
 30 | 
 31 | #include<iostream>
 32 | #include<vector>
 33 | using namespace std;
 34 | 
 35 | bool isSafeMove(vector<vector<char>>& board,int& row, int& col,int& n){
 36 |     for(int i=0;i<n;i++){
 37 |         if(board[i][col] == 'Q')
 38 |             return false;
 39 |     }
 40 | 
 41 |     int r = row + 1;
 42 |     int c = col + 1;
 43 |     while( r<n && c<n){
 44 |         if(board[r][c] == 'Q')
 45 |             return false;
 46 |         r++;
 47 |         c++;
 48 |     }
 49 | 
 50 |     r = row - 1;
 51 |     c = col - 1;
 52 |     while( r>=0 && c>=0){
 53 |         if(board[r][c] == 'Q')
 54 |             return false;
 55 |         r--;
 56 |         c--;
 57 |     }
 58 | 
 59 |     r = row - 1;
 60 |     c = col + 1;
 61 |     while( r>=0 && c<n){
 62 |         if(board[r][c] == 'Q')
 63 |             return false;
 64 |         r--;
 65 |         c++;
 66 |     }
 67 | 
 68 |     r = row + 1;
 69 |     c = col - 1;
 70 |     while( r<n && c>=0){
 71 |         if(board[r][c] == 'Q')
 72 |             return false;
 73 |         r++;
 74 |         c--;
 75 |     }
 76 |     return true;
 77 | }
 78 | 
 79 | void number_of_ways(vector<vector<char>>& board,int& size,int row_number,int& count){
 80 |     if(row_number == size){
 81 |         count++;
 82 |         return;
 83 |     }
 84 |     else{
 85 |         for(int i=0;i<size;i++){
 86 |             if(board[row_number][i]!='*' && isSafeMove(board,row_number,i,size)){
 87 |                 board[row_number][i] = 'Q';
 88 |                 number_of_ways(board,size,row_number+1,count);
 89 |                 board[row_number][i] = '.';
 90 |             }
 91 |         }
 92 |     }
 93 | }
 94 | 
 95 | int main(){
 96 | 
 97 |     vector<vector<char>> board(8,vector<char>(8));
 98 |     
 99 |     for(int i=0;i<8;i++){
100 |         for(int j=0;j<8;j++)
101 |             cin>>board[i][j];
102 |     }
103 |     int count = 0;
104 |     int board_size = 8;
105 |     number_of_ways(board,board_size,0,count);
106 |     cout<<count;
107 | 
108 | 
109 |     return 0;
110 | }


--------------------------------------------------------------------------------
/Sorting and Searching/14_factory_machines.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Time limit: 1.00 s Memory limit: 512 MB
  3 | A factory has n machines which can be used to make products. Your goal is to make a total of t products.
  4 |  
  5 | For each machine, you know the number of seconds it needs to make a single product. The machines can work simultaneously, and you can freely decide their schedule.
  6 |  
  7 | What is the shortest time needed to make t products?
  8 |  
  9 | Input
 10 |  
 11 | The first input line has two integers n and t: the number of machines and products.
 12 |  
 13 | The next line has n integers k1,k2,…,kn: the time needed to make a product using each machine.
 14 |  
 15 | Output
 16 |  
 17 | Print one integer: the minimum time needed to make t products.
 18 |  
 19 | Constraints
 20 | 1≤n≤2⋅10^5
 21 | 1≤t≤10^9
 22 | 1≤ki≤10^9
 23 | Example
 24 |  
 25 | Input:
 26 | 3 7
 27 | 3 2 5
 28 |  
 29 | Output:
 30 | 8
 31 |  
 32 | Explanation: Machine 1 makes two products, machine 2 makes four products and machine 3 makes one product.
 33 | */
 34 |  
 35 | #include<iostream>
 36 | #include<climits>
 37 | using namespace std;
 38 |  
 39 | long long bin_search(long long start,long long end,int& packets,int* arr,int& n){
 40 |  
 41 |     long long answer = end;
 42 |  
 43 |     while(start<=end){
 44 |         long long mid = start + (end-start)/2;
 45 |         long long temp = 0;
 46 |         bool flag = false;
 47 |         for(int i=0;i<n;i++){
 48 |             temp += mid/arr[i];
 49 |             if(temp > 1000000000000000000){ // to avoid getting out of range of long
 50 |                 flag = true;
 51 |                 break;
 52 |             }
 53 |         }
 54 |         //cout<<start<< " "<<mid<<" "<<end<<" "<<temp<<"***"<<endl;
 55 |         if(temp >= packets || flag ){
 56 |             answer = min(answer,mid);
 57 |             end = mid - 1;
 58 |         }
 59 |         else
 60 |             start = mid + 1;
 61 |     }
 62 |     return answer;
 63 |  
 64 | }
 65 |  
 66 | /*long long min_time_taken(int* arr,int& n,int& t){
 67 |     if(t == 0)
 68 |         return 0;
 69 |     long long candidate_time = 1;
 70 |  
 71 |     while(true){
 72 |         long long packets = 0;
 73 |         for(int i=0;i<n;i++)
 74 |             packets += candidate_time/arr[i];
 75 |         if(packets == t)
 76 |             return candidate_time;
 77 |         else if(packets > t)
 78 |             break;
 79 |         candidate_time *= 2;
 80 |     }
 81 |     //cout<<candidate_time/2<<"  "<<candidate_time<<endl;
 82 |     return bin_search(candidate_time/2,candidate_time,t,arr,n);
 83 |  
 84 | }*/
 85 |  
 86 | int main(){
 87 |     int n,t;
 88 |     //n = 10;
 89 |     //t =10;
 90 |     cin>>n>>t;
 91 |     int* time = new int[n];//{6 ,6 ,4 ,3 ,4 ,9 ,3 ,2 ,6 ,10};
 92 |    
 93 |   
 94 |     for(int i=0;i<n;i++)
 95 |         cin>>time[i];
 96 |      
 97 |     //cout<<min_time_taken(time,n,t);
 98 |     cout<<bin_search(1,1000000000000000000,t,time,n);
 99 |     return 0;
100 | }


--------------------------------------------------------------------------------
/Sorting and Searching/13_room_allocation.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Time limit: 1.00 s Memory limit: 512 MB
  3 | There is a large hotel, and n customers will arrive soon. Each customer wants to have a single room.
  4 | 
  5 | You know each customer's arrival and departure day. Two customers can stay in the same room if the departure day of the first customer is earlier than the arrival day of the second customer.
  6 | 
  7 | What is the minimum number of rooms that are needed to accommodate all customers? And how can the rooms be allocated?
  8 | 
  9 | Input
 10 | 
 11 | The first input line contains an integer n: the number of customers.
 12 | 
 13 | Then there are n lines, each of which describes one customer. Each line has two integers a and b: the arrival and departure day.
 14 | 
 15 | Output
 16 | 
 17 | Print first an integer k: the minimum number of rooms required.
 18 | 
 19 | After that, print a line that contains the room number of each customer in the same order as in the input. The rooms are numbered 1,2,…,k.
 20 | 
 21 | Constraints
 22 | 1≤n≤2⋅10^5
 23 | 1≤a≤b≤10^9
 24 | Example
 25 | 
 26 | Input:
 27 | 3
 28 | 1 2
 29 | 2 4
 30 | 4 4
 31 | 
 32 | Output:
 33 | 2
 34 | 1 2 1
 35 | */
 36 | 
 37 | #include<iostream>
 38 | #include<set>
 39 | #include<vector>
 40 | #include<iterator>
 41 | #include<algorithm>
 42 | using namespace std;
 43 | 
 44 | /*bool compf(pair<pair<int,int>,int>& a, pair<pair<int,int>,int>& b){
 45 |     if( a.first.first != b.first.first)
 46 |         return a.first.first < b.first.first;
 47 |     else {
 48 |         if(a.first.second != b.first.second)
 49 |             return a.first.second < b.first.second;
 50 |         return a.second < b.second;
 51 |     }
 52 | 
 53 | }*/
 54 | 
 55 | int main(){
 56 |     int n;
 57 |     cin>>n;
 58 | 
 59 |     vector<pair<pair<int,int>,int>> timings(n);
 60 |     for(int i=0;i<n;i++){
 61 |         cin>>timings[i].first.first>>timings[i].first.second;
 62 |         timings[i].second = i+1;
 63 |     }
 64 |     sort(timings.begin(),timings.end());//,compf);
 65 | 
 66 |     /*for(int i=0;i<n;i++){
 67 |         cout<<timings[i].first.first<<" "<<timings[i].first.second<<" "<<timings[i].second<<endl;
 68 |     }
 69 |     cout<<endl;*/
 70 | 
 71 |     multiset<int> roomFinishTimes;
 72 |     vector<int> respectiveRooms(n+1,0);
 73 |     int roomNum = 1;
 74 |     roomFinishTimes.insert(timings[0].first.second);
 75 |     respectiveRooms[timings[0].second] = roomNum;
 76 |     roomNum++;
 77 | 
 78 |     for(int i=1;i<n;i++){
 79 |        
 80 | 
 81 |         auto it = roomFinishTimes.lower_bound(timings[i].first.first);
 82 |         if(it == roomFinishTimes.begin()){
 83 |             roomFinishTimes.insert(timings[i].first.second);
 84 |             respectiveRooms[timings[i].second] = roomNum;
 85 |             roomNum ++;
 86 |         }
 87 |         else{
 88 |             it--;
 89 |             //cout<<(*it)<<"***"<<endl;
 90 |             int temp = distance(roomFinishTimes.begin(),it)+1;
 91 |             roomFinishTimes.erase(it);
 92 |             roomFinishTimes.insert(timings[i].first.second);
 93 |             respectiveRooms[timings[i].second] = temp;
 94 |         }
 95 |         
 96 |     }
 97 |     cout<<roomFinishTimes.size()<<endl;
 98 |     for(int i=1;i<=n;i++)
 99 |         cout<<respectiveRooms[i]<<" ";
100 | 
101 | 
102 |     return 0;
103 | }


--------------------------------------------------------------------------------
/Path Finding Algorithms/floyd_warshall_algo.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<unordered_map>
  3 | #include<vector>
  4 | #include<utility>
  5 | #include<climits>
  6 | using namespace std;
  7 | 
  8 | void floyd_warshall_algo(unordered_map<int,vector<pair<int,int>>>& graph,int total_nodes){
  9 |     
 10 |     vector<vector<int>> min_dist_matrix(total_nodes+1,vector<int>(total_nodes+1,INT_MAX));
 11 |     for(int i=1;i<=total_nodes;i++)
 12 |         min_dist_matrix[i][i] = 0;
 13 |     
 14 |     for(int i=1;i<= total_nodes;i++){
 15 |         for(int j=0;j<graph[i].size();j++){
 16 |             min_dist_matrix[i][graph[i][j].first] = graph[i][j].second;
 17 |         }
 18 |     }
 19 |     
 20 |     for(int k=1;k<=total_nodes;k++){
 21 |         for(int i=1;i<=total_nodes;i++){
 22 |             for(int j=1;j<=total_nodes;j++){
 23 |                 if(min_dist_matrix[i][k] != INT_MAX && min_dist_matrix[k][j] != INT_MAX)
 24 |                     min_dist_matrix[i][j] = min(min_dist_matrix[i][j],min_dist_matrix[i][k]+min_dist_matrix[k][j]);
 25 |             }
 26 |         }
 27 |     }
 28 |     
 29 |     for(int i=1;i<=total_nodes;i++){
 30 |         for(int j=1;j<=total_nodes;j++){
 31 |             if(min_dist_matrix[i][j] == INT_MAX){
 32 |                 cout<<"No possible path from node "<<i<<" to node "<<j<<" !"<<endl;
 33 |             }
 34 |             else
 35 |                 cout<<"Min distance between node "<<i<<" to node "<<j<<" : "<<min_dist_matrix[i][j]<<endl;
 36 |         }
 37 |     }
 38 |     
 39 |     
 40 | }
 41 | 
 42 | 
 43 | int main(){
 44 |     
 45 |     unordered_map<int,vector<pair<int,int>>> graph;
 46 |     graph[1].push_back({2,12});
 47 |     graph[1].push_back({3,3});
 48 |     graph[1].push_back({4,9});
 49 |     //graph[2].push_back({7,23});
 50 |     graph[2].push_back({6,2});
 51 |     graph[2].push_back({5,15});
 52 |     //graph[3].push_back({7,10});
 53 |     graph[3].push_back({6,5});
 54 |     graph[3].push_back({1,3});
 55 |     graph[3].push_back({5,7});
 56 |     //graph[4].push_back({7,41});
 57 |     graph[4].push_back({1,9});
 58 |     //graph[5].push_back({7,12});
 59 |     graph[5].push_back({3,7});
 60 |     graph[5].push_back({2,15});
 61 |     //graph[6].push_back({7,1});
 62 |     graph[6].push_back({2,2});
 63 |     graph[7].push_back({4,41});
 64 |     graph[7].push_back({6,1});
 65 |     
 66 |     int total_nodes = 7;
 67 | 
 68 |     
 69 |     floyd_warshall_algo(graph,total_nodes);
 70 |     
 71 |     return 0;
 72 | }#include<iostream>
 73 | #include<unordered_map>
 74 | #include<vector>
 75 | #include<utility>
 76 | #include<climits>
 77 | using namespace std;
 78 | 
 79 | void floyd_warshall_algo(unordered_map<int,vector<pair<int,int>>>& graph,int total_nodes){
 80 |     
 81 |     vector<vector<int>> min_dist_matrix(total_nodes+1,vector<int>(total_nodes+1,INT_MAX));
 82 |     for(int i=1;i<=total_nodes;i++)
 83 |         min_dist_matrix[i][i] = 0;
 84 |     
 85 |     for(int i=1;i<= total_nodes;i++){
 86 |         for(int j=0;j<graph[i].size();j++){
 87 |             min_dist_matrix[i][graph[i][j].first] = graph[i][j].second;
 88 |         }
 89 |     }
 90 |     
 91 |     for(int k=1;k<=total_nodes;k++){
 92 |         for(int i=1;i<=total_nodes;i++){
 93 |             for(int j=1;j<=total_nodes;j++){
 94 |                 if(min_dist_matrix[i][k] != INT_MAX && min_dist_matrix[k][j] != INT_MAX)
 95 |                     min_dist_matrix[i][j] = min(min_dist_matrix[i][j],min_dist_matrix[i][k]+min_dist_matrix[k][j]);
 96 |             }
 97 |         }
 98 |     }
 99 |     
100 |     for(int i=1;i<=total_nodes;i++){
101 |         for(int j=1;j<=total_nodes;j++){
102 |             if(min_dist_matrix[i][j] == INT_MAX){
103 |                 cout<<"No possible path from node "<<i<<" to node "<<j<<" !"<<endl;
104 |             }
105 |             else
106 |                 cout<<"Min distance between node "<<i<<" to node "<<j<<" : "<<min_dist_matrix[i][j]<<endl;
107 |         }
108 |     }
109 |     
110 |     
111 | }
112 | 
113 | 
114 | int main(){
115 |     
116 |     unordered_map<int,vector<pair<int,int>>> graph;
117 |     graph[1].push_back({2,12});
118 |     graph[1].push_back({3,3});
119 |     graph[1].push_back({4,9});
120 |     //graph[2].push_back({7,23});
121 |     graph[2].push_back({6,2});
122 |     graph[2].push_back({5,15});
123 |     //graph[3].push_back({7,10});
124 |     graph[3].push_back({6,5});
125 |     graph[3].push_back({1,3});
126 |     graph[3].push_back({5,7});
127 |     //graph[4].push_back({7,41});
128 |     graph[4].push_back({1,9});
129 |     //graph[5].push_back({7,12});
130 |     graph[5].push_back({3,7});
131 |     graph[5].push_back({2,15});
132 |     //graph[6].push_back({7,1});
133 |     graph[6].push_back({2,2});
134 |     graph[7].push_back({4,41});
135 |     graph[7].push_back({6,1});
136 |     
137 |     int total_nodes = 7;
138 | 
139 |     
140 |     floyd_warshall_algo(graph,total_nodes);
141 |     
142 |     return 0;
143 | }


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