├── LCS_bottom_up_dp.cpp ├── LCS_memoization.cpp ├── LCS_recursive.cpp ├── LCSubstring.cpp ├── MCM_memoization.cpp ├── MCM_recursive.cpp ├── README.md ├── SCS.cpp ├── coin_change_max_ways.cpp ├── coin_change_min_coins.cpp ├── count_of_subset_with_given_diff.cpp ├── count_of_subsets_with_given_sum.cpp ├── diameter_of_binary_tree.cpp ├── egg_dropping_problem_memoization.cpp ├── egg_dropping_problem_memoized_optimization.cpp ├── egg_dropping_problem_optimized_for_leetcode.cpp ├── egg_dropping_problem_recursive.cpp ├── equal_sum_partition_problem.cpp ├── evaluate_expression_to_true.cpp ├── evaluate_expression_to_true_bottom_up_dp_using_3d_array.cpp ├── evaluate_expression_to_true_memoization_using_3d_array.cpp ├── evaluate_expression_to_true_memoization_using_map.cpp ├── knapsack_memoization.cpp ├── knapsack_recursive.cpp ├── knapsack_top_down_dp.cpp ├── longest_pallin_subseq.cpp ├── longest_repeating_subseq.cpp ├── max_path_sum_from_any_node_to_any.cpp ├── max_path_sum_from_leaf_to_leaf.cpp ├── min_del_to_make_pallindrome.cpp ├── min_insertion_del__to_convert_a_to_b.cpp ├── min_insertion_to_make_string_pallindrome.cpp ├── min_subset_sum_diff.cpp ├── pallindrome_partitioning_memoization.cpp ├── pallindrome_partitioning_memoized_optimization.cpp ├── pallindrome_partitioning_recursive.cpp ├── print_LCS.cpp ├── print_SCS.cpp ├── rod_cutting_problem.cpp ├── scramble_strings.cpp ├── scramble_strings_memoization.cpp ├── sequence_patttern_matching.cpp ├── subset_sum_problem_dp.cpp └── target_sum.cpp /LCS_bottom_up_dp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | signed main() { 24 | string X, Y; cin >> X >> Y; 25 | int n = X.length(), m = Y.length(); 26 | 27 | cout << LCS(X, Y, n, m) << endl; 28 | return 0; 29 | } -------------------------------------------------------------------------------- /LCS_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int dp[D][D]; 6 | 7 | int LCS(string X, string Y, int n, int m) { 8 | // base case 9 | if (n == 0 || m == 0) 10 | dp[n][m] = 0; 11 | 12 | if (dp[n][m] != -1) 13 | return dp[n][m]; 14 | 15 | // when last character is same 16 | if (X[n - 1] == Y[m - 1]) 17 | dp[n][m] = 1 + LCS(X, Y, n - 1, m - 1); 18 | // when last character is not same -> pick max 19 | else 20 | dp[n][m] = max(LCS(X, Y, n - 1, m), LCS(X, Y, n, m - 1)); 21 | 22 | return dp[n][m]; 23 | } 24 | 25 | signed main() { 26 | string X, Y; cin >> X >> Y; 27 | int n = X.length(), m = Y.length(); 28 | 29 | memset(dp, -1, sizeof(dp)); 30 | 31 | cout << LCS(X, Y, n, m) << endl; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /LCS_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | // base case 6 | if (n == 0 || m == 0) 7 | return 0; 8 | 9 | // when last character is same 10 | if (X[n - 1] == Y[m - 1]) 11 | return 1 + LCS(X, Y, n - 1, m - 1); 12 | // when last character is not same -> pick max 13 | else 14 | return max(LCS(X, Y, n - 1, m), LCS(X, Y, n, m - 1)); 15 | } 16 | 17 | signed main() { 18 | string X, Y; cin >> X >> Y; 19 | int n = X.length(), m = Y.length(); 20 | 21 | cout << LCS(X, Y, n, m) << endl; 22 | return 0; 23 | } -------------------------------------------------------------------------------- /LCSubstring.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCSubstr(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | for (int i = 0; i <= n; i++) 8 | for (int j = 0; j <= m; j++) 9 | if (i == 0 || j == 0) 10 | dp[i][j] = 0; 11 | 12 | for (int i = 1; i <= n; i++) 13 | for (int j = 1; j <= m; j++) 14 | if (X[i - 1] == Y[j - 1]) 15 | dp[i][j] = 1 + dp[i - 1][j - 1]; 16 | else 17 | dp[i][j] = 0; 18 | 19 | int mx = INT_MIN; 20 | for (int i = 0; i <= n; i++) 21 | for (int j = 0; j <= m; j++) 22 | mx = max(mx, dp[i][j]); 23 | 24 | return mx; 25 | } 26 | 27 | signed main() { 28 | string X, Y; cin >> X >> Y; 29 | int n = X.length(), m = Y.length(); 30 | 31 | cout << LCSubstr(X, Y, n, m) << endl; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /MCM_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1000; 5 | int t[D][D]; 6 | 7 | int Solve(int arr[], int i, int j) { 8 | if (i >= j) { 9 | t[i][j] = 0; 10 | return 0; 11 | } 12 | 13 | if (t[i][j] != -1) 14 | return t[i][j]; 15 | 16 | int ans = INT_MAX; 17 | for (int k = i; k <= j - 1; k++) { 18 | int temp_ans = Solve(arr, i, k) + Solve(arr, k + 1, j) + arr[i - 1] * arr[k] * arr[j]; 19 | ans = min(ans, temp_ans); 20 | } 21 | 22 | return t[i][j] = ans; 23 | } 24 | 25 | signed main() { 26 | int n; cin >> n; 27 | int arr[n]; 28 | for (int i = 0; i < n; i++) 29 | cin >> arr[i]; 30 | 31 | memset(t, -1, sizeof(t)); 32 | 33 | cout << Solve(arr, 1, n - 1) << endl; 34 | return 0; 35 | } -------------------------------------------------------------------------------- /MCM_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(int arr[], int i, int j) { 5 | if (i >= j) 6 | return 0; 7 | 8 | int ans = INT_MAX; 9 | for (int k = i; k <= j - 1; k++) { 10 | int temp_ans = Solve(arr, i, k) + Solve(arr, k + 1, j) + arr[i - 1] * arr[k] * arr[j]; 11 | ans = min(ans, temp_ans); 12 | } 13 | 14 | return ans; 15 | } 16 | 17 | signed main() { 18 | int n; cin >> n; 19 | int arr[n]; 20 | for (int i = 0; i < n; i++) 21 | cin >> arr[i]; 22 | 23 | cout << Solve(arr, 1, n - 1) << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Dynamic-Programming-Questions-by-Aditya-Verma 2 | 3 | Codes of all questions covered by Aditya Verma in his Dynamic Programming Lectures\ 4 | (Codes are tested on gfg / leetcode and are in the order of videos)\ 5 | Note: **Click on title of question to go to the page of code** 6 | 7 | - **0/1 Knapsack** 8 | - [Knapsack Recursive](knapsack_recursive.cpp) 9 | - [Video Link](https://www.youtube.com/watch?v=kvyShbFVaY8&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=3) 10 | - [Knapsack Memoization](knapsack_memoization.cpp) 11 | - [Video Link](https://www.youtube.com/watch?v=fJbIuhs24zQ&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=4) 12 | - [Knapsack Bottom-up](knapsack_top_down_dp.cpp) 13 | - [Video Link](https://www.youtube.com/watch?v=ntCGbPMeqgg&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=5) 14 | - [Subset Sum Problem](subset_sum_problem_dp.cpp) 15 | - [Video Link](https://www.youtube.com/watch?v=_gPcYovP7wc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=7) 16 | - [Equal Sum Partition Problem](equal_sum_partition_problem.cpp) 17 | - [Video Link](https://www.youtube.com/watch?v=UmMh7xp07kY&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=8) 18 | - [Count of Subsets Sum with a Given Sum](count_of_subsets_with_given_sum.cpp) 19 | - [Video Link](https://www.youtube.com/watch?v=F7wqWbqYn9g&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=9) 20 | - [Min Subset Sum Difference](min_subset_sum_diff.cpp) 21 | - [Video Link](https://www.youtube.com/watch?v=-GtpxG6l_Mc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=10) 22 | - [Count of Subsets with given diff](count_of_subset_with_given_diff.cpp) 23 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=11) 24 | - [Target Sum - Specific to leetcode problem](target_sum.cpp) 25 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=12) 26 | - **Unbounded Knapsack** 27 | - [Rod Cutting Problem](rod_cutting_problem.cpp) 28 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=14) 29 | - [Coin Change - I: max number of ways](coin_change_max_ways.cpp) 30 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=15) 31 | - [Coin Change - II: min number of coins](coin_change_min_coins.cpp) 32 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=16) 33 | - **Longest Common Subsequence (LCS)** 34 | - [LCS Recursive](LCS_recursive.cpp) 35 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=19) 36 | - [LCS Memoization](LCS_memoization.cpp) 37 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=20) 38 | - [LCS Bottom - Up DP](LCS_bottom_up_dp.cpp) 39 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=21) 40 | - [Longest Common Substring](LCSubstring.cpp) 41 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=22) 42 | - [Print LCS](print_LCS.cpp) 43 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=23) 44 | - [Shortest Common Supersequence (SCS)](SCS.cpp) 45 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=24) 46 | - [Min # of insertion and deletion to convert a to b](min_insertion_del__to_convert_a_to_b.cpp) 47 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=25) 48 | - [Longest Pallindromic Subsquence (LPS)](longest_pallin_subseq.cpp) 49 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=26) 50 | - [Min Number of deletions in string to make it pallindrome](min_del_to_make_pallindrome.cpp) 51 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=28) 52 | - [Print SCS](print_SCS.cpp) 53 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=29) 54 | - [Longest Repeating Subsequence](longest_repeating_subseq.cpp) 55 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=30) 56 | - [Sequence Pattern Matching](sequence_patttern_matching.cpp) 57 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=31) 58 | - [Min number of insertion in a string to make string pallindrome](min_insertion_to_make_string_pallindrome.cpp) 59 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=32) 60 | - **Matrix Chain Multiplication (MCM)** 61 | - [MCM Recursive](MCM_recursive.cpp) 62 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=34) 63 | - [MCM Memoization](MCM_memoization.cpp) 64 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=35) 65 | - [Pallindrome Partitioning Recursive](pallindrome_partitioning_recursive.cpp) 66 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=36) 67 | - [Pallindrome Partitioning Memoization](pallindrome_partitioning_memoization.cpp) 68 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=37) 69 | - [Pallindrome Partitioning Optimization -> Still Giving TLE on GFG(Will Update if found better)](pallindrome_partitioning_memoized_optimization.cpp) 70 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=38) 71 | - To Solve these problem on GFG [Click Here.](https://practice.geeksforgeeks.org/problems/palindromic-patitioning4845/1) 72 | - [Evaluate Expression to true Recursive](evaluate_expression_to_true.cpp) 73 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=39) 74 | - [Evaluate Expression to true Memoization: Using Map -> Giving TLE on GFG (Will Update if found better)](evaluate_expression_to_true_memoization_using_map.cpp) 75 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=40) 76 | - To Solve these problem on GFG [Click Here.](https://practice.geeksforgeeks.org/problems/boolean-parenthesization/0) 77 | - [Evaluate Expression to true Memoization: Using 3d Array](evaluate_expression_to_true_memoization_using_3d_array.cpp) 78 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=40) 79 | - [Scramble String Recursive](scramble_strings.cpp) 80 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=41) 81 | - [Scramble String Memoization](scramble_strings_memoization.cpp) 82 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=42) 83 | - To Solve these problem on leetcode [Click Here.](https://leetcode.com/problems/scramble-string/) 84 | - [Egg Dropping Problem Recursive](egg_dropping_problem_recursive.cpp) 85 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=43) 86 | - [Egg Dropping Problem Memoization](egg_dropping_problem_memoization.cpp) 87 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=44) 88 | - [Egg Dropping Problem Memoization Optimization - As suggested in lectures](egg_dropping_problem_memoized_optimization.cpp) 89 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=45) 90 | - To Solve these problem on GFG [Click Here.](https://practice.geeksforgeeks.org/problems/egg-dropping-puzzle-1587115620/1) 91 | - [Egg Dropping Problem Optimization Using Concept of Binary Search - Accepted on Leetcode (Credits: Comment below video)](egg_dropping_problem_optimized_for_leetcode.cpp) 92 | - To Solve these problem on leetcode [Click Here.](https://leetcode.com/problems/super-egg-drop/) 93 | - **DP on Trees (Direct Solutions to leetcode / gfg problems)** 94 | - [Diameter of Binary Tree](diameter_of_binary_tree.cpp) 95 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=48) 96 | - To Solve these problem on leetcode [Click Here.](https://leetcode.com/problems/diameter-of-binary-tree/) 97 | - [Maximum path sum (from any node to any node)](max_path_sum_from_any_node_to_any.cpp) 98 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=49) 99 | - To Solve these problem on leetcode [Click Here.](https://leetcode.com/problems/binary-tree-maximum-path-sum/) 100 | - [Maximum path sum from leaf to leaf](max_path_sum_from_leaf_to_leaf.cpp) 101 | - [Video Link](https://www.youtube.com/watch?v=ot_XBHyqpFc&list=PL_z_8CaSLPWekqhdCPmFohncHwz8TY2Go&index=50) 102 | - To Solve these problem on GFG [Click Here.](https://practice.geeksforgeeks.org/problems/maximum-path-sum/1) 103 | -------------------------------------------------------------------------------- /SCS.cpp: -------------------------------------------------------------------------------- 1 | // Shortest Common Supersequence 2 | #include 3 | using namespace std; 4 | 5 | int LCS(string X, string Y, int n, int m) { 6 | int dp[n + 1][m + 1]; // DP - matrix 7 | 8 | // base case of recursion --> for initialization of dp - matrix 9 | for (int i = 0; i <= n; i++) 10 | for (int j = 0; j <= m; j++) 11 | if (i == 0 || j == 0) 12 | dp[i][j] = 0; 13 | 14 | for (int i = 1; i <= n; i++) 15 | for (int j = 1; j <= m; j++) 16 | if (X[i - 1] == Y[j - 1]) // when last character is same 17 | dp[i][j] = 1 + dp[i - 1][j - 1]; 18 | else // when last character is not same -> pick max 19 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 20 | 21 | return dp[n][m]; 22 | } 23 | 24 | int SCS(string X, string Y, int n, int m) { 25 | return m + n - LCS(X, Y, n, m); 26 | } 27 | 28 | signed main() { 29 | string X, Y; cin >> X >> Y; 30 | int n = X.length(), m = Y.length(); 31 | 32 | cout << SCS(X, Y, n, m) << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /coin_change_max_ways.cpp: -------------------------------------------------------------------------------- 1 | // Unbounded Knapsack -> Coin Change - I (max number of ways) 2 | 3 | #include 4 | using namespace std; 5 | 6 | int getMaxNumberOfWays(int coins[], int n, int sum) { 7 | int t[n + 1][sum + 1]; 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = 0; 13 | if (j == 0) 14 | t[i][j] = 1; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; i++) 19 | for (int j = 1; j <= sum; j++) 20 | if (coins[i - 1] <= j) 21 | t[i][j] = t[i - 1][j] + t[i][j - coins[i - 1]]; 22 | else 23 | t[i][j] = t[i - 1][j]; 24 | 25 | return t[n][sum]; 26 | } 27 | 28 | signed main() { 29 | int n; cin >> n; 30 | int coins[n]; 31 | for (int i = 0; i < n; i++) 32 | cin >> coins[i]; 33 | int sum; cin >> sum; 34 | 35 | cout << getMaxNumberOfWays(coins, n, sum) << endl; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /coin_change_min_coins.cpp: -------------------------------------------------------------------------------- 1 | // Unbounded Knapsack -> Coin Change - II (min number of coins) 2 | 3 | #include 4 | using namespace std; 5 | #define INF INT_MAX-1 6 | 7 | int getMinNumberOfCoins(int coins[], int n, int sum) { 8 | int t[n + 1][sum + 1]; 9 | // initialization 10 | for (int i = 0; i <= n; i++) { 11 | for (int j = 0; j <= sum; j++) { 12 | if (j == 0) 13 | t[i][j] = 0; 14 | if (i == 0) 15 | t[i][j] = INF; 16 | if (i == 1) { 17 | if (j % coins[i - 1] == 0) 18 | t[i][j] = j / coins[i - 1]; 19 | else 20 | t[i][j] = INF; 21 | } 22 | } 23 | } 24 | 25 | t[0][0] = 0; 26 | 27 | for (int i = 1; i <= n; i++) 28 | for (int j = 1; j <= sum; j++) 29 | if (coins[i - 1] <= j) 30 | t[i][j] = min(t[i - 1][j], 1 + t[i][j - coins[i - 1]]); 31 | else 32 | t[i][j] = t[i - 1][j]; 33 | 34 | return t[n][sum]; 35 | } 36 | 37 | signed main() { 38 | int n; cin >> n; 39 | int coins[n]; 40 | for (int i = 0; i < n; i++) 41 | cin >> coins[i]; 42 | int sum; cin >> sum; 43 | 44 | cout << getMinNumberOfCoins(coins, n, sum) << endl; 45 | return 0; 46 | } -------------------------------------------------------------------------------- /count_of_subset_with_given_diff.cpp: -------------------------------------------------------------------------------- 1 | // Count of Subsets with given Sum 2 | 3 | #include 4 | using namespace std; 5 | 6 | int CountSubsetsWithSum(int arr[], int n, int sum) { 7 | int t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = 0; 13 | if (j == 0) 14 | t[i][j] = 1; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; i++) { 19 | for (int j = 1; j <= sum; j++) { 20 | if (arr[i - 1] <= j) 21 | t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; 22 | else 23 | t[i][j] = t[i - 1][j]; 24 | } 25 | } 26 | 27 | return t[n][sum]; 28 | } 29 | 30 | int CountSubsetsWithDiff(int arr[], int n, int diff) { 31 | int sumOfArray = 0; 32 | for (int i = 0; i < n; i++) 33 | sumOfArray += arr[i]; 34 | 35 | if ((sumOfArray + diff) % 2 != 0) 36 | return 0; 37 | else 38 | return CountSubsetsWithSum(arr, n, (sumOfArray + diff) / 2); 39 | } 40 | 41 | signed main() { 42 | int n; cin >> n; 43 | int arr[n]; 44 | for (int i = 0; i < n; i++) 45 | cin >> arr[i]; 46 | int diff; cin >> diff; 47 | 48 | cout << CountSubsetsWithDiff(arr, n, diff) << endl; 49 | return 0; 50 | } -------------------------------------------------------------------------------- /count_of_subsets_with_given_sum.cpp: -------------------------------------------------------------------------------- 1 | // Count of Subsets with given Sum 2 | 3 | #include 4 | using namespace std; 5 | 6 | int CountSubsets(int arr[], int n, int sum) { 7 | int t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = 0; 13 | if (j == 0) 14 | t[i][j] = 1; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; i++) { 19 | for (int j = 1; j <= sum; j++) { 20 | if (arr[i - 1] <= j) 21 | t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; 22 | else 23 | t[i][j] = t[i - 1][j]; 24 | } 25 | } 26 | 27 | return t[n][sum]; 28 | } 29 | 30 | signed main() { 31 | int n; cin >> n; 32 | int arr[n]; 33 | for (int i = 0; i < n; i++) 34 | cin >> arr[i]; 35 | int sum; cin >> sum; 36 | 37 | cout << CountSubsets(arr, n, sum) << endl; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /diameter_of_binary_tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | private: 14 | int res; 15 | public: 16 | int Solve(TreeNode* root) { 17 | if (root == NULL) 18 | return 0; 19 | 20 | int l = Solve(root->left); 21 | int r = Solve(root->right); 22 | 23 | int temp = 1 + max(l, r); 24 | int ans = max(temp, l + r + 1); 25 | res = max(res, ans); 26 | return temp; 27 | } 28 | int diameterOfBinaryTree(TreeNode* root) { 29 | if (root == NULL) 30 | return 0; 31 | 32 | res = INT_MIN + 1; 33 | Solve(root); 34 | return res - 1; 35 | } 36 | }; -------------------------------------------------------------------------------- /egg_dropping_problem_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 101; 5 | int t[D][D]; 6 | 7 | int Solve(int eggs, int floors) { 8 | if (t[eggs][floors] != -1) 9 | return t[eggs][floors]; 10 | 11 | if (eggs == 1 || floors == 0 || floors == 1) { 12 | t[eggs][floors] = floors; 13 | return floors; 14 | } 15 | 16 | int mn = INT_MAX; 17 | for (int k = 1; k <= floors; k++) { 18 | int temp_ans = 1 + max(Solve(eggs - 1, k - 1), Solve(eggs, floors - k)); 19 | mn = min(mn, temp_ans); 20 | } 21 | 22 | return t[eggs][floors] = mn; 23 | } 24 | 25 | signed main() { 26 | int eggs, floors; 27 | cin >> eggs >> floors; 28 | 29 | memset(t, -1, sizeof(t)); 30 | 31 | cout << Solve(eggs, floors) << endl; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /egg_dropping_problem_memoized_optimization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 101; 5 | int dp[D][D]; 6 | 7 | int Solve(int eggs, int floors) { 8 | if (dp[eggs][floors] != -1) 9 | return dp[eggs][floors]; 10 | 11 | if (eggs == 1 || floors == 0 || floors == 1) { 12 | dp[eggs][floors] = floors; 13 | return floors; 14 | } 15 | 16 | int mn = INT_MAX; 17 | for (int k = 1; k <= floors; k++) { 18 | int top, bottom; 19 | if (dp[eggs - 1][k - 1] != -1) 20 | top = dp[eggs - 1][k - 1]; 21 | else { 22 | top = Solve(eggs - 1, k - 1); 23 | dp[eggs - 1][k - 1] = top; 24 | } 25 | 26 | if (dp[eggs][floors - k] != -1) 27 | bottom = dp[eggs][floors - k]; 28 | else { 29 | bottom = Solve(eggs, floors - k); 30 | dp[eggs][floors - k] = bottom; 31 | } 32 | int temp_ans = 1 + max(top, bottom); 33 | mn = min(mn, temp_ans); 34 | } 35 | 36 | return dp[eggs][floors] = mn; 37 | } 38 | 39 | signed main() { 40 | int eggs, floors; 41 | cin >> eggs >> floors; 42 | 43 | memset(dp, -1, sizeof(dp)); 44 | 45 | cout << Solve(eggs, floors) << endl; 46 | return 0; 47 | } -------------------------------------------------------------------------------- /egg_dropping_problem_optimized_for_leetcode.cpp: -------------------------------------------------------------------------------- 1 | 2 | class Solution { 3 | int dp[107][10007]; 4 | public: 5 | int Solve(int eggs, int floors) { 6 | if (dp[eggs][floors] != -1) 7 | return dp[eggs][floors]; 8 | 9 | if (eggs == 1 || floors == 0 || floors == 1) { 10 | dp[eggs][floors] = floors; 11 | return floors; 12 | } 13 | 14 | int ans = floors; 15 | int low = 1, high = floors; 16 | while (low <= high) { 17 | int mid = low + (high - low) / 2; 18 | int bottom = Solve(eggs - 1, mid - 1); // egg broke 19 | int top = Solve(eggs, floors - mid); // egg doesn't broke 20 | int temp = 1 + max(top, bottom); // max for worst case 21 | if (bottom < top) // go upward for worst case 22 | low = mid + 1; 23 | else // go downward for worst case 24 | high = mid - 1; 25 | 26 | ans = min(ans, temp); 27 | } 28 | 29 | return dp[eggs][floors] = ans; 30 | } 31 | int superEggDrop(int K, int N) { 32 | memset(dp, -1, sizeof(dp)); 33 | return Solve(K, N); 34 | } 35 | }; -------------------------------------------------------------------------------- /egg_dropping_problem_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(int eggs, int floors) { 5 | if (eggs == 1) 6 | return floors; 7 | if (floors == 0 || floors == 1) 8 | return floors; 9 | 10 | int mn = INT_MAX; 11 | for (int k = 1; k <= floors; k++) { 12 | int temp_ans = 1 + max(Solve(eggs - 1, k - 1), Solve(eggs, floors - k)); 13 | mn = min(mn, temp_ans); 14 | } 15 | 16 | return mn; 17 | } 18 | 19 | signed main() { 20 | int eggs, floors; 21 | cin >> eggs >> floors; 22 | 23 | cout << Solve(eggs, floors) << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /equal_sum_partition_problem.cpp: -------------------------------------------------------------------------------- 1 | // Equal sum Partition Problem 2 | 3 | #include 4 | using namespace std; 5 | 6 | bool isSubsetPoss(int arr[], int n, int sum) { 7 | bool t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = false; 13 | if (j == 0) 14 | t[i][j] = true; 15 | } 16 | } 17 | 18 | 19 | for (int i = 1; i <= n; i++) { 20 | for (int j = 1; j <= sum; j++) { 21 | if (arr[i - 1] <= j) 22 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; 23 | else 24 | t[i][j] = t[i - 1][j]; 25 | } 26 | } 27 | 28 | return t[n][sum]; 29 | } 30 | 31 | bool EqualSumPartitionPossible(int arr[], int n) { 32 | int sum = 0; // sum of all elements of arr 33 | for (int i = 0; i < n; i++) 34 | sum += arr[i]; 35 | 36 | if (sum % 2 != 0) // if sum is odd --> not possible to make equal partitions 37 | return false; 38 | 39 | return isSubsetPoss(arr, n, sum / 2); 40 | } 41 | 42 | signed main() { 43 | int n; cin >> n; 44 | int arr[n]; 45 | for (int i = 0; i < n; i++) 46 | cin >> arr[i]; 47 | 48 | EqualSumPartitionPossible(arr, n) ? cout << "YES\n" : cout << "NO\n"; 49 | return 0; 50 | } -------------------------------------------------------------------------------- /evaluate_expression_to_true.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(string X, int i, int j, bool isTrue) { 5 | if (i >= j) { 6 | if (isTrue) 7 | return X[i] == 'T'; 8 | else 9 | return X[i] == 'F'; 10 | } 11 | 12 | int ans = 0; 13 | for (int k = i + 1; k < j; k += 2) { 14 | int l_T = Solve(X, i, k - 1, true); 15 | int l_F = Solve(X, i, k - 1, false); 16 | int r_T = Solve(X, k + 1, j, true); 17 | int r_F = Solve(X, k + 1, j, false); 18 | 19 | if (X[k] == '|') { 20 | if (isTrue == true) 21 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 22 | else 23 | ans += l_F * r_F; 24 | } 25 | else if (X[k] == '&') { 26 | if (isTrue == true) 27 | ans += l_T * r_T; 28 | else 29 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 30 | } 31 | else if (X[k] == '^') { 32 | if (isTrue == true) 33 | ans += l_T * r_F + l_F * r_T; 34 | else 35 | ans += l_T * r_T + l_F * r_F; 36 | } 37 | 38 | } 39 | 40 | return ans; 41 | } 42 | 43 | signed main() { 44 | string X; cin >> X; 45 | cout << Solve(X, 0, X.length() - 1, true) << endl; 46 | return 0; 47 | } -------------------------------------------------------------------------------- /evaluate_expression_to_true_bottom_up_dp_using_3d_array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(string X, int n) { 5 | int dp[n + 1][n + 1]; 6 | 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= n; j++) { 9 | if (i >= j) { 10 | dp[true][i][j] = (X[i] == 'T'); 11 | dp[false][i][j] = (X[i] == 'F'); 12 | } 13 | } 14 | } 15 | 16 | for (int i = 0; i < n; i += 2) { 17 | for (int j = i; j < n; j += 2) { 18 | if (i == j) 19 | dp[true][i][j] = (X[i] == 'T'); 20 | else { 21 | for (int k = i + 1; k <= j; k += 2) { 22 | int l_T = dp[true][i][k - 1]; 23 | int r_T = dp[true][k + 1][j]; 24 | } 25 | } 26 | } 27 | } 28 | 29 | for (int i = 0; i < n; i++) { 30 | for (int j = i; j < n; j++) { 31 | for (int k = i + 1; k < j; k += 2) { 32 | int l_T = dp[true][i][k - 1]; 33 | int l_F = dp[false][i][k - 1]; 34 | int r_T = dp[true][k + 1][j]; 35 | int r_F = dp[false][k + 1][j]; 36 | 37 | if (X[k] == '|') { 38 | if (isTrue == true) 39 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 40 | else 41 | ans += l_F * r_F; 42 | } 43 | else if (X[k] == '&') { 44 | if (isTrue == true) 45 | ans += l_T * r_T; 46 | else 47 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 48 | } 49 | else if (X[k] == '^') { 50 | if (isTrue == true) 51 | ans += l_T * r_F + l_F * r_T; 52 | else 53 | ans += l_T * r_T + l_F * r_F; 54 | } 55 | } 56 | } 57 | } 58 | 59 | return dp[1][1][n]; 60 | } 61 | 62 | signed main() { 63 | #ifndef ONLINE_JUDGE 64 | freopen("../input1.txt", "r", stdin); 65 | freopen("../output1.txt", "w", stdout); 66 | #endif 67 | 68 | string X; cin >> X; 69 | 70 | memset(dp[0], -1, sizeof(dp[0])); 71 | memset(dp[1], -1, sizeof(dp[1])); 72 | 73 | cout << Solve(X, X.length()) << endl; 74 | return 0; 75 | } -------------------------------------------------------------------------------- /evaluate_expression_to_true_memoization_using_3d_array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int dp[2][D][D]; 6 | 7 | int Solve(string X, int i, int j, bool isTrue) { 8 | if (i >= j) { 9 | if (isTrue) 10 | dp[1][i][j] = X[i] == 'T'; 11 | else 12 | dp[0][i][j] = X[i] == 'F'; 13 | return dp[isTrue][i][j]; 14 | } 15 | 16 | if (dp[isTrue][i][j] != -1) 17 | return dp[isTrue][i][j]; 18 | 19 | int ans = 0; 20 | for (int k = i + 1; k < j; k += 2) { 21 | int l_T = Solve(X, i, k - 1, true); 22 | int l_F = Solve(X, i, k - 1, false); 23 | int r_T = Solve(X, k + 1, j, true); 24 | int r_F = Solve(X, k + 1, j, false); 25 | 26 | if (X[k] == '|') { 27 | if (isTrue == true) 28 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 29 | else 30 | ans += l_F * r_F; 31 | } 32 | else if (X[k] == '&') { 33 | if (isTrue == true) 34 | ans += l_T * r_T; 35 | else 36 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 37 | } 38 | else if (X[k] == '^') { 39 | if (isTrue == true) 40 | ans += l_T * r_F + l_F * r_T; 41 | else 42 | ans += l_T * r_T + l_F * r_F; 43 | } 44 | 45 | } 46 | 47 | dp[isTrue][i][j] = ans; 48 | 49 | return ans; 50 | } 51 | 52 | signed main() { 53 | string X; cin >> X; 54 | 55 | memset(dp[0], -1, sizeof(dp[0])); 56 | memset(dp[1], -1, sizeof(dp[1])); 57 | 58 | cout << Solve(X, 0, X.length() - 1, true) << endl; 59 | return 0; 60 | } -------------------------------------------------------------------------------- /evaluate_expression_to_true_memoization_using_map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map ump; 5 | 6 | int Solve(string X, int i, int j, bool isTrue) { 7 | string key = to_string(i) + " " + to_string(j) + " " + (isTrue ? "T" : "F"); 8 | 9 | if (ump.find(key) != ump.end()) 10 | return ump[key]; 11 | 12 | if (i >= j) { 13 | if (isTrue) 14 | ump[key] = X[i] == 'T'; 15 | else 16 | ump[key] = X[i] == 'F'; 17 | return ump[key]; 18 | } 19 | 20 | int ans = 0; 21 | for (int k = i + 1; k < j; k += 2) { 22 | int l_T = Solve(X, i, k - 1, true); 23 | int l_F = Solve(X, i, k - 1, false); 24 | int r_T = Solve(X, k + 1, j, true); 25 | int r_F = Solve(X, k + 1, j, false); 26 | 27 | if (X[k] == '|') { 28 | if (isTrue == true) 29 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 30 | else 31 | ans += l_F * r_F; 32 | } 33 | else if (X[k] == '&') { 34 | if (isTrue == true) 35 | ans += l_T * r_T; 36 | else 37 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 38 | } 39 | else if (X[k] == '^') { 40 | if (isTrue == true) 41 | ans += l_T * r_F + l_F * r_T; 42 | else 43 | ans += l_T * r_T + l_F * r_F; 44 | } 45 | 46 | } 47 | 48 | return ump[key] = ans; 49 | } 50 | 51 | signed main() { 52 | string X; cin >> X; 53 | ump.clear(); 54 | cout << Solve(X, 0, X.length() - 1, true) << endl; 55 | return 0; 56 | } -------------------------------------------------------------------------------- /knapsack_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1000; // DP - matrix dimension 5 | 6 | int t[D][D]; // DP matrix 7 | 8 | int Knapsack(int wt[], int val[], int W, int n) { 9 | // base case 10 | if (n == 0 || W == 0) 11 | return 0; 12 | 13 | // if already calculated 14 | if (t[n][W] != -1) 15 | return t[n][W]; 16 | // else calculate 17 | else { 18 | if (wt[n - 1] <= W) 19 | t[n][W] = max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1), 20 | Knapsack(wt, val, W, n - 1)); 21 | else if (wt[n - 1] > W) 22 | t[n][W] = Knapsack(wt, val, W, n - 1); 23 | 24 | return t[n][W]; 25 | } 26 | } 27 | 28 | signed main() { 29 | int n; cin >> n; // number of items 30 | int val[n], wt[n]; // values and wts array 31 | for (int i = 0; i < n; i++) 32 | cin >> wt[i]; 33 | for (int i = 0; i < n; i++) 34 | cin >> val[i]; 35 | int W; cin >> W; // capacity 36 | 37 | // matrix initialization 38 | for (int i = 0; i <= n; i++) 39 | for (int j = 0; j <= W; j++) 40 | t[i][j] = -1; 41 | 42 | cout << Knapsack(wt, val, W, n) << endl; 43 | return 0; 44 | } -------------------------------------------------------------------------------- /knapsack_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int Knapsack(int wt[], int val[], int W, int n) { 6 | // base case 7 | if (n == 0 || W == 0) 8 | return 0; 9 | 10 | // recursive cases 11 | if (wt[n - 1] <= W) { 12 | return max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1), 13 | Knapsack(wt, val, W, n - 1)); 14 | } 15 | else if (wt[n - 1] > W) 16 | return Knapsack(wt, val, W, n - 1); 17 | else 18 | return -1; // to avoid warning 19 | } 20 | 21 | signed main() { 22 | int n; cin >> n; // number of items 23 | int val[n], wt[n]; // values and wts array 24 | for (int i = 0; i < n; i++) 25 | cin >> wt[i]; 26 | for (int i = 0; i < n; i++) 27 | cin >> val[i]; 28 | int W; cin >> W; // Knappsack capacity 29 | 30 | cout << Knapsack(wt, val, W, n) << endl; 31 | return 0; 32 | } -------------------------------------------------------------------------------- /knapsack_top_down_dp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Knapsack(int wt[], int val[], int W, int n) { 5 | int t[n + 1][W + 1]; // DP matrix 6 | 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= W; j++) { 9 | if (i == 0 || j == 0) // base case 10 | t[i][j] = 0; 11 | else if (wt[i - 1] <= j) { // current wt can fit in bag 12 | int val1 = val[i - 1] + t[i - 1][j - wt[i - 1]]; // take current wt 13 | int val2 = t[i - 1][j]; // skip current wt 14 | t[i][j] = max(val1, val2); 15 | } 16 | else if (wt[i - 1] > j) // current wt doesn't fit in bag 17 | t[i][j] = t[i - 1][j]; 18 | } 19 | } 20 | 21 | return t[n][W]; 22 | } 23 | 24 | signed main() { 25 | int n; cin >> n; // number of items 26 | int val[n], wt[n]; // values and wts array 27 | for (int i = 0; i < n; i++) 28 | cin >> wt[i]; 29 | for (int i = 0; i < n; i++) 30 | cin >> val[i]; 31 | int W; cin >> W; // capacity 32 | 33 | cout << Knapsack(wt, val, W, n) << endl; 34 | return 0; 35 | } -------------------------------------------------------------------------------- /longest_pallin_subseq.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | int LPS(string X, int n) { 24 | string rev_X = X; 25 | reverse(rev_X.begin(), rev_X.end()); 26 | return LCS(X, rev_X, n, n); 27 | } 28 | 29 | signed main() { 30 | string X, Y; cin >> X; 31 | int n = X.length(); 32 | 33 | cout << LPS(X, n) << endl; 34 | return 0; 35 | } -------------------------------------------------------------------------------- /longest_repeating_subseq.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | for (int i = 0; i <= n; i++) 8 | for (int j = 0; j <= m; j++) 9 | if (i == 0 || j == 0) 10 | dp[i][j] = 0; 11 | 12 | for (int i = 1; i <= n; i++) 13 | for (int j = 1; j <= m; j++) 14 | if (X[i - 1] == Y[j - 1] && i != j) 15 | dp[i][j] = 1 + dp[i - 1][j - 1]; 16 | else 17 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 18 | 19 | return dp[n][m]; 20 | } 21 | 22 | signed main() { 23 | string X; cin >> X; 24 | int n = X.length(); 25 | 26 | cout << LCS(X, X, n, n) << endl; 27 | return 0; 28 | } -------------------------------------------------------------------------------- /max_path_sum_from_any_node_to_any.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | private: 14 | int res; 15 | public: 16 | int Solve(TreeNode* root) { 17 | if (root == NULL) 18 | return 0; 19 | 20 | int l = Solve(root->left); 21 | int r = Solve(root->right); 22 | 23 | int temp = max(root->val + max(l, r), root->val); 24 | int ans = max(temp, l + r + root->val); 25 | res = max(res, ans); 26 | 27 | return temp; 28 | } 29 | int maxPathSum(TreeNode* root) { 30 | res = INT_MIN; 31 | Solve(root); 32 | return res; 33 | } 34 | }; -------------------------------------------------------------------------------- /max_path_sum_from_leaf_to_leaf.cpp: -------------------------------------------------------------------------------- 1 | int res; 2 | 3 | int Solve(Node* root) { 4 | if (root == NULL) 5 | return 0; 6 | 7 | int l = Solve(root->left); 8 | int r = Solve(root->right); 9 | 10 | int temp; 11 | if (root->left && root->right) { 12 | res = max(res, l + r + root->data); 13 | temp = root->data + max(l, r); 14 | } 15 | else if (root->left) 16 | temp = root->data + l; 17 | else if (root->right) 18 | temp = root->data + r; 19 | else 20 | temp = root->data; 21 | 22 | 23 | return temp; 24 | } 25 | 26 | int maxPathSum(Node* root) 27 | { 28 | // code here 29 | res = INT_MIN; 30 | Solve(root); 31 | return res; 32 | } -------------------------------------------------------------------------------- /min_del_to_make_pallindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | int LPS(string X, int n) { 24 | string rev_X = X; 25 | reverse(rev_X.begin(), rev_X.end()); 26 | return LCS(X, rev_X, n, n); 27 | } 28 | 29 | int MinDelForPallindrome(string X, int n) { 30 | return n - LPS(X, n); 31 | } 32 | 33 | signed main() { 34 | string X, Y; cin >> X; 35 | int n = X.length(); 36 | 37 | cout << MinDelForPallindrome(X, n) << endl; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /min_insertion_del__to_convert_a_to_b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | int MinInsertDel(string X, string Y, int n, int m) { 24 | int lcs_len = LCS(X, Y, n, m); 25 | return m + n - 2 * lcs_len; 26 | } 27 | 28 | signed main() { 29 | string X, Y; cin >> X >> Y; 30 | int n = X.length(), m = Y.length(); 31 | 32 | cout << MinInsertDel(X, Y, n, m) << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /min_insertion_to_make_string_pallindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | int LPS(string X, int n) { 24 | string rev_X = X; 25 | reverse(rev_X.begin(), rev_X.end()); 26 | return LCS(X, rev_X, n, n); 27 | } 28 | 29 | int MinInsertForPallindrome(string X, int n) { 30 | return n - LPS(X, n); 31 | } 32 | 33 | signed main() { 34 | string X, Y; cin >> X; 35 | int n = X.length(); 36 | 37 | cout << MinInsertForPallindrome(X, n) << endl; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /min_subset_sum_diff.cpp: -------------------------------------------------------------------------------- 1 | // Min Subset Sum Difference 2 | 3 | #include 4 | using namespace std; 5 | 6 | vector isSubsetPoss(int arr[], int n, int sum) { 7 | bool t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = false; 13 | if (j == 0) 14 | t[i][j] = true; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; i++) { 19 | for (int j = 1; j <= sum; j++) { 20 | if (arr[i - 1] <= j) 21 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; 22 | else 23 | t[i][j] = t[i - 1][j]; 24 | } 25 | } 26 | 27 | vector v; // contains all subset sums possible with n elements 28 | for (int j = 0; j <= sum; j++) 29 | if (t[n][j] == true) 30 | v.push_back(j); 31 | 32 | return v; 33 | } 34 | 35 | int MinSubsetSumDiff(int arr[], int n) { 36 | int range = 0; 37 | for (int i = 0; i < n; i++) 38 | range += arr[i]; 39 | 40 | vector v = isSubsetPoss(arr, n, range); 41 | int mn = INT_MAX; 42 | for (int i = 0; i < v.size(); i++) 43 | mn = min(mn, abs(range - 2 * v[i])); 44 | 45 | return mn; 46 | } 47 | 48 | signed main() { 49 | int n; cin >> n; 50 | int arr[n]; 51 | for (int i = 0; i < n; i++) 52 | cin >> arr[i]; 53 | 54 | cout << MinSubsetSumDiff(arr, n) << endl; 55 | return 0; 56 | } -------------------------------------------------------------------------------- /pallindrome_partitioning_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int t[D][D]; 6 | 7 | bool isPallindrome(string X, int i, int j) { 8 | while (i <= j) { 9 | if (X[i] != X[j]) 10 | return false; 11 | i++, j--; 12 | } 13 | 14 | return true; 15 | } 16 | 17 | int Solve(string X, int i, int j) { 18 | if (i >= j || isPallindrome(X, i, j)) { 19 | t[i][j] = 0; 20 | return 0; 21 | } 22 | 23 | if (t[i][j] != -1) 24 | return t[i][j]; 25 | 26 | int ans = INT_MAX; 27 | for (int k = i; k < j; k++) { 28 | int temp_ans = Solve(X, i, k) + Solve(X, k + 1, j) + 1; 29 | ans = min(ans, temp_ans); 30 | } 31 | 32 | return t[i][j] = ans; 33 | } 34 | 35 | int main() { 36 | string X; cin >> X; 37 | 38 | memset(t, -1, sizeof(t)); 39 | 40 | cout << Solve(X, 0, X.length() - 1) << endl; 41 | return 0; 42 | } -------------------------------------------------------------------------------- /pallindrome_partitioning_memoized_optimization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int t[D][D]; 6 | 7 | bool isPallindrome(string X, int i, int j) { 8 | while (i <= j) { 9 | if (X[i] != X[j]) 10 | return false; 11 | i++, j--; 12 | } 13 | 14 | return true; 15 | } 16 | 17 | int Solve(string X, int i, int j) { 18 | if (t[i][j] != -1) 19 | return t[i][j]; 20 | 21 | if (i >= j || isPallindrome(X, i, j)) { 22 | t[i][j] = 0; 23 | return 0; 24 | } 25 | 26 | int ans = INT_MAX; 27 | for (int k = i; k < j; k++) { 28 | int left, right; 29 | if (t[i][k] == -1) 30 | left = Solve(X, i, k); 31 | else 32 | left = t[i][k]; 33 | 34 | if (t[k + 1][j] == -1) 35 | right = Solve(X, k + 1, j); 36 | else 37 | right = t[k + 1][j]; 38 | 39 | int temp_ans = left + right + 1; 40 | ans = min(ans, temp_ans); 41 | } 42 | 43 | return t[i][j] = ans; 44 | } 45 | 46 | int main() { 47 | string X; cin >> X; 48 | 49 | memset(t, -1, sizeof(t)); 50 | 51 | cout << Solve(X, 0, X.length() - 1) << endl; 52 | return 0; 53 | } -------------------------------------------------------------------------------- /pallindrome_partitioning_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool isPallindrome(string X, int i, int j) { 5 | while (i <= j) { 6 | if (X[i] != X[j]) 7 | return false; 8 | i++, j--; 9 | } 10 | 11 | return true; 12 | } 13 | 14 | int Solve(string X, int i, int j) { 15 | if (i >= j || isPallindrome(X, i, j)) 16 | return 0; 17 | 18 | int ans = INT_MAX; 19 | for (int k = i; k < j; k++) { 20 | int temp_ans = Solve(X, i, k) + Solve(X, k + 1, j) + 1; 21 | ans = min(ans, temp_ans); 22 | } 23 | 24 | return ans; 25 | } 26 | 27 | int main() { 28 | string X; cin >> X; 29 | 30 | cout << Solve(X, 0, X.length() - 1) << endl; 31 | return 0; 32 | } -------------------------------------------------------------------------------- /print_LCS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | int i = n, j = m; 21 | string lcs = ""; 22 | while (i > 0 && j > 0) { 23 | if (X[i - 1] == Y[j - 1]) { 24 | lcs += X[i - 1]; 25 | i--, j--; 26 | } 27 | else { 28 | if (dp[i][j - 1] > dp[i - 1][j]) 29 | j--; 30 | else 31 | i--; 32 | } 33 | } 34 | reverse(lcs.begin(), lcs.end()); 35 | 36 | return lcs; 37 | } 38 | 39 | signed main() { 40 | string X, Y; cin >> X >> Y; 41 | int n = X.length(), m = Y.length(); 42 | 43 | cout << LCS(X, Y, n, m) << endl; 44 | return 0; 45 | } -------------------------------------------------------------------------------- /print_SCS.cpp: -------------------------------------------------------------------------------- 1 | // Shortest Common Supersequence 2 | #include 3 | using namespace std; 4 | 5 | string SCS(string X, string Y, int n, int m) { 6 | int dp[n + 1][m + 1]; // DP - matrix 7 | 8 | // base case of recursion --> for initialization of dp - matrix 9 | for (int i = 0; i <= n; i++) 10 | for (int j = 0; j <= m; j++) 11 | if (i == 0 || j == 0) 12 | dp[i][j] = 0; 13 | 14 | for (int i = 1; i <= n; i++) 15 | for (int j = 1; j <= m; j++) 16 | if (X[i - 1] == Y[j - 1]) // when last character is same 17 | dp[i][j] = 1 + dp[i - 1][j - 1]; 18 | else // when last character is not same -> pick max 19 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 20 | 21 | int i = n, j = m; 22 | string scs = ""; 23 | while (i > 0 && j > 0) { 24 | if (X[i - 1] == Y[j - 1]) { 25 | scs += X[i - 1]; 26 | i--, j--; 27 | } 28 | else if (dp[i][j - 1] > dp[i - 1][j]) { 29 | scs += Y[j - 1]; 30 | j--; 31 | } 32 | else { 33 | scs += X[i - 1]; 34 | i--; 35 | } 36 | } 37 | 38 | while (i > 0) { 39 | scs += X[i - 1]; 40 | i--; 41 | } 42 | 43 | while (j > 0) { 44 | scs += Y[j - 1]; 45 | j--; 46 | } 47 | 48 | reverse(scs.begin(), scs.end()); 49 | 50 | return scs; 51 | } 52 | 53 | signed main() { 54 | string X, Y; cin >> X >> Y; 55 | int n = X.length(), m = Y.length(); 56 | 57 | cout << SCS(X, Y, n, m) << endl; 58 | return 0; 59 | } -------------------------------------------------------------------------------- /rod_cutting_problem.cpp: -------------------------------------------------------------------------------- 1 | // Rod Cutting Problem 2 | 3 | #include 4 | using namespace std; 5 | 6 | int getMaxProfit(int length[], int price[], int n, int L) { 7 | int dp[n + 1][L + 1]; 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= L; j++) 10 | if (j == 0 || i == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) { 14 | for (int j = 1; j <= L; j++) { 15 | if (length[i - 1] <= j) { 16 | dp[i][j] = max(dp[i - 1][j], 17 | price[i - 1] + dp[i][j - length[i - 1]]); 18 | } 19 | else 20 | dp[i][j] = dp[i - 1][j]; 21 | } 22 | } 23 | 24 | return dp[n][L]; 25 | } 26 | 27 | signed main() { 28 | int n; cin >> n; 29 | int length[n], price[n]; 30 | for (int i = 0; i < n; i++) 31 | cin >> length[i]; 32 | for (int i = 0; i < n; i++) 33 | cin >> price[i]; 34 | int L; cin >> L; 35 | 36 | cout << getMaxProfit(length, price, n, L) << endl; 37 | return 0; 38 | } -------------------------------------------------------------------------------- /scramble_strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool Solve(string X, string Y) { 5 | if (X.compare(Y) == 0) 6 | return true; 7 | if (X.length() <= 1) 8 | return false; 9 | 10 | int n = X.length(); 11 | int flag = false; 12 | for (int i = 1; i <= n - 1; i++) { 13 | if ((Solve(X.substr(0, i), Y.substr(n - i, i)) && Solve(X.substr(i), Y.substr(0, n - i))) || 14 | (Solve(X.substr(0, i), Y.substr(0, i)) && Solve(X.substr(i), Y.substr(i)))) { 15 | flag = true; 16 | break; 17 | } 18 | } 19 | 20 | return flag; 21 | } 22 | 23 | int main() { 24 | string X, Y; cin >> X >> Y; 25 | 26 | if (X.length() != Y.length()) 27 | cout << "No\n"; 28 | else 29 | Solve(X, Y) ? cout << "Yes\n" : cout << "No\n"; 30 | return 0; 31 | } -------------------------------------------------------------------------------- /scramble_strings_memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map ump; 5 | 6 | bool Solve(string X, string Y) { 7 | string key = X + " " + Y; 8 | if (ump.find(key) != ump.end()) 9 | return ump[key]; 10 | 11 | if (X.compare(Y) == 0) { 12 | ump[key] = true; 13 | return true; 14 | } 15 | if (X.length() <= 1) { 16 | ump[key] = false; 17 | return false; 18 | } 19 | 20 | int n = X.length(); 21 | int flag = false; 22 | for (int i = 1; i <= n - 1; i++) { 23 | if ((Solve(X.substr(0, i), Y.substr(n - i, i)) && Solve(X.substr(i), Y.substr(0, n - i))) || 24 | (Solve(X.substr(0, i), Y.substr(0, i)) && Solve(X.substr(i), Y.substr(i)))) { 25 | flag = true; 26 | break; 27 | } 28 | } 29 | 30 | return ump[key] = flag; 31 | } 32 | 33 | int main() { 34 | string X, Y; cin >> X >> Y; 35 | 36 | ump.clear(); 37 | 38 | if (X.length() != Y.length()) 39 | cout << "No\n"; 40 | else 41 | Solve(X, Y) ? cout << "Yes\n" : cout << "No\n"; 42 | return 0; 43 | } -------------------------------------------------------------------------------- /sequence_patttern_matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | bool SeqPatternMatching(string X, string Y, int n, int m) { 24 | return LCS(X, Y, n, m) == min(n, m); 25 | } 26 | 27 | signed main() { 28 | string X, Y; cin >> X >> Y; 29 | int n = X.length(), m = Y.length(); 30 | 31 | SeqPatternMatching(X, Y, n, m) ? "YES\n" : "NO\n"; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /subset_sum_problem_dp.cpp: -------------------------------------------------------------------------------- 1 | // Subset Sum problem 2 | 3 | #include 4 | using namespace std; 5 | 6 | bool isSubsetPoss(int arr[], int n, int sum) { 7 | bool t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | for (int i = 0; i <= n; i++) { 10 | for (int j = 0; j <= sum; j++) { 11 | if (i == 0) 12 | t[i][j] = false; 13 | if (j == 0) 14 | t[i][j] = true; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; i++) { 19 | for (int j = 1; j <= sum; j++) { 20 | if (arr[i - 1] <= j) 21 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; 22 | else 23 | t[i][j] = t[i - 1][j]; 24 | } 25 | } 26 | 27 | return t[n][sum]; 28 | } 29 | 30 | signed main() { 31 | int n; cin >> n; 32 | int arr[n]; 33 | for (int i = 0; i < n; i++) 34 | cin >> arr[i]; 35 | int sum; cin >> sum; 36 | 37 | isSubsetPoss(arr, n, sum) ? cout << "Yes\n" : cout << "No\n"; 38 | return 0; 39 | } -------------------------------------------------------------------------------- /target_sum.cpp: -------------------------------------------------------------------------------- 1 | // Target Sum 2 | 3 | #include 4 | using namespace std; 5 | 6 | int CountSubsetsWithSum(int arr[], int n, int sum) { 7 | int t[n + 1][sum + 1]; // DP - matrix 8 | // initialization 9 | t[0][0] = 1; 10 | int k = 1; 11 | for (int i = 0; i <= n; i++) { 12 | for (int j = 0; j <= sum; j++) { 13 | if (i == 0 && j > 0) 14 | t[i][j] = 0; 15 | if (j == 0 && i > 0) { 16 | if (arr[i - 1] == 0) { 17 | t[i][j] = pow(2, k); 18 | k++; 19 | } 20 | else 21 | t[i][j] = t[i - 1][j]; 22 | } 23 | } 24 | } 25 | 26 | for (int i = 1; i <= n; i++) { 27 | for (int j = 1; j <= sum; j++) { 28 | if (arr[i - 1] <= j) 29 | t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; 30 | else 31 | t[i][j] = t[i - 1][j]; 32 | } 33 | } 34 | 35 | return t[n][sum]; 36 | } 37 | 38 | int TargetSum(int arr[], int n, int diff) { 39 | int sumOfArray = 0; 40 | for (int i = 0; i < n; i++) 41 | sumOfArray += arr[i]; 42 | 43 | if ((sumOfArray + diff) % 2 != 0) 44 | return 0; 45 | else 46 | return CountSubsetsWithSum(arr, n, (sumOfArray + diff) / 2); 47 | } 48 | 49 | signed main() { 50 | int n; cin >> n; 51 | int arr[n]; 52 | for (int i = 0; i < n; i++) 53 | cin >> arr[i]; 54 | int sum; cin >> sum; 55 | 56 | cout << TargetSum(arr, n, sum) << endl; 57 | return 0; 58 | } --------------------------------------------------------------------------------