├── C++ Codes ├── O_N_knapsack.cpp ├── alphacode.cpp ├── auto_biographical_numbers.cpp ├── best_time_to_buy_and_sell_stock.cpp ├── bottom_up_vs_top_down.cpp ├── colorful_knapsack.cpp ├── company_queries_1.cpp ├── consecutive_sequence.cpp ├── countOrdered.cpp ├── countUnordered2.cpp ├── count_set_bits.cpp ├── count_unordered.cpp ├── diameter_code.cpp ├── distance_tree_1.cpp ├── edit_distance.cpp ├── elevator_problem_code.cpp ├── fibosum.cpp ├── fibosum_2.cpp ├── good sequences.cpp ├── hamiltonian_path_backtrack.cpp ├── hamiltonian_path_bottom_up.cpp ├── hamiltonian_path_recursive_memo.cpp ├── hamiltonian_path_using_bitmask.cpp ├── interleaving_strings.cpp ├── investigation_code.cpp ├── knapsack_recursion.cpp ├── knapsack_tabular.cpp ├── lids_todo.cpp ├── lis.cpp ├── lis_nlogn.cpp ├── longest_common_subsequence_unmemoised.cpp ├── magic_number.cpp ├── make_fence_great_again_recursive_memo.cpp ├── make_fence_great_again_tabulation.cpp ├── minimum_steps_to_reach_one.cpp ├── new.cpp ├── new2.cpp ├── no_consecutive_ones.cpp ├── optimal_selection.cpp ├── ordered_pair(code).cpp ├── paint_house.cpp ├── palindromic_partitioning.cpp ├── palindromic_partitioning_2.cpp ├── partition_array_for_maximum_sum.cpp ├── pictures_with_kitten(easy).cpp ├── pictures_with_kitten_hard.cpp ├── plates.cpp ├── prac.cpp ├── readme.md ├── recursion_simple_digit_dp.cpp ├── regular_expression_matching.cpp ├── rod_cutting.cpp ├── split_array_largest_sum.cpp ├── spoj_3_tile.cpp ├── spp.cpp ├── subset_sum.cpp ├── subset_sum_one_row.cpp ├── subset_sum_one_row_erpeating_values.cpp ├── subset_sum_repeating.cpp ├── subset_sum_tabulation.cpp ├── subset_sum_two_rows.cpp ├── subset_sum_using_bitset.cpp ├── sum_of_digits_spoj.cpp ├── supw.cpp ├── supw_k.cpp ├── tiling_3.cpp ├── to_do_digit_dp.cpp ├── tower_of_hanoi.cpp ├── tree_dis_2.cpp ├── vertex_cover_dfs.cpp ├── vertex_cover_spoj_bfs.cpp ├── vertex_cover_spoj_dp.cpp └── wildcard_pattern_matching.cpp └── Java Codes ├── AlphaCode.java ├── AutoBiographicalNumber.java ├── BestTimeToBuyAndSellStocks.java ├── BottomUpVsTopDown.java ├── ColorfulKnapsack.java ├── CompanyQueries.java ├── ConsecutiveSequence.java ├── CountOrdered.java ├── CountSetBits.java ├── CountUnordered.java ├── CountUnorderedTwo.java ├── Diameter.java ├── DistanceTreeOne.java ├── EditDistance.java ├── ElevatorProblem.java ├── Fibonacci.java ├── FibonacciSum.java ├── GoodSequence.java ├── HamiltonPathBacktrack.java ├── HamiltonPathBottomUp.java ├── HamiltonPathRecursiveMemo.java ├── HamiltonPathUsingBitmask.java ├── InterleavingStrings.java ├── InvestigationCode.java ├── Knapsack.java ├── KnapsackRecursion.java ├── LCS_unmemoised.java ├── LIS.java ├── LIS_nlogn.java ├── LIS_todo.java ├── MagicNumber.java ├── MakeFenceGreatAgain.java ├── MakeFenceGreatAgainRec.java ├── MinimumStepsToReachOne.java ├── New.java ├── New2.java ├── NoConsecOnes.java ├── O_N_KnapSack.java ├── OptimalSelection.java ├── OrderedPair.java ├── PaintHouse.java ├── PalindromicPartitioning.java ├── PalindromicPartitioning2.java ├── PartitionArrayForMaximumSum.java ├── PictureWithKittenEasy.java ├── PictureWithKittenHard.java ├── Plates.java ├── Prac.java ├── RecursionSimpleDigitDp.java ├── RegularExpressionMatching.java ├── RoadCutting.java ├── SPP.java ├── SUPW.java ├── SUPW_k.java ├── SplitArrayLargestSum.java ├── Spoj3Tile.java ├── SubsetSum.java ├── SubsetSumBitset.java ├── SubsetSumOneRow.java ├── SubsetSumRepeating.java ├── SubsetSumTabulation.java ├── SubsetSumTwoRows.java ├── SumOfDigitsSpoj.java ├── Tiling3.java ├── ToDoDigitDp.java ├── TowerOfHanoi.java ├── TreeDis2.java ├── VertexCoverSpoj.java ├── VertexCoverSpojBFS.java ├── VertexCoverSpojDfs.java ├── WildCardMatching.java └── subsetSumOneRowRepeatingValues.java /C++ Codes/O_N_knapsack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int size, n; 11 | cin >> size >> n; 12 | 13 | int s[n + 1], v[n + 1]; 14 | 15 | for (int i = 1; i <= n; i++) { 16 | cin >> s[i] >> v[i]; 17 | } 18 | 19 | int dp[size + 1]; 20 | 21 | memset(dp, 0, sizeof(dp)); 22 | 23 | for (int i = 1; i <= n; i++) { 24 | 25 | // 0/N knapsack 26 | for (int j = 0; j <= size; j++) { 27 | if (j - s[i] >= 0) dp[j] = max(dp[j], dp[j - s[i]] + v[i]); 28 | } 29 | } 30 | 31 | cout << dp[size]; 32 | 33 | 34 | 35 | 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /C++ Codes/alphacode.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | string s; 7 | vector memo; 8 | 9 | int dp(int i) { 10 | 11 | if (i == s.size()) return 1; 12 | 13 | if (memo[i] != -1) return memo[i]; 14 | 15 | int ans = 0; 16 | if (s[i] >= '1' && s[i] <= '9') { 17 | ans += dp(i + 1); 18 | } 19 | 20 | if (i + 1 < s.size() && (s[i] == '1')) { 21 | ans += dp(i + 2); 22 | } 23 | 24 | if (i + 1 < s.size() && (s[i] == '2' && s[i + 1] <= '6')) { 25 | ans += dp(i + 2); 26 | } 27 | 28 | return memo[i] = ans; 29 | } 30 | 31 | int32_t main() { 32 | #ifndef ONLINE_JUDGE 33 | freopen("input.txt", "r", stdin); 34 | freopen("output.txt", "w", stdout); 35 | #endif 36 | 37 | while (1) { 38 | cin >> s; 39 | if (s[0] == '0') break; 40 | 41 | memo.clear(); 42 | memo.resize(s.size(), -1); 43 | 44 | cout << dp(0) << '\n'; 45 | 46 | } 47 | 48 | 49 | } -------------------------------------------------------------------------------- /C++ Codes/auto_biographical_numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 20; 6 | 7 | int length, num[N], cnt[N]; 8 | 9 | void auto_bio_graphical_number(int index) { 10 | 11 | // base case 12 | if (index == length) { 13 | for (int i = 0; i < length; i++) { 14 | if (num[i] != cnt[i]) return; 15 | } 16 | 17 | for (int i = 0; i < length; i++) { 18 | cout << num[i]; 19 | } cout << '\n'; 20 | 21 | return; 22 | } 23 | 24 | for (int _num = 0; _num < length; _num++) { 25 | num[index] = _num; 26 | cnt[_num]++; 27 | 28 | auto_bio_graphical_number(index + 1); 29 | 30 | // back tracking 31 | cnt[_num]--; 32 | num[index] = -1; 33 | 34 | } 35 | 36 | } 37 | 38 | int main() 39 | { 40 | freopen("input.txt", "r", stdin); 41 | freopen("output.txt", "w", stdout); 42 | 43 | length = 4; 44 | auto_bio_graphical_number(0); 45 | 46 | 47 | return 0; 48 | } -------------------------------------------------------------------------------- /C++ Codes/best_time_to_buy_and_sell_stock.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | int memo[1001][2][101]; 8 | int dp(int i, int buy, int k, vector& prices) { 9 | if (i == prices.size()) return 0; 10 | if (memo[i][buy][k] != -1) return memo[i][buy][k]; 11 | // dont buy/sell 12 | int ans = dp(i + 1, buy, k, prices); 13 | if (k == 0) return 0; 14 | // buy 15 | if (buy) { 16 | ans = max(ans, -prices[i] + dp(i + 1, false, k, prices)); 17 | } 18 | else { 19 | ans = max(ans, prices[i] + dp(i + 1, true, k - 1, prices)); 20 | } 21 | 22 | return memo[i][buy][k] = ans; 23 | } 24 | int maxProfit(int k, vector& prices) { 25 | memset(memo, -1, sizeof(memo)); 26 | return dp(0, true, k, prices); 27 | } 28 | }; 29 | 30 | int main() 31 | { 32 | freopen("input.txt", "r", stdin); 33 | freopen("output.txt", "w", stdout); 34 | 35 | Solution H; 36 | vector prices = {3, 2, 6, 5, 0, 3}; 37 | cout << H.maxProfit(2, prices); 38 | 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /C++ Codes/bottom_up_vs_top_down.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | map mp; 6 | 7 | // int memo[1e6]; 8 | 9 | int dp(int n) { 10 | if (n <= 1) return n; 11 | if (mp.count(n)) return mp[n]; 12 | return mp[n] = max(dp(n / 2) + dp(n / 3) + dp(n / 4), n); 13 | } 14 | 15 | int main() 16 | { 17 | freopen("input.txt", "r", stdin); 18 | freopen("output.txt", "w", stdout); 19 | 20 | int n; 21 | /* 22 | while (cin >> n) { 23 | // cout << n << '\n'; 24 | 25 | // bottom up 26 | 27 | int dp[n + 1]; 28 | dp[0] = 0; 29 | dp[1] = 1; 30 | for (int i = 2; i <= n; i++) { 31 | dp[i] = max(i, dp[i / 2] + dp[i / 3] + dp[i / 4]); 32 | } 33 | cout << dp[n] << '\n'; 34 | } 35 | */ 36 | 37 | // top down 38 | while (cin >> n) { 39 | cout << dp(n) << '\n'; 40 | } 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /C++ Codes/colorful_knapsack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | #ifndef ONLINE_JUDGE 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | #endif 10 | // ll t; 11 | // cin>>t; 12 | // while(t--) 13 | { 14 | ll i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 15 | cin >> j >> n >> m; 16 | ll dp[105][10005] = {}; 17 | vector v[105]; 18 | ll a[105]; 19 | for (i = 0; i < j; i++) { 20 | cin >> a[i]; 21 | } 22 | for (i = 0; i < j; i++) { 23 | ll x; cin >> x; 24 | v[x].pb(a[i]); 25 | } 26 | for (auto x : v[1]) { 27 | dp[1][x]++; 28 | } 29 | for (i = 1; i < n; i++) { 30 | for (j = 0; j <= m; j++) { 31 | if (dp[i][j]) { 32 | for (auto x : v[i + 1]) { 33 | if (j + x <= m) { 34 | dp[i + 1][j + x]++; 35 | } 36 | } 37 | } 38 | } 39 | } 40 | for (j = 1; j <= m; j++) { 41 | if (dp[n][j]) { 42 | ans = max(ans, j); 43 | } 44 | } 45 | if (ans == 0) cout << -1; 46 | else cout << m - ans; 47 | } 48 | } -------------------------------------------------------------------------------- /C++ Codes/company_queries_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 2e5 + 1, M = 20; 6 | 7 | vector gr[N]; 8 | int Par[N][M]; 9 | 10 | void dfs(int cur, int par) { 11 | 12 | Par[cur][0] = par; 13 | for (int j = 1; j < M; j++) { 14 | Par[cur][j] = Par[Par[cur][j - 1]][j - 1]; 15 | } 16 | 17 | for (auto x : gr[cur]) { 18 | if (x != par) { 19 | dfs(x, cur); 20 | } 21 | } 22 | } 23 | 24 | int giveKthPar(int x, int k) { 25 | 26 | int cur = x; 27 | for (int j = 0; j < M; j++) { 28 | if ((k >> j) & 1) { 29 | cur = Par[cur][j]; 30 | } 31 | } 32 | 33 | if (cur == 0) cur = -1; 34 | return cur; 35 | 36 | } 37 | 38 | int main() 39 | { 40 | freopen("input.txt", "r", stdin); 41 | freopen("output.txt", "w", stdout); 42 | 43 | int n, q; 44 | cin >> n >> q; 45 | 46 | for (int i = 2; i <= n; i++) { 47 | int par; 48 | cin >> par; 49 | gr[i].push_back(par); 50 | gr[par].push_back(i); 51 | } 52 | 53 | dfs(1, 0); 54 | 55 | // for (int i = 1; i <= n; i++) { 56 | // for (int j = 0; j < 3; j++) { 57 | // cout << i << " " << pow(2, j) << " " << Par[i][j] << '\n'; 58 | // } 59 | // } 60 | 61 | while (q--) { 62 | int x, k; 63 | cin >> x >> k; 64 | cout << giveKthPar(x, k) << '\n'; 65 | } 66 | 67 | return 0; 68 | } -------------------------------------------------------------------------------- /C++ Codes/consecutive_sequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | cin >> n; 12 | int a[n]; 13 | for (int i = 0; i < n; i++) { 14 | cin >> a[i]; 15 | } 16 | map dp; 17 | 18 | for (int i = 0; i < n; i++) { 19 | dp[a[i]] = dp[a[i] - 1] + 1; 20 | } 21 | 22 | int k = 0, start, end; 23 | for (auto x : dp) { 24 | // x.first 25 | if (k < x.second) end = x.first; 26 | k = max(k, x.second); 27 | } 28 | 29 | cout << k << '\n'; 30 | 31 | start = end - k + 1; 32 | for (int i = 0; i < n; i++) { 33 | if (a[i] == start) { 34 | // zero-based inedxing 35 | cout << i + 1 << " "; 36 | start++; 37 | } 38 | if (start == end + 1) break; 39 | } 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /C++ Codes/countOrdered.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | // O(n*n) 7 | int memo[1000]; 8 | int countOrdered(int n) { 9 | if (n == 0) return 1; 10 | if (memo[n] != -1) return memo[n]; 11 | int ans = 0; 12 | for (int i = 1; i <= n; i++) { 13 | ans += countOrdered(n - i); 14 | } 15 | return memo[n] = ans; 16 | } 17 | 18 | int32_t main() { 19 | #ifndef ONLINE_JUDGE 20 | freopen("input.txt", "r", stdin); 21 | freopen("output.txt", "w", stdout); 22 | #endif 23 | 24 | int n; 25 | cin >> n; 26 | memset(memo, -1, sizeof(memo)); 27 | cout << countOrdered(n) << '\n'; 28 | 29 | // O(n) 30 | int dp[n + 1]; 31 | dp[0] = 1; 32 | int sum = 0; 33 | for (int i = 1; i <= n; i++) { 34 | dp[i] = sum + 1; 35 | sum += dp[i]; 36 | } 37 | 38 | cout << dp[n] << '\n'; 39 | 40 | // O(1) 41 | cout << pow(2, n - 1); 42 | 43 | 44 | } -------------------------------------------------------------------------------- /C++ Codes/countUnordered2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | // O(n*n*n) after memoisation 7 | int countUnordered(int min, int n) { 8 | 9 | if (n == 0) return 1; 10 | 11 | int ans = 0; 12 | for (int i = min; i <= n; i++) { 13 | ans += countUnordered(i, n - i); 14 | } 15 | 16 | return ans; 17 | 18 | } 19 | 20 | // O(n*n) 21 | int countUnordered2(int min, int n) { 22 | 23 | // memoise 24 | 25 | if (n == 0) return 1; 26 | if (min > n) return 0; 27 | if (min == n) return 1; 28 | 29 | // included in the partition 30 | int ans = countUnordered2(min, n - min) 31 | // exluded in the partition 32 | + countUnordered2(min + 1, n); 33 | 34 | return ans; 35 | 36 | } 37 | 38 | int32_t main() { 39 | #ifndef ONLINE_JUDGE 40 | freopen("input.txt", "r", stdin); 41 | freopen("output.txt", "w", stdout); 42 | #endif 43 | 44 | int n; 45 | cin >> n; 46 | 47 | for (int i = 0; i <= 20; i++) { 48 | cout << countUnordered(1, i) << '\n'; 49 | } 50 | 51 | for (int i = 0; i <= 20; i++) { 52 | cout << countUnordered2(1, i) << '\n'; 53 | } 54 | 55 | // O(n*n) solution 56 | int dp[n + 1]; 57 | memset(dp, 0, sizeof(dp)); 58 | dp[0] = 1; 59 | 60 | for (int i = 1; i <= n; i++) { 61 | 62 | for (int j = i; j <= n; j++) { 63 | dp[j] += dp[j - i]; 64 | } 65 | 66 | for (int k = 0; k <= n; k++) { 67 | cout << dp[k] << " "; 68 | } cout << '\n'; 69 | } 70 | 71 | cout << dp[n] << '\n'; 72 | 73 | 74 | 75 | 76 | 77 | } -------------------------------------------------------------------------------- /C++ Codes/count_set_bits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n = 10; 11 | int dp[n + 1]; 12 | dp[0] = 0; 13 | 14 | for (int i = 1; i <= n; i++) { 15 | dp[i] = dp[i / 2] + (i % 2); 16 | cout << dp[i] << '\n'; 17 | } 18 | // O(n) 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /C++ Codes/count_unordered.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | // O(n*n*n) after memoisation 7 | int countUnordered(int min, int n) { 8 | 9 | if (n == 0) return 1; 10 | 11 | int ans = 0; 12 | for (int i = min; i <= n; i++) { 13 | ans += countUnordered(i, n - i); 14 | } 15 | 16 | return ans; 17 | 18 | } 19 | 20 | int32_t main() { 21 | #ifndef ONLINE_JUDGE 22 | freopen("input.txt", "r", stdin); 23 | freopen("output.txt", "w", stdout); 24 | #endif 25 | 26 | int n; 27 | cin >> n; 28 | 29 | // for (int i = 0; i <= 20; i++) { 30 | // cout << countUnordered(1, i) << '\n'; 31 | // } 32 | 33 | // O(n*n) solution 34 | int dp[n + 1]; 35 | memset(dp, 0, sizeof(dp)); 36 | dp[0] = 1; 37 | 38 | for (int i = 1; i <= n; i++) { 39 | 40 | for (int j = i; j <= n; j++) { 41 | dp[j] += dp[j - i]; 42 | } 43 | 44 | for (int k = 0; k <= n; k++) { 45 | cout << dp[k] << " "; 46 | } cout << '\n'; 47 | } 48 | 49 | cout << dp[n] << '\n'; 50 | 51 | 52 | 53 | 54 | 55 | } -------------------------------------------------------------------------------- /C++ Codes/diameter_code.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 2e5 + 1; 6 | 7 | vector gr[N]; 8 | int f[N], g[N]; 9 | 10 | void dfs(int cur, int par) { 11 | int max_1 = 0, max_2 = 0; 12 | 13 | for (auto x : gr[cur]) { 14 | if (x != par) { 15 | dfs(x, cur); 16 | 17 | // g for the cur node 18 | g[cur] = max(g[x] + 1, g[cur]); 19 | f[cur] = max(f[x], f[cur]); 20 | 21 | // max 2 values of g[x] 22 | if (g[x] + 1 > max_1) { 23 | max_2 = max_1; 24 | max_1 = g[x] + 1; 25 | } 26 | else if (g[x] + 1 > max_2) { 27 | max_2 = g[x] + 1; 28 | } 29 | } 30 | } 31 | 32 | f[cur] = max(f[cur], max_1 + max_2); 33 | 34 | } 35 | 36 | int main() 37 | { 38 | // freopen("input.txt", "r", stdin); 39 | // freopen("output.txt", "w", stdout); 40 | 41 | int n; 42 | cin >> n; 43 | 44 | for (int i = 0; i < n - 1; i++) { 45 | int x, y; 46 | cin >> x >> y; 47 | gr[x].push_back(y); 48 | gr[y].push_back(x); 49 | } 50 | 51 | dfs(1, -1); 52 | 53 | cout << f[1]; 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /C++ Codes/distance_tree_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 2e5 + 1; 6 | 7 | vector gr[N]; 8 | int g[N], f[N]; 9 | 10 | void dfs_g(int cur, int par) { 11 | for (auto x : gr[cur]) { 12 | if (x != par) { 13 | dfs_g(x, cur); 14 | g[cur] = max(g[cur], g[x] + 1); 15 | } 16 | } 17 | } 18 | 19 | void dfs_f(int cur, int par, int dis_par) { 20 | 21 | int max_1 = -1, max_2 = -1; 22 | 23 | for (auto x : gr[cur]) { 24 | if (x != par) { 25 | if (g[x] > max_1) max_2 = max_1, max_1 = g[x]; 26 | else if (g[x] > max_2) max_2 = g[x]; 27 | } 28 | } 29 | 30 | for (auto x : gr[cur]) { 31 | if (x != par) { 32 | 33 | int new_dis_par = dis_par; 34 | 35 | // for (auto y : gr[cur]) { 36 | // if (y != par && y != x) { 37 | // new_dis_par = max(g[y], new_dis_par); 38 | // } 39 | // } 40 | 41 | if (g[x] == max_1) 42 | new_dis_par = max(new_dis_par, max_2); 43 | else 44 | new_dis_par = max(new_dis_par, max_1); 45 | 46 | dfs_f(x, cur, new_dis_par + 1); 47 | 48 | // for any node in the subtree 49 | f[cur] = max(f[cur], g[x] + 1); 50 | } 51 | } 52 | 53 | // for any node in the supertree 54 | // supertree = compliment of subtree 55 | f[cur] = max(f[cur], dis_par + 1); 56 | 57 | } 58 | 59 | int main() 60 | { 61 | freopen("input.txt", "r", stdin); 62 | freopen("output.txt", "w", stdout); 63 | 64 | int n; 65 | cin >> n; 66 | 67 | for (int i = 0; i < n - 1; i++) { 68 | int x, y; 69 | cin >> x >> y; 70 | gr[x].push_back(y); 71 | gr[y].push_back(x); 72 | } 73 | 74 | // O(N) 75 | dfs_g(1, -1); 76 | 77 | // O(N) 78 | dfs_f(1, -1, -1); 79 | 80 | for (int i = 1; i <= n; i++) { 81 | cout << f[i] << " "; 82 | } 83 | 84 | return 0; 85 | } -------------------------------------------------------------------------------- /C++ Codes/edit_distance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | string a, b; 6 | 7 | int memo[2000][2000]; 8 | 9 | int edit_distance(int i, int j) { 10 | if (i == a.size() && j == b.size()) return 0; 11 | if (i == a.size()) return (b.size() - j); 12 | if (j == b.size()) return (a.size() - i); 13 | 14 | if (memo[i][j] != -1) return memo[i][j]; 15 | 16 | // i> t; 36 | while (t--) { 37 | cin >> a >> b; 38 | memset(memo, -1, sizeof(memo)); 39 | cout << edit_distance(0, 0) << '\n'; 40 | } 41 | 42 | } -------------------------------------------------------------------------------- /C++ Codes/elevator_problem_code.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int x, n; 11 | cin >> x >> n; 12 | 13 | int weight[n]; 14 | 15 | for (int i = 0; i < n; i++) { 16 | cin >> weight[i]; 17 | } 18 | 19 | pair dp[1 << n]; 20 | // dp[mask].first = f[mask] = rides 21 | // dp[mask].second = g[mask] = weight 22 | 23 | dp[0] = {1, 0}; 24 | 25 | for (int mask = 1; mask < 1 << n; mask++) { 26 | dp[mask] = {n, 0}; 27 | for (int y = 0; y < n; y++) { 28 | if ((mask >> y) & 1) { 29 | int new_mask = mask ^ (1 << y); 30 | pair option = dp[new_mask]; 31 | // include yth person 32 | if (option.second + weight[y] <= x) { 33 | option.first = option.first; 34 | option.second += weight[y]; 35 | } 36 | else { 37 | // exclude the yth person 38 | // new ride with y 39 | option.first++; 40 | option.second = weight[y]; 41 | } 42 | dp[mask] = min(dp[mask], option); 43 | } 44 | } 45 | } 46 | 47 | cout << dp[(1 << n) - 1].first << " " << dp[(1 << n) - 1].second; 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /C++ Codes/fibosum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | using namespace std; 4 | 5 | const int mod = 1e9 + 7; 6 | const int sz = 2; 7 | 8 | struct Mat { 9 | int m[sz][sz]; 10 | Mat() { 11 | memset(m, 0, sizeof(m)); 12 | } 13 | void identity() { 14 | for (int i = 0; i < sz; i++) { 15 | m[i][i] = 1; 16 | } 17 | } 18 | Mat operator* (Mat a) { 19 | Mat res; 20 | for (int i = 0; i < sz; i++) { 21 | for (int j = 0; j < sz; j++) { 22 | for (int k = 0; k < sz; k++) { 23 | res.m[i][j] += m[i][k] * a.m[k][j]; 24 | res.m[i][j] %= mod; 25 | } 26 | } 27 | } 28 | return res; 29 | } 30 | }; 31 | 32 | int Fib(int n) { 33 | if (n == 0) return 0; 34 | Mat res; 35 | res.identity(); 36 | Mat T; 37 | T.m[0][0] = T.m[0][1] = T.m[1][0] = 1; 38 | 39 | if (n <= 2) return 1; 40 | n -= 2; 41 | 42 | // log(n) 43 | while (n) { 44 | if (n & 1) res = res * T; 45 | T = T * T; 46 | n /= 2; 47 | } 48 | 49 | return (res.m[0][0] + res.m[0][1]) % mod; 50 | } 51 | 52 | int32_t main() 53 | { 54 | freopen("input.txt", "r", stdin); 55 | freopen("output.txt", "w", stdout); 56 | 57 | int t; 58 | cin >> t; 59 | 60 | while (t--) { 61 | int n, m; 62 | cin >> n >> m; 63 | cout << (Fib(m + 2) - Fib(n + 1) + mod) % mod << '\n'; 64 | } 65 | 66 | return 0; 67 | } -------------------------------------------------------------------------------- /C++ Codes/fibosum_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | using namespace std; 4 | 5 | const int mod = 1e9 + 7; 6 | const int sz = 3; 7 | 8 | struct Mat { 9 | int m[sz][sz]; 10 | Mat() { 11 | memset(m, 0, sizeof(m)); 12 | } 13 | void identity() { 14 | for (int i = 0; i < sz; i++) { 15 | m[i][i] = 1; 16 | } 17 | } 18 | Mat operator* (Mat a) { 19 | Mat res; 20 | for (int i = 0; i < sz; i++) { 21 | for (int j = 0; j < sz; j++) { 22 | for (int k = 0; k < sz; k++) { 23 | res.m[i][j] += m[i][k] * a.m[k][j]; 24 | res.m[i][j] %= mod; 25 | } 26 | } 27 | } 28 | return res; 29 | } 30 | }; 31 | 32 | int Fibosum(int n) { 33 | // base case 34 | if (n == -1) return 0; 35 | if (n == 0) return 0; 36 | if (n == 1) return 1; 37 | 38 | Mat res; 39 | res.identity(); 40 | Mat T; 41 | T.m[0][0] = T.m[0][1] = T.m[0][2] = 1; 42 | T.m[1][1] = T.m[1][2] = 1; 43 | T.m[2][1] = 1; 44 | 45 | // n >= 2 46 | n -= 1; 47 | 48 | // log(n) 49 | while (n) { 50 | if (n & 1) res = res * T; 51 | T = T * T; 52 | n /= 2; 53 | } 54 | 55 | return (res.m[0][0] + res.m[0][1]) % mod; 56 | } 57 | 58 | int32_t main() 59 | { 60 | freopen("input.txt", "r", stdin); 61 | freopen("output.txt", "w", stdout); 62 | 63 | int t; 64 | cin >> t; 65 | 66 | while (t--) { 67 | int n, m; 68 | cin >> n >> m; 69 | cout << (Fibosum(m) - Fibosum(n - 1) + mod) % mod << '\n'; 70 | } 71 | 72 | return 0; 73 | } -------------------------------------------------------------------------------- /C++ Codes/good sequences.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5 + 1; 6 | 7 | int dp_prime[N]; 8 | 9 | // O(sqrt(n)) 10 | vector give_prime_divisors(int n) { 11 | vector div; 12 | for (int i = 2; i * i <= n; i++) { 13 | if (n % i == 0) { 14 | div.push_back(i); 15 | while (n % i == 0) n /= i; 16 | } 17 | } 18 | if (n > 1) div.push_back(n); 19 | return div; 20 | } 21 | 22 | int main() 23 | { 24 | freopen("input.txt", "r", stdin); 25 | freopen("output.txt", "w", stdout); 26 | 27 | int n; 28 | cin >> n; 29 | int a[n]; 30 | 31 | for (int i = 0; i < n; i++) { 32 | cin >> a[i]; 33 | } 34 | 35 | for (int i = 0; i < n; i++) { 36 | vector prime_div = give_prime_divisors(a[i]); 37 | 38 | int best_ending = 0; 39 | for (auto x : prime_div) { 40 | best_ending = max(best_ending, dp_prime[x]); 41 | } 42 | 43 | for (auto x : prime_div) { 44 | dp_prime[x] = best_ending + 1; 45 | } 46 | } 47 | 48 | cout << *max_element(dp_prime, dp_prime + N); 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /C++ Codes/hamiltonian_path_backtrack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5; 6 | 7 | vector gr[N]; 8 | int n, m; 9 | int vis[N]; 10 | bool hamiltonian_path = false; 11 | 12 | // bool paths() 13 | 14 | // O(number_of_hamiltonian_paths) 15 | void paths(int cur, int cnt) { 16 | if (cnt == n) { 17 | hamiltonian_path = true; 18 | return; 19 | } 20 | 21 | vis[cur] = 1; 22 | 23 | for (auto x : gr[cur]) { 24 | if (!vis[x]) { 25 | paths(x, cnt + 1); 26 | } 27 | } 28 | 29 | // backtracking 30 | vis[cur] = 0; 31 | return; 32 | } 33 | 34 | int main() 35 | { 36 | freopen("input.txt", "r", stdin); 37 | freopen("output.txt", "w", stdout); 38 | 39 | cin >> n >> m; 40 | 41 | for (int i = 0; i < m; i++) { 42 | int x, y; 43 | cin >> x >> y; 44 | gr[x].push_back(y); 45 | gr[y].push_back(x); 46 | } 47 | 48 | for (int i = 0; i < n; i++) { 49 | paths(i, 1); 50 | } 51 | 52 | cout << hamiltonian_path; 53 | 54 | 55 | 56 | 57 | 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /C++ Codes/hamiltonian_path_bottom_up.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n, m; 11 | cin >> n >> m; 12 | vector gr[n]; 13 | 14 | for (int i = 0; i < m; i++) { 15 | int x, y; 16 | cin >> x >> y; 17 | gr[x].push_back(y); 18 | gr[y].push_back(x); 19 | } 20 | 21 | int dp[n][1 << n]; 22 | memset(dp, 0, sizeof(dp)); 23 | 24 | for (int i = 0; i < n; i++) { 25 | dp[i][1 << i] = 1; 26 | } 27 | 28 | for (int mask = 0; mask < (1 << n); mask++) { 29 | for (int cur = 0; cur < n; cur++) { 30 | if (dp[cur][mask]) { 31 | for (auto x : gr[cur]) { 32 | if (!((mask >> x) & 1)) { 33 | dp[x][mask | (1 << x)] = true; 34 | } 35 | } 36 | } 37 | } 38 | } 39 | 40 | bool ans = 0; 41 | 42 | for (int i = 0; i < n; i++) { 43 | ans |= dp[i][(1 << n) - 1]; 44 | } 45 | 46 | cout << ans; 47 | 48 | 49 | 50 | return 0; 51 | } -------------------------------------------------------------------------------- /C++ Codes/hamiltonian_path_recursive_memo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 10; 6 | 7 | vector gr[N]; 8 | 9 | map>, bool> mp; 10 | int n, m; 11 | 12 | bool dp(int cur, set St) { 13 | 14 | if (St.size() == n) { 15 | return true; 16 | } 17 | if (mp.count({cur, St})) { 18 | return mp[ {cur, St}]; 19 | } 20 | 21 | bool ans = false; 22 | for (auto x : gr[cur]) { 23 | if (St.find(x) == St.end()) { 24 | 25 | set temp = St; 26 | temp.insert(x); 27 | 28 | ans |= dp(x, temp); 29 | } 30 | } 31 | 32 | return mp[ {cur, St}] = ans; 33 | 34 | } 35 | 36 | int main() 37 | { 38 | freopen("input.txt", "r", stdin); 39 | freopen("output.txt", "w", stdout); 40 | 41 | cin >> n >> m; 42 | 43 | for (int i = 0; i < m; i++) { 44 | int x, y; 45 | cin >> x >> y; 46 | gr[x].push_back(y); 47 | gr[y].push_back(x); 48 | } 49 | 50 | bool hamiltonian_path = false; 51 | 52 | for (int i = 0; i < n; i++) { 53 | set St; 54 | St.insert(i); 55 | hamiltonian_path |= dp(i, St); 56 | } 57 | 58 | cout << hamiltonian_path; 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | return 0; 67 | } -------------------------------------------------------------------------------- /C++ Codes/hamiltonian_path_using_bitmask.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 10; 6 | 7 | vector gr[N]; 8 | int memo[N][1 << N]; 9 | 10 | int n, m; 11 | 12 | bool dp(int cur, int mask) { 13 | if (mask == (1 << n) - 1) { 14 | return true; 15 | } 16 | 17 | if (memo[cur][mask] != -1) { 18 | return memo[cur][mask]; 19 | } 20 | 21 | bool ans = false; 22 | for (auto x : gr[cur]) { 23 | // xth bit of mask is set or not 24 | if (!((mask >> x) & 1)) { 25 | ans |= dp(x, mask | (1 << x)); 26 | } 27 | } 28 | 29 | return memo[cur][mask] = ans; 30 | 31 | } 32 | 33 | int main() 34 | { 35 | freopen("input.txt", "r", stdin); 36 | freopen("output.txt", "w", stdout); 37 | 38 | cin >> n >> m; 39 | 40 | for (int i = 0; i < m; i++) { 41 | int x, y; 42 | cin >> x >> y; 43 | gr[x].push_back(y); 44 | gr[y].push_back(x); 45 | } 46 | 47 | bool hamiltonian_path = false; 48 | 49 | memset(memo, -1, sizeof(memo)); 50 | 51 | for (int i = 0; i < n; i++) { 52 | hamiltonian_path |= dp(i, (1 << i)); 53 | } 54 | 55 | cout << hamiltonian_path; 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | return 0; 64 | } -------------------------------------------------------------------------------- /C++ Codes/interleaving_strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | string s1, s2, s3; 8 | vector> memo; 9 | int dp(int i, int j) { 10 | 11 | 12 | int k = i + j; 13 | if (k == s3.size()) return true; 14 | 15 | if (memo[i][j] != -1) return memo[i][j]; 16 | 17 | int ans = 0; 18 | if (i < s1.size() && s1[i] == s3[k]) { 19 | ans |= dp(i + 1, j); 20 | } 21 | 22 | if (j < s2.size() && s2[j] == s3[k]) { 23 | ans |= dp(i, j + 1); 24 | } 25 | 26 | return memo[i][j] = ans; 27 | } 28 | bool isInterleave(string s1, string s2, string s3) { 29 | this->s1 = s1; 30 | this->s2 = s2; 31 | this->s3 = s3; 32 | if (s1.size() + s2.size() != s3.size()) return false; 33 | memo.resize(s1.size() + 1, vector(s2.size() + 1, -1)); 34 | return dp(0, 0); 35 | } 36 | }; 37 | 38 | int main() 39 | { 40 | freopen("input.txt", "r", stdin); 41 | freopen("output.txt", "w", stdout); 42 | 43 | string s1, s2, s3; 44 | cin >> s1 >> s2 >> s3; 45 | 46 | Solution H; 47 | cout << H.isInterleave(s1, s2, s3); 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /C++ Codes/investigation_code.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | string n; 7 | int a, b, k; 8 | 9 | // 10 * 2 * 100 * 100 states 10 | int memo[10][2][90][90]; 11 | 12 | int solver(int index, bool last, int sum_mod, int sum_dig_mod) { 13 | 14 | if (index == n.size()) { 15 | if (sum_mod == 0 && sum_dig_mod == 0) { 16 | return 1; 17 | } 18 | return 0; 19 | } 20 | 21 | if (memo[index][last][sum_mod][sum_dig_mod] != -1) { 22 | return memo[index][last][sum_mod][sum_dig_mod]; 23 | } 24 | 25 | int till = (last ? n[index] - '0' : 9); 26 | int ans = 0; 27 | 28 | for (int digits = 0; digits <= till; digits++) { 29 | ans += solver(index + 1, last && (digits == till), 30 | (sum_mod * 10 + digits) % k, 31 | (sum_dig_mod + digits) % k); 32 | } 33 | 34 | return memo[index][last][sum_mod][sum_dig_mod] = ans; 35 | 36 | } 37 | 38 | int f(int _n) { 39 | if (k > 90) return 0; 40 | n = to_string(_n); 41 | memset(memo, -1, sizeof(memo)); 42 | return solver(0, true, 0, 0); 43 | } 44 | 45 | int32_t main() 46 | { 47 | freopen("input.txt", "r", stdin); 48 | freopen("output.txt", "w", stdout); 49 | 50 | // dont forget to add case ? 51 | // Case 1: 52 | // Case 2: 53 | 54 | int t; 55 | cin >> t; 56 | while (t--) { 57 | cin >> a >> b >> k; 58 | cout << f(b) - f(a - 1) << '\n'; 59 | } 60 | 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /C++ Codes/knapsack_recursion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 2001; 6 | 7 | int s[N], v[N]; 8 | int memo[N][N]; 9 | 10 | // O(n*size) 11 | int knapsack(int index, int size) { 12 | if (index == 0) return 0; 13 | 14 | int &ans = memo[index][size]; 15 | 16 | if (ans != -1) return ans; 17 | ans = 0; 18 | 19 | // include 20 | if (s[index] <= size) { 21 | ans = v[index] + knapsack(index - 1, size - s[index]); 22 | } 23 | // exclude 24 | ans = max(ans, knapsack(index - 1, size)); 25 | 26 | return ans; 27 | 28 | } 29 | 30 | int main() 31 | { 32 | freopen("input.txt", "r", stdin); 33 | freopen("output.txt", "w", stdout); 34 | 35 | int size, n; 36 | cin >> size >> n; 37 | 38 | for (int i = 1; i <= n; i++) { 39 | cin >> s[i] >> v[i]; 40 | } 41 | 42 | memset(memo, -1, sizeof(memo)); 43 | 44 | cout << knapsack(n, size); 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /C++ Codes/knapsack_tabular.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int size, n; 11 | cin >> size >> n; 12 | int s[n + 1], v[n + 1]; 13 | for (int i = 1; i <= n; i++) { 14 | cin >> s[i] >> v[i]; 15 | } 16 | 17 | int dp[size + 1]; 18 | memset(dp, 0, sizeof(dp)); 19 | 20 | for (int i = 1; i <= n; i++) { 21 | for (int j = size; j >= 0; j--) { 22 | if (j - s[i] >= 0) dp[j] = max(dp[j], dp[j - s[i]] + v[i]); 23 | } 24 | } 25 | 26 | cout << dp[size]; 27 | 28 | 29 | 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /C++ Codes/lids_todo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | string n, m; 7 | 8 | int memo1[11][2][2][11][11]; 9 | 10 | int combination(int index, bool first, bool last, int prev, int len) { 11 | 12 | // cout << prev << " " << len << '\n'; 13 | 14 | if (index == n.size()) { 15 | if (len == 0) return 1; 16 | return 0; 17 | } 18 | 19 | if (memo1[index][first][last][prev][len] != -1) { 20 | return memo1[index][first][last][prev][len]; 21 | } 22 | 23 | int start = (first ? n[index] - '0' : 0); 24 | int till = (last ? m[index] - '0' : 9); 25 | int ans = 0; 26 | 27 | 28 | for (int digits = start; digits <= till; digits++) { 29 | ans += combination(index + 1, first && (digits == start), last && (digits == till), prev, len); 30 | if (digits > prev) { 31 | ans += combination(index + 1, first && (digits == start), last && (digits == till), digits, len - 1); 32 | } 33 | } 34 | 35 | return memo1[index][first][last][prev][len] = ans; 36 | 37 | } 38 | 39 | int solver(int _n, int _m, int len) { 40 | n = to_string(_n); 41 | m = to_string(_m); 42 | int diff = m.size() - n.size(); 43 | while (diff--) { 44 | n = "0" + n; 45 | } 46 | memset(memo1, -1, sizeof(memo1)); 47 | return combination(0, true, true, 0, len); 48 | } 49 | 50 | int32_t main() 51 | { 52 | freopen("input.txt", "r", stdin); 53 | freopen("output.txt", "w", stdout); 54 | 55 | int t; 56 | cin >> t; 57 | 58 | for (int i = 1; i <= t; i++) { 59 | 60 | int a, b; 61 | cin >> a >> b; 62 | 63 | for (int len = 10; len >= 0; len--) { 64 | if (solver(a, b, len)) { 65 | cout << "Case " << i << ": " << len << " " << solver(a, b, len) << '\n'; 66 | break; 67 | } 68 | } 69 | 70 | } 71 | 72 | 73 | return 0; 74 | } -------------------------------------------------------------------------------- /C++ Codes/lis.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | cin >> n; 12 | int a[n]; 13 | int dp[n]; 14 | 15 | for (int i = 0; i < n; i++) { 16 | cin >> a[i]; 17 | dp[i] = 1; 18 | } 19 | 20 | // O(n*n) 21 | for (int i = 0; i < n; i++) { 22 | 23 | // dp[i] -> lis if it ends on ith index 24 | for (int j = 0; j < i; j++) { 25 | 26 | if (a[j] <= a[i]) { 27 | dp[i] = max(dp[i], dp[j] + 1); 28 | } 29 | 30 | } 31 | } 32 | 33 | int lis = 1; 34 | 35 | for (int i = 0; i < n; i++) { 36 | // cout << a[i] << " " << dp[i] << '\n'; 37 | lis = max(lis, dp[i]); 38 | } 39 | 40 | cout << lis; 41 | 42 | 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /C++ Codes/lis_nlogn.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct fenwick { 6 | vector fn; 7 | int n; 8 | fenwick() {} 9 | fenwick(int n) { 10 | init(n); 11 | } 12 | void init(int _n) { 13 | n = _n + 10; 14 | fn.clear(); fn.resize(n, 0); 15 | } 16 | // log(n) 17 | void update(int x, int val) { 18 | x++;// 1 based indexing 19 | while (x < n) { 20 | fn[x] = max(fn[x], val); 21 | x += (x & (-x)); 22 | } 23 | } 24 | // log(n) 25 | int query(int x) { 26 | x++;//1 basaed indexing 27 | int ans = 0; 28 | while (x) { 29 | ans = max(ans, fn[x]); 30 | x -= (x & (-x)); 31 | } 32 | return ans; 33 | } 34 | }; 35 | 36 | int main() 37 | { 38 | freopen("input.txt", "r", stdin); 39 | freopen("output.txt", "w", stdout); 40 | 41 | int n; 42 | cin >> n; 43 | int a[n]; 44 | pair b[n]; 45 | for (int i = 0; i < n; i++) { 46 | cin >> a[i]; 47 | b[i] = {a[i], i}; 48 | } 49 | 50 | fenwick H(n); 51 | 52 | int lis[n]; 53 | 54 | // n log n 55 | sort(b, b + n); 56 | 57 | for (int i = 0; i < n; i++) { 58 | int val = b[i].first; 59 | int index = b[i].second; 60 | 61 | lis[index] = H.query(index - 1) + 1; 62 | 63 | H.update(index, lis[index]); 64 | } 65 | 66 | // for (int i = 0; i < n; i++) { 67 | // cout << lis[i] << " "; 68 | // } 69 | 70 | // n logn 71 | 72 | cout << H.query(n - 1); 73 | 74 | 75 | // inversion count 76 | 77 | 78 | 79 | return 0; 80 | } -------------------------------------------------------------------------------- /C++ Codes/longest_common_subsequence_unmemoised.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | string s, t; 6 | 7 | int lcs(int i, int j) { 8 | if (i == s.size() && j == t.size()) return 0; 9 | if (i == s.size()) return 0; 10 | if (j == t.size()) return 0; 11 | 12 | int ans = 0; 13 | if (s[i] == t[j]) { 14 | ans = 1 + lcs(i + 1, j + 1); 15 | } 16 | else { 17 | ans = max(lcs(i, j + 1), lcs(i + 1, j)); 18 | } 19 | 20 | return ans; 21 | } 22 | 23 | int main() { 24 | 25 | #ifndef ONLINE_JUDGE 26 | freopen("input.txt", "r", stdin); 27 | freopen("output.txt", "w", stdout); 28 | #endif 29 | 30 | cin >> s >> t; 31 | 32 | cout << lcs(0, 0); 33 | 34 | } -------------------------------------------------------------------------------- /C++ Codes/magic_number.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | int m, d, mod = 1e9 + 7; 7 | string n; 8 | 9 | // memoisation 10 | int memo[2000][2][2000]; 11 | 12 | // 0-based index 13 | int dp(int index, bool last, int dig_mod) { 14 | 15 | if (index == n.size()) { 16 | return (dig_mod == 0); 17 | } 18 | 19 | if (memo[index][last][dig_mod] != -1) return memo[index][last][dig_mod]; 20 | 21 | int till = (last ? n[index] - '0' : 9); 22 | int ans = 0; 23 | 24 | if (index % 2 == 1) { 25 | // even position 26 | if (d <= till) { 27 | ans += dp(index + 1, last && (d == till), (dig_mod * 10 + d) % m); 28 | ans %= mod; 29 | } 30 | } 31 | else { 32 | // odd positions 33 | for (int digits = 0; digits <= till; digits++) { 34 | // odd position cannot place d 35 | if (digits == d) continue; 36 | ans += dp(index + 1, last && (digits == till), (dig_mod * 10 + digits) % m); 37 | ans %= mod; 38 | } 39 | } 40 | return memo[index][last][dig_mod] = ans; 41 | } 42 | 43 | int solve(string _n) { 44 | n = _n; 45 | memset(memo, -1, sizeof(memo)); 46 | return dp(0, true, 0); 47 | } 48 | 49 | int32_t main() { 50 | 51 | #ifndef ONLINE_JUDGE 52 | freopen("input.txt", "r", stdin); 53 | freopen("output.txt", "w", stdout); 54 | #endif 55 | 56 | cin >> m >> d; 57 | 58 | string a, b; 59 | cin >> a >> b; 60 | 61 | int i = a.size() - 1; 62 | 63 | while (i >= 0 && a[i] == '0') { 64 | a[i] = '9'; 65 | i--; 66 | } 67 | a[i] = a[i] - 1; 68 | 69 | // cout << a << '\n'; 70 | 71 | // a = a - 1; 72 | cout << (solve(b) - solve(a) + mod) % mod; 73 | 74 | 75 | 76 | 77 | 78 | } -------------------------------------------------------------------------------- /C++ Codes/make_fence_great_again_recursive_memo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define P pair 10 | #define pb push_back 11 | 12 | const int N = 300005; 13 | 14 | int n; 15 | int a[N], dp[N][3], b[N]; 16 | 17 | int solve(int pos, int prev, int state) { 18 | if (pos == n) return 0; 19 | if (dp[pos][state] != -1) return dp[pos][state]; 20 | int ans = 1e18; 21 | if (a[pos] + 0 != prev) { 22 | ans = min(ans, solve(pos + 1, a[pos] + 0, 0)); 23 | } 24 | if (a[pos] + 1 != prev) { 25 | ans = min(ans, b[pos] + solve(pos + 1, a[pos] + 1, 1)); 26 | } 27 | if (a[pos] + 2 != prev) { 28 | ans = min(ans, 2 * b[pos] + solve(pos + 1, a[pos] + 2, 2)); 29 | } 30 | return dp[pos][state] = ans; 31 | } 32 | 33 | int32_t main() 34 | { 35 | ios_base:: sync_with_stdio(false); 36 | cin.tie(NULL); cout.tie(NULL); 37 | int t; cin >> t; while (t--) 38 | { 39 | int i, j, k, m, ans = 0, cnt = 0, sum = 0; 40 | cin >> n; 41 | for (i = 0; i < n; i++) { 42 | cin >> a[i] >> b[i]; 43 | } 44 | for (i = 0; i <= n; i++) { 45 | for (j = 0; j < 3; j++) { 46 | dp[i][j] = -1; 47 | } 48 | } 49 | cout << min({solve(0, -1, 0), solve(0, -1, 1), solve(0, -1, 2)}) << '\n'; 50 | } 51 | } -------------------------------------------------------------------------------- /C++ Codes/make_fence_great_again_tabulation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define P pair 10 | #define pb push_back 11 | 12 | const int N = 300005; 13 | 14 | int32_t main() 15 | { 16 | ios_base:: sync_with_stdio(false); 17 | cin.tie(NULL); cout.tie(NULL); 18 | int t; cin >> t; while (t--) 19 | { 20 | int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 21 | cin >> n; 22 | int a[n], b[n]; 23 | for (i = 0; i < n; i++) { 24 | cin >> a[i] >> b[i]; 25 | } 26 | int dp[n][3] ; 27 | for (i = 0; i < n; i++) { 28 | dp[i][0] = dp[i][1] = dp[i][2] = 1e18; 29 | } 30 | dp[0][0] = 0; dp[0][1] = b[0]; dp[0][2] = 2 * b[0]; 31 | for (i = 1; i < n; i++) { 32 | for (j = 0; j < 3; j++) { 33 | for (k = 0; k < 3; k++) { 34 | if (a[i - 1] + j != a[i] + k) { 35 | dp[i][k] = min(dp[i][k], dp[i - 1][j] + k * b[i]); 36 | } 37 | } 38 | } 39 | } 40 | cout << min({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << '\n'; 41 | } 42 | } -------------------------------------------------------------------------------- /C++ Codes/minimum_steps_to_reach_one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5; 6 | 7 | int memo[N]; 8 | 9 | int dp(int n) { 10 | if (n == 1) return 0; 11 | 12 | int &ans = memo[n]; 13 | 14 | if (ans != -1) return ans; 15 | ans = INT_MAX; 16 | 17 | if (n % 2 == 0) { 18 | ans = min(ans, dp(n / 2)); 19 | } 20 | if (n % 3 == 0) { 21 | ans = min(ans, dp(n / 3)); 22 | } 23 | ans = min(ans, dp(n - 1)); 24 | ans += 1; 25 | 26 | return ans; 27 | } 28 | 29 | int main() 30 | { 31 | freopen("input.txt", "r", stdin); 32 | freopen("output.txt", "w", stdout); 33 | 34 | int n; 35 | cin >> n; 36 | 37 | memset(memo, -1, sizeof(memo)); 38 | 39 | cout << dp(n); 40 | 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /C++ Codes/new.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | using namespace std; 4 | 5 | #define db(...) __f(#__VA_ARGS__, __VA_ARGS__) 6 | 7 | template 8 | void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; } 9 | template 10 | void __f(const char* names, Arg1&& arg1, Args&&... args) { 11 | const char* comma = strchr(names + 1, ','); 12 | cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...); 13 | } 14 | 15 | 16 | const int N = 16; 17 | int a[N][N], n; 18 | 19 | int give_score(int mask, int bit) { 20 | int score = 0; 21 | for (int i = 0; i < n; i++) { 22 | if ((mask >> i) & 1) { 23 | score += a[i][bit]; 24 | } 25 | } 26 | return score; 27 | } 28 | 29 | int32_t main() 30 | { 31 | ios_base:: sync_with_stdio(false); 32 | cin.tie(NULL); cout.tie(NULL); 33 | #ifndef ONLINE_JUDGE 34 | freopen("input.txt", "r", stdin); 35 | freopen("output.txt", "w", stdout); 36 | #endif 37 | 38 | cin >> n; 39 | for (int i = 0; i < n; i++) { 40 | for (int j = 0; j < n; j++) { 41 | cin >> a[i][j]; 42 | } 43 | } 44 | 45 | // total value, 46 | // set of previous group 47 | pair dp[1 << n]; 48 | 49 | dp[0] = {0, 0}; 50 | 51 | for (int mask = 1; mask < (1 << n); mask++) { 52 | dp[mask] = { -1e18, 0}; 53 | for (int bit = 0; bit < n; bit++) { 54 | if ((mask >> bit) & 1) { 55 | int new_mask = mask ^ (1 << bit); 56 | 57 | // start new group 58 | if (dp[new_mask].first > dp[mask].first) { 59 | dp[mask] = {dp[new_mask].first, 1 << bit}; 60 | } 61 | 62 | // either add current element 63 | // to previous group 64 | int score = give_score(dp[new_mask].second, bit); 65 | if (score + dp[new_mask].first >= dp[mask].first) { 66 | dp[mask] = {score + dp[new_mask].first, dp[new_mask].second | (1 << bit)}; 67 | } 68 | } 69 | } 70 | // cout << mask << " " << dp[mask].first << " " << dp[mask].second << '\n'; 71 | } 72 | 73 | cout << dp[(1 << n) - 1].first; 74 | 75 | 76 | 77 | 78 | return 0; 79 | } -------------------------------------------------------------------------------- /C++ Codes/new2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | const int N = 2e5 + 1; 7 | 8 | vector gr[N]; 9 | int g[N], h[N], f[N], n; 10 | 11 | void dfs_g(int cur, int par) { 12 | for (auto x : gr[cur]) { 13 | if (x != par) { 14 | dfs_g(x, cur); 15 | g[cur] += g[x] + h[x]; 16 | h[cur] += h[x]; 17 | } 18 | } 19 | h[cur] += 1; 20 | } 21 | 22 | void dfs_f(int cur, int par, int sum_par) { 23 | 24 | // cout << cur << " " << par << " " << sum_par << '\n'; 25 | 26 | for (auto x : gr[cur]) { 27 | if (x != par) { 28 | 29 | int new_sum_par = sum_par + (n - h[cur]); 30 | new_sum_par += (g[cur] - g[x] - h[x]); 31 | 32 | dfs_f(x, cur, new_sum_par); 33 | 34 | // for any node in the subtree 35 | f[cur] += g[x] + h[x]; 36 | } 37 | } 38 | 39 | // for any node in the supertree 40 | // supertree = compliment of subtree 41 | f[cur] += sum_par + (n - h[cur]); 42 | 43 | } 44 | 45 | int32_t main() 46 | { 47 | freopen("input.txt", "r", stdin); 48 | freopen("output.txt", "w", stdout); 49 | 50 | cin >> n; 51 | 52 | for (int i = 0; i < n - 1; i++) { 53 | int x, y; 54 | cin >> x >> y; 55 | gr[x].push_back(y); 56 | gr[y].push_back(x); 57 | } 58 | 59 | // O(N) 60 | dfs_g(1, -1); 61 | 62 | // O(N) 63 | dfs_f(1, -1, 0); 64 | 65 | for (int i = 1; i <= n; i++) { 66 | cout << f[i] << " "; 67 | } 68 | 69 | return 0; 70 | } -------------------------------------------------------------------------------- /C++ Codes/no_consecutive_ones.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // one represents whether 6 | // the number at previous index is one 7 | int fun(int index, int n, bool previous_one) { 8 | 9 | // base case 10 | if (index == n + 1) return 1; 11 | 12 | int ans = 0; 13 | 14 | // either place 0 here 15 | ans += fun(index + 1, n, false); 16 | 17 | // or place 1 here 18 | if (previous_one == false) { 19 | ans += fun(index + 1, n, true); 20 | } 21 | 22 | return ans; 23 | // ans for array [index.....n] 24 | } 25 | 26 | int main() 27 | { 28 | freopen("input.txt", "r", stdin); 29 | freopen("output.txt", "w", stdout); 30 | 31 | 32 | for (int i = 1; i <= 10; i++) { 33 | cout << fun(1, i, false) << '\n'; 34 | } 35 | 36 | // fibonacci series 37 | // 1,1,2,3,5,8 ..... 38 | // ans = fib(n+2) 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /C++ Codes/optimal_selection.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int k, n; 11 | cin >> k >> n; 12 | 13 | int price[k][n]; 14 | vector> dp(1 << k, vector(n, 1e8)); 15 | 16 | for (int i = 0; i < k; i++) { 17 | for (int j = 0; j < n; j++) { 18 | cin >> price[i][j]; 19 | } 20 | } 21 | 22 | dp[0][0] = 0; 23 | 24 | for (int i = 0; i < k; i++) { 25 | dp[1 << i][0] = price[i][0]; 26 | } 27 | 28 | for (int mask = 0; mask < (1 << k); mask++) { 29 | for (int d = 1; d < n; d++) { 30 | // dp[mask][d] 31 | dp[mask][d] = dp[mask][d - 1]; 32 | 33 | for (int x = 0; x < k; x++) { 34 | if ((mask >> x) & 1) { 35 | // unset jth bit of mask 36 | int new_mask = mask ^ (1 << x); 37 | dp[mask][d] = min(dp[mask][d], 38 | dp[new_mask][d - 1] + price[x][d]); 39 | } 40 | } 41 | } 42 | } 43 | 44 | cout << dp[(1 << k) - 1][n - 1]; 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | return 0; 58 | } -------------------------------------------------------------------------------- /C++ Codes/ordered_pair(code).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | int memo[1000]; 7 | 8 | // O(n*n) 9 | int countWaysOrdered(int n) { 10 | if (n == 0) return 1; 11 | if (memo[n] != -1) return memo[n]; 12 | int ans = 0; 13 | 14 | // for (i....n) 15 | for (int i = 1; i <= n; i++) { 16 | ans += countWaysOrdered(n - i); 17 | } 18 | 19 | return memo[n] = ans; 20 | } 21 | 22 | int32_t main() { 23 | #ifndef ONLINE_JUDGE 24 | freopen("input.txt", "r", stdin); 25 | freopen("output.txt", "w", stdout); 26 | #endif 27 | 28 | int n; 29 | cin >> n; 30 | 31 | // top down approach 32 | memset(memo, -1, sizeof(memo)); 33 | 34 | cout << countWaysOrdered(n) << '\n'; 35 | 36 | // bottom up approach 37 | // O(n) 38 | int sum = 0; 39 | int dp[n + 1]; 40 | 41 | for (int i = 1; i <= n; i++) { 42 | dp[i] = sum + 1; 43 | sum += dp[i]; 44 | } 45 | 46 | cout << dp[n] << '\n'; 47 | 48 | // 2^(n-1) 49 | // O(1) 50 | cout << pow(2, n - 1) << '\n'; 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | } -------------------------------------------------------------------------------- /C++ Codes/paint_house.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | cin >> n; 12 | int cost[3][n]; 13 | 14 | for (int i = 0; i < n; i++) { 15 | cin >> cost[0][i]; 16 | } 17 | for (int i = 0; i < n; i++) { 18 | cin >> cost[1][i]; 19 | } 20 | for (int i = 0; i < n; i++) { 21 | cin >> cost[2][i]; 22 | } 23 | 24 | int dp[3][n]; 25 | 26 | dp[0][0] = cost[0][0]; 27 | dp[1][0] = cost[1][0]; 28 | dp[2][0] = cost[2][0]; 29 | 30 | for (int j = 1; j < n; j++) { 31 | dp[0][j] = dp[1][j] = dp[2][j] = INT_MAX; 32 | 33 | // for (int i = 0; i < 3; i++) { 34 | // for (int i_ = 0; i_ < 3; i_++) { 35 | // if (i != i_) { 36 | // dp[i][j] = min(dp[i_][j - 1] + cost[i][j]); 37 | // } 38 | // } 39 | // } 40 | 41 | dp[0][j] = min(dp[2][j - 1], dp[1][j - 1]) + cost[0][j]; 42 | dp[1][j] = min(dp[0][j - 1], dp[2][j - 1]) + cost[1][j]; 43 | dp[2][j] = min(dp[0][j - 1], dp[1][j - 1]) + cost[2][j]; 44 | } 45 | 46 | cout << min({dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]}); 47 | 48 | 49 | 50 | 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /C++ Codes/palindromic_partitioning.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | string s; 8 | map>> mp; 9 | 10 | bool is_palindrome(int i, int j) { 11 | while (i <= j) { 12 | if (s[i] != s[j]) return false; 13 | i++; j--; 14 | } 15 | return true; 16 | } 17 | 18 | vector> dp(int i) { 19 | if (i == s.size()) return vector>(); 20 | 21 | if (mp.count(i)) return mp[i]; 22 | 23 | vector> ans; 24 | 25 | for (int j = i; j < s.size(); j++) { 26 | if (is_palindrome(i, j)) { 27 | 28 | vector> res = dp(j + 1); 29 | string substring = s.substr(i, j - i + 1); 30 | 31 | for (auto &x : res) { 32 | x.insert(x.begin(), substring); 33 | } 34 | 35 | if (res.empty()) { 36 | res.push_back({substring}); 37 | } 38 | 39 | for (auto x : res) { 40 | ans.push_back(x); 41 | } 42 | } 43 | 44 | } 45 | 46 | return mp[i] = ans; 47 | } 48 | 49 | vector> partition(string s) { 50 | this->s = s; 51 | return dp(0); 52 | } 53 | }; 54 | 55 | int main() 56 | { 57 | freopen("input.txt", "r", stdin); 58 | freopen("output.txt", "w", stdout); 59 | 60 | string s; 61 | cin >> s; 62 | 63 | Solution H; 64 | vector> res = H.partition(s); 65 | 66 | for (auto x : res) { 67 | for (auto y : x) { 68 | cout << y << " "; 69 | } cout << '\n'; 70 | } 71 | 72 | return 0; 73 | } -------------------------------------------------------------------------------- /C++ Codes/palindromic_partitioning_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | string s; 8 | vector> memo; 9 | vector memo1; 10 | 11 | // memoising? 12 | // O(n*n) 13 | bool is_palindrome(int i, int j) { 14 | if (i == j) return true; 15 | if (i == j - 1) return (s[i] == s[j]); 16 | if (memo[i][j] != -1) return memo[i][j]; 17 | return memo[i][j] = is_palindrome(i + 1, j - 1) && (s[i] == s[j]); 18 | } 19 | 20 | // states O(n) 21 | int dp(int i) { 22 | if (i == s.size()) return 0; 23 | 24 | if (memo1[i] != -1) return memo1[i]; 25 | 26 | int ans = INT_MAX; 27 | // O(n) 28 | for (int j = i; j < s.size(); j++) { 29 | if (is_palindrome(i, j)) { 30 | ans = min(ans, dp(j + 1)); 31 | } 32 | } 33 | ans += 1; 34 | return memo1[i] = ans; 35 | } 36 | 37 | int minCut(string s) { 38 | this->s = s; 39 | memo.resize(s.size(), vector(s.size(), -1)); 40 | memo1.resize(s.size(), -1); 41 | return dp(0) - 1; 42 | } 43 | }; 44 | 45 | int main() 46 | { 47 | freopen("input.txt", "r", stdin); 48 | freopen("output.txt", "w", stdout); 49 | 50 | string s; 51 | cin >> s; 52 | 53 | Solution H; 54 | cout << H.minCut(s); 55 | 56 | 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /C++ Codes/partition_array_for_maximum_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | vector memo; 8 | int dp(int i, vector& arr, int k) { 9 | if (i == arr.size()) return 0; 10 | if (memo[i] != -1) return memo[i]; 11 | int ans = 0, mx = 0; 12 | for (int j = i; j < min((int)arr.size(), i + k); j++) { 13 | mx = max(mx, arr[j]); 14 | ans = max(ans, mx * (j - i + 1) + dp(j + 1, arr, k)); 15 | } 16 | return memo[i] = ans; 17 | } 18 | int maxSumAfterPartitioning(vector& arr, int k) { 19 | memo.resize(arr.size(), -1); 20 | return dp(0, arr, k); 21 | } 22 | }; 23 | 24 | int main() 25 | { 26 | freopen("input.txt", "r", stdin); 27 | freopen("output.txt", "w", stdout); 28 | 29 | Solution H; 30 | vector a = {1, 15, 7, 9, 2, 5, 10}; 31 | cout << H.maxSumAfterPartitioning(a, 3); 32 | 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /C++ Codes/pictures_with_kitten(easy).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define P pair 10 | #define pb push_back 11 | #define db(...) __f(#__VA_ARGS__, __VA_ARGS__) 12 | 13 | template 14 | void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; } 15 | template 16 | void __f(const char* names, Arg1&& arg1, Args&&... args) { 17 | const char* comma = strchr(names + 1, ','); 18 | cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...); 19 | } 20 | 21 | const int N = 205; 22 | 23 | int n, k, m; 24 | vector a(N); 25 | vector> memo(N, (vector(N, -1))); 26 | 27 | int dp(int cur, int rem) { 28 | if (memo[cur][rem] != -1) return memo[cur][rem]; 29 | if (cur == n) { 30 | if (rem == 0) return 0; 31 | else return -1e18; 32 | } 33 | if (rem == 1) { 34 | if (cur >= n - k) return a[cur]; 35 | else return -1e18; 36 | } 37 | int i; 38 | int ans = -1e18; 39 | for (i = cur + 1; i < n && i <= cur + k; i++) { 40 | ans = max(ans, a[cur] + dp(i, rem - 1)); 41 | } 42 | return memo[cur][rem] = ans; 43 | } 44 | 45 | void solve() { 46 | int i, j, ans = 0, cnt = 0, sum = 0; 47 | cin >> n >> k >> m; 48 | for (i = 0; i < n; i++) { 49 | cin >> a[i]; 50 | } 51 | ans = -1e18; 52 | for (i = 0; i < k; i++) { 53 | ans = max(ans, dp(i, m)); 54 | // cout << i << " " << dp(i, m) << '\n'; 55 | } 56 | if (ans < 0) ans = -1; 57 | cout << ans; 58 | return ; 59 | } 60 | 61 | int32_t main() 62 | { 63 | ios_base:: sync_with_stdio(false); 64 | cin.tie(NULL); cout.tie(NULL); 65 | // int t; cin >> t; while (t--) 66 | solve(); 67 | return 0; 68 | } 69 | // 1879965082 -------------------------------------------------------------------------------- /C++ Codes/pictures_with_kitten_hard.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define P pair 10 | #define pb push_back 11 | #define db(...) __f(#__VA_ARGS__, __VA_ARGS__) 12 | 13 | template 14 | void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; } 15 | template 16 | void __f(const char* names, Arg1&& arg1, Args&&... args) { 17 | const char* comma = strchr(names + 1, ','); 18 | cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...); 19 | } 20 | 21 | const int N = 5005; 22 | 23 | int n, k, m; 24 | vector a(N); 25 | 26 | struct sparse_table { 27 | vector> mat;// 0 based indexing 28 | int n, m; // size and log 29 | vector p2;//log2 30 | void init(int _n, int _m) { 31 | n = _n; m = _m; 32 | mat.resize(n); p2.resize(n + 1); 33 | for (int i = 0; i < n; i++) mat[i].resize(m); 34 | for (int i = 2; i <= n; i++) p2[i] = p2[i / 2] + 1; 35 | } 36 | void build(int a[]) { 37 | int i, j; 38 | for (i = 0; i < n; i++) mat[i][0] = a[i]; 39 | for (j = 1; j < m; j++) { 40 | for (i = 0; i + (1 << j) <= n; i++) { 41 | mat[i][j] = max(mat[i][j - 1], mat[i + (1 << (j - 1))][j - 1]); 42 | } 43 | } 44 | } 45 | int query(int l, int r) { 46 | int pw = p2[r - l]; 47 | return max(mat[l][pw], mat[r - (1 << pw) + 1][pw]); 48 | } 49 | } table; 50 | 51 | void solve() { 52 | int i, j, ans = 0, cnt = 0, sum = 0; 53 | cin >> n >> k >> m; 54 | for (i = 0; i < n; i++) { 55 | cin >> a[i]; 56 | } 57 | int dp[n]; 58 | for (i = 0; i < n; i++) { 59 | if (i >= n - k) dp[i] = a[i]; 60 | else dp[i] = -1e16; 61 | } 62 | table.init(n, 13); 63 | for (j = 2; j <= m; j++) { 64 | table.build(dp); 65 | for (i = 0; i < n - 1; i++) { 66 | dp[i] = a[i] + table.query(i + 1, min(i + k, n - 1)); 67 | } 68 | dp[n - 1] = -1e16; 69 | } 70 | ans = -1e16; 71 | for (i = 0; i < k; i++) { 72 | ans = max(ans, dp[i]); 73 | } 74 | if (ans < 0) ans = -1; 75 | cout << ans; 76 | return ; 77 | } 78 | 79 | int32_t main() 80 | { 81 | ios_base:: sync_with_stdio(false); 82 | cin.tie(NULL); cout.tie(NULL); 83 | // int t; cin >> t; while (t--) 84 | solve(); 85 | return 0; 86 | } 87 | // 1879965082 -------------------------------------------------------------------------------- /C++ Codes/plates.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int solve() { 6 | int n, k, p; 7 | cin >> n >> k >> p; 8 | vector> a(n + 1, vector(k + 1, 0)); 9 | vector> pref(n + 1, vector(k + 1, 0)); 10 | for (int i = 1; i <= n; i++) { 11 | for (int j = 1; j <= k; j++) { 12 | cin >> a[i][j]; 13 | pref[i][j] = pref[i][j - 1] + a[i][j]; 14 | } 15 | } 16 | 17 | // dp array column length should be p 18 | vector> dp(n + 1, vector(p + 1, 0)); 19 | 20 | for (int i = 1; i <= n; i++) { 21 | for (int j = 1; j <= p; j++) { 22 | // dp[i][j] 23 | // pick j plates from first i rows 24 | for (int x = 0; x <= min(k, j); x++) { 25 | dp[i][j] = max(dp[i][j], pref[i][x] + 26 | dp[i - 1][j - x]); 27 | } 28 | } 29 | } 30 | return dp[n][p]; 31 | } 32 | 33 | int main() 34 | { 35 | freopen("input.txt", "r", stdin); 36 | freopen("output.txt", "w", stdout); 37 | 38 | int t, z = 1; 39 | cin >> t; 40 | while (z <= t) { 41 | cout << "Case #" << z++ << ": " << solve() << '\n'; 42 | } 43 | 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /C++ Codes/prac.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | int32_t main() { 7 | #ifndef ONLINE_JUDGE 8 | freopen("input.txt", "r", stdin); 9 | freopen("output.txt", "w", stdout); 10 | #endif 11 | 12 | int n; 13 | cin >> n; 14 | int a[n][n]; 15 | 16 | for (int i = 0; i < n; i++) { 17 | for (int j = 0; j < n; j++) { 18 | cin >> a[i][j]; 19 | } 20 | } 21 | 22 | pair dp[1 << n]; 23 | 24 | dp[0] = {0, 0}; 25 | 26 | for (int mask = 1; mask < (1 << n); mask++) { 27 | dp[mask] = { -1e18, 0}; 28 | for (int bit = 0; bit < n; bit++) { 29 | if ((mask >> bit) & 1) { 30 | // bit -> x 31 | int new_mask = mask ^ (1 << bit); 32 | 33 | // whether start a new group with bit 34 | if (dp[mask].first < dp[new_mask].first) { 35 | dp[mask] = {dp[new_mask].first, (1 << bit)}; 36 | } 37 | 38 | // include bit into the previous best group 39 | // dp[new_mask].second 40 | int score = 0; 41 | for (int j = 0; j < n; j++) { 42 | if ((dp[new_mask].second >> j) & 1) { 43 | // j represents element in the previous best group 44 | // add compatibility of bit with j 45 | score += a[bit][j]; 46 | } 47 | } 48 | 49 | if (dp[mask].first <= dp[new_mask].first + score) { 50 | dp[mask] = {dp[new_mask].first + score, dp[new_mask].second | (1 << bit)}; 51 | } 52 | } 53 | } 54 | } 55 | 56 | 57 | cout << dp[(1 << n) - 1].first; 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | } -------------------------------------------------------------------------------- /C++ Codes/readme.md: -------------------------------------------------------------------------------- 1 | All the cpp codes are uploaded here 2 | -------------------------------------------------------------------------------- /C++ Codes/recursion_simple_digit_dp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | string s; 6 | 7 | void fun(string ans, int index, bool last) { 8 | 9 | if (index == s.size()) { 10 | cout << ans << '\n'; 11 | return; 12 | } 13 | 14 | int till = (last ? (s[index] - '0') : 9); 15 | 16 | for (int i = 0; i <= till; i++) { 17 | fun(ans + to_string(i), index + 1, (last && (i == till)) ); 18 | } 19 | 20 | } 21 | 22 | int main() 23 | { 24 | freopen("input.txt", "r", stdin); 25 | freopen("output.txt", "w", stdout); 26 | 27 | cin >> s; 28 | 29 | fun("", 0, true); 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /C++ Codes/regular_expression_matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | string s, p; 8 | vector> memo; 9 | int dp(int i, int j) { 10 | if (i == s.size() && j == p.size()) return true; 11 | if (j == p.size()) return false; 12 | // memoisation 13 | int &ans = memo[i][j]; 14 | if (ans != -1) return ans; 15 | ans = 0; 16 | 17 | if (j + 1 < p.size() && p[j + 1] == '*') { 18 | // when character matches due to * 19 | if (i < s.size() && (s[i] == p[j] || p[j] == '.')) { 20 | ans |= dp(i + 1, j); 21 | } 22 | // no character matches 23 | ans |= dp(i, j + 2); 24 | } 25 | else { 26 | if (i < s.size() && (s[i] == p[j] || p[j] == '.')) { 27 | ans |= dp(i + 1, j + 1); 28 | } 29 | } 30 | 31 | return ans; 32 | } 33 | bool isMatch(string s, string p) { 34 | this->s = s; 35 | this->p = p; 36 | memo.resize(s.size() + 1, vector(p.size() + 1, -1)); 37 | return dp(0, 0); 38 | } 39 | }; 40 | 41 | int main() 42 | { 43 | freopen("input.txt", "r", stdin); 44 | freopen("output.txt", "w", stdout); 45 | 46 | string s, p; 47 | cin >> s >> p; 48 | 49 | Solution H; 50 | cout << H.isMatch(s, p); 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /C++ Codes/rod_cutting.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | int memo[100000]; 7 | 8 | // Space Complexity -> O(n) 9 | // Time complexity -> O(n*n) 10 | int rodCutting(int n, int prices[]) { 11 | if (n == 0) return 0; 12 | 13 | if (memo[n] != -1) return memo[n]; 14 | 15 | // O(n) extra work inside each state 16 | int ans = 0; 17 | for (int i = 1; i <= n; i++) { 18 | ans = max(ans, prices[i] + rodCutting(n - i, prices)); 19 | } 20 | 21 | return memo[n] = ans; 22 | } 23 | 24 | int32_t main() { 25 | #ifndef ONLINE_JUDGE 26 | freopen("input.txt", "r", stdin); 27 | freopen("output.txt", "w", stdout); 28 | #endif 29 | 30 | int n; 31 | cin >> n; 32 | int prices[n + 1]; 33 | 34 | for (int i = 1; i <= n; i++) { 35 | cin >> prices[i]; 36 | } 37 | 38 | memset(memo, -1, sizeof(memo)); 39 | cout << rodCutting(n, prices); 40 | 41 | 42 | 43 | 44 | 45 | 46 | } -------------------------------------------------------------------------------- /C++ Codes/split_array_largest_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | vector> memo; 8 | int dp(int i, vector& nums, int m) { 9 | if (i == nums.size()) { 10 | if (m == 0) return 0; 11 | return 1e9; 12 | } 13 | if (m <= 0) return 1e9; 14 | // i>=0 && i0 15 | // I can make partitions 16 | if (memo[i][m] != -1) return memo[i][m]; 17 | int ans = 1e9, sum = 0; 18 | for (int j = i; j < nums.size(); j++) { 19 | // i....j 20 | sum += nums[j]; 21 | ans = min(ans, max(sum, dp(j + 1, nums, m - 1))); 22 | } 23 | return memo[i][m] = ans; 24 | } 25 | int splitArray(vector& nums, int m) { 26 | memo.resize(nums.size() + 1, vector(m + 1, -1)); 27 | return dp(0, nums, m); 28 | } 29 | }; 30 | 31 | int main() 32 | { 33 | freopen("input.txt", "r", stdin); 34 | freopen("output.txt", "w", stdout); 35 | 36 | Solution H; 37 | vector a = {1, 2, 3, 4, 5}; 38 | cout << H.splitArray(a, 2); 39 | 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /C++ Codes/spoj_3_tile.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | while (cin >> n) { 12 | if (n == -1) break; 13 | 14 | int f[n + 1], g[n + 1]; 15 | 16 | f[0] = g[0] = 1; 17 | f[1] = g[1] = 0; 18 | 19 | for (int i = 2; i <= n; i++) { 20 | f[i] = f[i - 2] + 2 * g[i - 2]; 21 | g[i] = g[i - 2] + f[i]; 22 | } 23 | 24 | cout << f[n] << '\n'; 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /C++ Codes/spp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define P pair 10 | #define V vector 11 | #define pb push_back 12 | #define db(...) __f(#__VA_ARGS__, __VA_ARGS__) 13 | 14 | template 15 | void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; } 16 | template 17 | void __f(const char* names, Arg1&& arg1, Args&&... args) { 18 | const char* comma = strchr(names + 1, ','); 19 | cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...); 20 | } 21 | 22 | const int N = 100005; 23 | 24 | int mod; 25 | 26 | const int M = 20; 27 | int sz; 28 | struct Mat 29 | { 30 | int m[M][M]; 31 | 32 | Mat() 33 | { 34 | memset(m, 0, sizeof m); 35 | } 36 | 37 | void eye() 38 | { 39 | for (int i = 0; i < sz; i++) 40 | m[i][i] = 1; 41 | } 42 | 43 | Mat operator* (const Mat &a) const 44 | { 45 | Mat r; 46 | for (int i = 0; i < sz; i++) 47 | for (int j = 0; j < sz; j++) 48 | for (int k = 0; k < sz; k++) 49 | r.m[i][j] = (r.m[i][j] + m[i][k] * a.m[k][j]) % mod; 50 | return r; 51 | } 52 | }; 53 | int solve(int b[], int c[], int e, int n) 54 | { 55 | Mat r, a; 56 | r.eye(); 57 | a.m[0][0] = 1; 58 | for (int i = 1; i < sz; i++) { 59 | a.m[0][i] = c[i - 1]; 60 | a.m[1][i] = c[i - 1]; 61 | } 62 | for (int i = 2; i < sz; i++) { 63 | a.m[i][i - 1] = 1; 64 | } 65 | while (e) { 66 | if (e & 1) 67 | r = r * a; 68 | a = a * a; 69 | e >>= 1; 70 | } 71 | int ans = 0; 72 | for (int i = 0; i < n; i++) { 73 | ans += b[i]; 74 | } 75 | ans = r.m[0][0] * ans; 76 | ans %= mod; 77 | for (int i = 1; i < sz; i++) { 78 | ans += r.m[0][i] * b[n - i]; 79 | ans %= mod; 80 | } 81 | return ans; 82 | } 83 | 84 | int give(int k, int b[], int c[], int n) { 85 | if (k < n) { 86 | int ans = 0; 87 | for (int i = 0; i <= k; i++) { 88 | ans += b[i]; 89 | ans %= mod; 90 | } 91 | return ans; 92 | } 93 | else { 94 | return solve(b, c, k - n + 1, n) ; 95 | } 96 | } 97 | 98 | int32_t main() 99 | { 100 | int t; cin >> t; while (t--) 101 | { 102 | int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 103 | cin >> n; 104 | sz = n + 1; 105 | int b[n], c[n]; 106 | for (i = 0; i < n; i++) { 107 | cin >> b[i]; 108 | } 109 | for (i = 0; i < n; i++) { 110 | cin >> c[i]; 111 | } 112 | int l, r; 113 | cin >> l >> r >> mod; 114 | l--; r--; 115 | cout << (give(r, b, c, n) - give(l - 1, b, c, n) + mod) % mod << '\n'; 116 | } 117 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1000; 6 | 7 | int a[N], n; 8 | 9 | vector> memo; 10 | 11 | // whether sum is possible from subset of 12 | // a[.....index] 13 | // O(n x sum) 14 | int subsetSum(int index, int sum) { 15 | 16 | // no elements left for sum 17 | if (index == -1) return (sum == 0); 18 | 19 | if (memo[index][sum] != -1) return memo[index][sum]; 20 | 21 | bool ans = false; 22 | // include a[index] in sum 23 | if (sum >= a[index]) { 24 | ans |= subsetSum(index - 1, sum - a[index]); 25 | } 26 | // exclude a[index] 27 | ans |= subsetSum(index - 1, sum); 28 | 29 | return memo[index][sum] = ans; 30 | } 31 | 32 | int main() 33 | { 34 | freopen("input.txt", "r", stdin); 35 | freopen("output.txt", "w", stdout); 36 | 37 | int sum; 38 | cin >> sum >> n; 39 | 40 | 41 | for (int i = 0; i < n; i++) { 42 | cin >> a[i]; 43 | } 44 | 45 | memo.resize(n, vector(sum + 1, -1)); 46 | cout << subsetSum(n - 1, sum); 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_one_row.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int sum, n; 11 | cin >> sum >> n; 12 | 13 | int a[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | cin >> a[i]; 17 | } 18 | 19 | // O(sum) 20 | bool dp[sum + 1]; 21 | 22 | // one row dp[j] 23 | 24 | dp[0] = true; 25 | 26 | for (int j = 1; j <= sum; j++) { 27 | dp[j] = false; 28 | } 29 | 30 | // O(n*sum) 31 | for (int i = 1; i <= n; i++) { 32 | for (int j = sum; j >= 0; j--) { 33 | 34 | if (j - a[i] >= 0) { 35 | dp[j] |= dp[j - a[i]]; 36 | } 37 | 38 | } 39 | 40 | } 41 | 42 | cout << dp[sum]; 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_one_row_erpeating_values.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int sum, n; 11 | cin >> sum >> n; 12 | 13 | int a[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | cin >> a[i]; 17 | } 18 | 19 | bool dp[sum + 1]; 20 | 21 | // one row dp[j] 22 | 23 | dp[0] = true; 24 | 25 | for (int j = 1; j <= sum; j++) { 26 | dp[j] = false; 27 | } 28 | 29 | // O(n*sum) 30 | for (int i = 1; i <= n; i++) { 31 | for (int j = sum; j >= 0; j--) { 32 | 33 | if (j - a[i] >= 0) { 34 | dp[j] |= dp[j - a[i]]; 35 | } 36 | 37 | } 38 | 39 | } 40 | 41 | cout << dp[sum]; 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | return 0; 54 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_repeating.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1000; 6 | 7 | int a[N], n; 8 | 9 | vector> memo; 10 | 11 | // whether sum is possible from subset of 12 | // a[.....index] 13 | // O(n x sum) 14 | int subsetSumRepeatingNumbers(int index, int sum) { 15 | 16 | // no elements left for sum 17 | if (index == -1) return (sum == 0); 18 | 19 | if (memo[index][sum] != -1) return memo[index][sum]; 20 | 21 | bool ans = false; 22 | // include a[index] in sum multiple times 23 | if (sum >= a[index]) { 24 | ans |= subsetSumRepeatingNumbers(index, sum - a[index]); 25 | } 26 | // exclude a[index] 27 | ans |= subsetSumRepeatingNumbers(index - 1, sum); 28 | 29 | return memo[index][sum] = ans; 30 | } 31 | 32 | int main() 33 | { 34 | freopen("input.txt", "r", stdin); 35 | freopen("output.txt", "w", stdout); 36 | 37 | int sum; 38 | cin >> sum >> n; 39 | 40 | 41 | for (int i = 0; i < n; i++) { 42 | cin >> a[i]; 43 | } 44 | 45 | memo.resize(n, vector(sum + 1, -1)); 46 | cout << subsetSumRepeatingNumbers(n - 1, sum); 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_tabulation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int sum, n; 11 | cin >> sum >> n; 12 | 13 | int a[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | cin >> a[i]; 17 | } 18 | 19 | bool dp[n + 1][sum + 1]; 20 | 21 | dp[0][0] = true; 22 | 23 | for (int j = 1; j <= sum; j++) { 24 | dp[0][j] = false; 25 | } 26 | 27 | for (int i = 1; i <= n; i++) { 28 | for (int j = 0; j <= sum; j++) { 29 | 30 | // exlcusion 31 | dp[i][j] = dp[i - 1][j]; 32 | 33 | // inclusion 34 | if (j - a[i] >= 0) { 35 | dp[i][j] |= dp[i - 1][j - a[i]]; 36 | } 37 | } 38 | } 39 | 40 | // cout << dp[n][sum]; 41 | 42 | 43 | for (int i = 0; i <= n; i++) { 44 | for (int j = 0; j <= sum; j++) { 45 | cout << dp[i][j] << " "; 46 | } cout << '\n'; 47 | } 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_two_rows.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int sum, n; 11 | cin >> sum >> n; 12 | 13 | int a[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | cin >> a[i]; 17 | } 18 | 19 | bool dp[2][sum + 1]; 20 | 21 | // first row dp[0][j] 22 | // second row dp[1][j] 23 | 24 | dp[0][0] = true; 25 | 26 | for (int j = 1; j <= sum; j++) { 27 | dp[0][j] = false; 28 | } 29 | 30 | for (int i = 1; i <= n; i++) { 31 | for (int j = 0; j <= sum; j++) { 32 | // dp[ith] row is 2nd row 33 | dp[1][j] = dp[0][j]; 34 | if (j - a[i] >= 0) { 35 | dp[1][j] |= dp[0][j - a[i]]; 36 | } 37 | } 38 | 39 | // copy 2st row to 0th row 40 | // for next i calculation 41 | for (int j = 0; j <= sum; j++) { 42 | dp[0][j] = dp[1][j]; 43 | } 44 | 45 | } 46 | 47 | cout << dp[1][sum]; 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /C++ Codes/subset_sum_using_bitset.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 13; 6 | 7 | int main() 8 | { 9 | freopen("input.txt", "r", stdin); 10 | freopen("output.txt", "w", stdout); 11 | 12 | int sum, n; 13 | cin >> sum >> n; 14 | 15 | int a[n + 1]; 16 | a[0] = 0; 17 | for (int i = 1; i <= n; i++) { 18 | cin >> a[i]; 19 | } 20 | 21 | bitset bt; 22 | bt[0] = 1; 23 | 24 | // O(n) 25 | for (int i = 1; i <= n; i++) { 26 | bt |= (bt << a[i]); 27 | } 28 | 29 | cout << bt[sum]; 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /C++ Codes/sum_of_digits_spoj.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | string n; 7 | 8 | int memo[10][2][90]; 9 | 10 | int dp(int index, bool last, int sum) { 11 | 12 | if (index == n.size()) { 13 | return sum; 14 | } 15 | 16 | if (memo[index][last][sum] != -1) return memo[index][last][sum]; 17 | 18 | int till = (last ? n[index] - '0' : 9); 19 | int ans = 0; 20 | 21 | for (int digits = 0; digits <= till; digits++) { 22 | ans += dp(index + 1, last && (digits == till), sum + digits); 23 | } 24 | 25 | return memo[index][last][sum] = ans; 26 | } 27 | 28 | int solve(int _n) { 29 | n = to_string(_n); 30 | memset(memo, -1, sizeof(memo)); 31 | return dp(0, true, 0); 32 | } 33 | 34 | int32_t main() 35 | { 36 | freopen("input.txt", "r", stdin); 37 | freopen("output.txt", "w", stdout); 38 | 39 | while (1) { 40 | 41 | int a, b; 42 | cin >> a >> b; 43 | 44 | if (a == -1 && b == -1) break; 45 | 46 | cout << solve(b) - solve(a - 1) << '\n'; 47 | 48 | } 49 | 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /C++ Codes/supw.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | int a[n], dp[n]; 14 | 15 | for (int i = 0; i < n; i++) { 16 | cin >> a[i]; 17 | } 18 | 19 | dp[0] = a[0]; 20 | dp[1] = a[1]; 21 | dp[2] = a[2]; 22 | 23 | for (int i = 3; i < n; i++) { 24 | dp[i] = min({dp[i - 1], dp[i - 2], dp[i - 3]}) + a[i]; 25 | } 26 | 27 | for (int i = 0; i < n; i++) { 28 | cout << dp[i] << " "; 29 | } cout << '\n'; 30 | 31 | cout << min({dp[n - 1], dp[n - 2], dp[n - 3]}); 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /C++ Codes/supw_k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct segmenttree { 6 | vector st; 7 | int n; 8 | void init(int _n) { 9 | n = _n; 10 | st.clear(); 11 | st.resize(4 * _n); 12 | } 13 | void build(int l, int r, int node, int a[]) { 14 | if (l == r) { 15 | st[node] = a[l]; 16 | return; 17 | } 18 | int mid = (l + r) / 2; 19 | build(l, mid, node * 2 + 1, a); 20 | build(mid + 1, r, node * 2 + 2, a); 21 | st[node] = min(st[2 * node + 1], st[2 * node + 2]); 22 | } 23 | 24 | void update(int l, int r, int indup, int val, int node) { 25 | if (l == r) { 26 | st[node] = val; 27 | return; 28 | } 29 | else { 30 | int mid = (l + r) / 2; 31 | if (indup >= l && indup <= mid) { 32 | update(l, mid, indup, val, node * 2 + 1); 33 | } 34 | else { 35 | update(mid + 1, r, indup, val, node * 2 + 2); 36 | } 37 | st[node] = min(st[2 * node + 1], st[2 * node + 2]); 38 | } 39 | } 40 | 41 | int query(int si, int se, int l, int r, int node) { 42 | if (se < l || si > r || l > r) { 43 | return INT_MAX; 44 | } 45 | if (si >= l && se <= r) { 46 | return st[node]; 47 | } 48 | int mid = (si + se) / 2; 49 | int q1 = query(si, mid, l, r, node * 2 + 1); 50 | int q2 = query(mid + 1, se, l, r, node * 2 + 2); 51 | return min(q1, q2); 52 | } 53 | void build(int n, int a[]) { 54 | init(n); 55 | build(0, n - 1, 0, a); 56 | } 57 | int query(int l, int r) { 58 | return query(0, n - 1, l, r, 0); 59 | } 60 | void update(int index, int val) { 61 | update(0, n - 1, index, val, 0); 62 | } 63 | }; 64 | 65 | int main() 66 | { 67 | freopen("input.txt", "r", stdin); 68 | freopen("output.txt", "w", stdout); 69 | 70 | int n, k; 71 | cin >> n >> k; 72 | int a[n], b[n], dp[n]; 73 | for (int i = 0; i < n; i++) { 74 | cin >> a[i]; 75 | b[i] = INT_MAX; 76 | } 77 | 78 | segmenttree H; 79 | 80 | H.build(n, b); 81 | 82 | for (int i = 0; i < k; i++) { 83 | dp[i] = a[i]; 84 | H.update(i, dp[i]); 85 | } 86 | 87 | for (int i = k; i < n; i++) { 88 | int mn = H.query(i - k, i - 1); 89 | dp[i] = mn + a[i]; 90 | H.update(i, dp[i]); 91 | } 92 | 93 | // for (int i = 0; i < n; i++) { 94 | // cout << dp[i] << " "; 95 | // } 96 | 97 | cout << H.query(n - k, n - 1); 98 | 99 | 100 | 101 | 102 | return 0; 103 | } -------------------------------------------------------------------------------- /C++ Codes/tiling_3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | freopen("input.txt", "r", stdin); 8 | freopen("output.txt", "w", stdout); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | int f[n + 1], g[n + 1]; 14 | f[0] = g[0] = 0; 15 | f[1] = g[1] = 1; 16 | f[2] = g[2] = 2; 17 | 18 | for (int i = 3; i <= n; i++) { 19 | f[i] = f[i - 1] + f[i - 2] + 2 * g[i - 2]; 20 | g[i] = g[i - 1] + f[i - 1]; 21 | } 22 | 23 | cout << f[n]; 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C++ Codes/to_do_digit_dp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define int long long int 6 | #define ld long double 7 | #define F first 8 | #define S second 9 | #define pb push_back 10 | 11 | const int N = 100005; 12 | 13 | string s; 14 | int dp[2001][2][2000], m, mod = 1e9 + 7; 15 | 16 | int work(int pos, bool last, int modpro) { 17 | if (pos == s.size()) { 18 | if (modpro == 0) { 19 | return 1; 20 | } 21 | return 0; 22 | } 23 | if (dp[pos][last][modpro] != -1) { 24 | return dp[pos][last][modpro]; 25 | } 26 | int till = (last ? s[pos] - '0' : 9); 27 | int ans = 0; 28 | for (int i = 0; i <= till; i++) { 29 | ans += work(pos + 1, last && (i == s[pos] - '0'), (modpro * 10 + i) % m); 30 | ans %= mod; 31 | } 32 | return dp[pos][last][modpro] = ans % mod; 33 | } 34 | 35 | int solve(int n) { 36 | s = to_string(n); 37 | memset(dp, -1, sizeof(dp)); 38 | int ans = work(0, 1, 0); 39 | return ans; 40 | } 41 | 42 | int32_t main() 43 | { 44 | ios_base:: sync_with_stdio(false); 45 | cin.tie(NULL); cout.tie(NULL); 46 | #ifndef ONLINE_JUDGE 47 | freopen("input.txt", "r", stdin); 48 | freopen("output.txt", "w", stdout); 49 | freopen("debug.txt", "w", stderr); 50 | #endif 51 | int t; cin >> t; while (t--) 52 | { 53 | int i, j, k, n, ans = 0, cnt = 0, sum = 0; 54 | cin >> i >> j >> m; 55 | cout << solve(j) - solve(i - 1); 56 | } 57 | } -------------------------------------------------------------------------------- /C++ Codes/tower_of_hanoi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | void TowerOfHanoi(int n, char from, char helper, char to) { 6 | 7 | if (n == 0) return; 8 | 9 | // cout << n << " " << from << " " << helper << " " << to << '\n'; 10 | 11 | TowerOfHanoi(n - 1, from, to, helper); 12 | // reached here 13 | // nth rod to to 14 | cout << from << " -> " << to << '\n'; 15 | 16 | TowerOfHanoi(n - 1, helper, from, to); 17 | 18 | } 19 | 20 | int main() 21 | { 22 | freopen("input.txt", "r", stdin); 23 | freopen("output.txt", "w", stdout); 24 | 25 | int n; 26 | cin >> n; 27 | 28 | TowerOfHanoi(n, 'A', 'B', 'C'); 29 | 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /C++ Codes/tree_dis_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define int long long int 3 | 4 | using namespace std; 5 | 6 | const int N = 2e5 + 1; 7 | 8 | vector gr[N]; 9 | int g[N], h[N], f[N], n; 10 | 11 | void dfs_g(int cur, int par) { 12 | for (auto x : gr[cur]) { 13 | if (x != par) { 14 | dfs_g(x, cur); 15 | g[cur] += g[x] + h[x]; 16 | h[cur] += h[x]; 17 | } 18 | } 19 | h[cur] += 1; 20 | } 21 | 22 | void dfs_f(int cur, int par, int sum_par) { 23 | 24 | for (auto x : gr[cur]) { 25 | if (x != par) { 26 | 27 | int new_sum_par = sum_par + (n - h[cur]); 28 | 29 | int current_child_values = g[x] + h[x]; 30 | 31 | new_sum_par += (g[cur] - current_child_values); 32 | 33 | dfs_f(x, cur, new_sum_par); 34 | 35 | // for any node in the subtree 36 | f[cur] += (g[x] + h[x]); 37 | } 38 | } 39 | 40 | // for any node in the supertree 41 | // supertree = compliment of subtree 42 | f[cur] += sum_par + (n - h[cur]); 43 | 44 | } 45 | 46 | int32_t main() 47 | { 48 | // freopen("input.txt", "r", stdin); 49 | // freopen("output.txt", "w", stdout); 50 | 51 | cin >> n; 52 | 53 | for (int i = 0; i < n - 1; i++) { 54 | int x, y; 55 | cin >> x >> y; 56 | gr[x].push_back(y); 57 | gr[y].push_back(x); 58 | } 59 | 60 | // O(N) 61 | dfs_g(1, -1); 62 | 63 | // O(N) 64 | dfs_f(1, -1, 0); 65 | 66 | for (int i = 1; i <= n; i++) { 67 | cout << f[i] << " "; 68 | } 69 | 70 | return 0; 71 | } -------------------------------------------------------------------------------- /C++ Codes/vertex_cover_dfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5 + 1; 6 | 7 | vector gr[N]; 8 | int dp[N][2]; 9 | 10 | void dfs(int cur, int par) { 11 | 12 | dp[cur][0] = 0; 13 | dp[cur][1] = 1; 14 | 15 | for (auto x : gr[cur]) { 16 | if (x != par) { 17 | 18 | dfs(x, cur); 19 | // coming back from dfs 20 | // dp[x] wil be filled 21 | 22 | dp[cur][0] += dp[x][1]; 23 | dp[cur][1] += min(dp[x][0], dp[x][1]); 24 | 25 | } 26 | } 27 | 28 | } 29 | 30 | int main() 31 | { 32 | freopen("input.txt", "r", stdin); 33 | freopen("output.txt", "w", stdout); 34 | 35 | int n; 36 | cin >> n; 37 | 38 | // corrected n-1 as edge count 39 | for (int i = 0; i < n - 1; i++) { 40 | int x, y; 41 | cin >> x >> y; 42 | gr[x].push_back(y); 43 | gr[y].push_back(x); 44 | } 45 | 46 | dfs(1, 0); 47 | 48 | cout << min(dp[1][0], dp[1][1]); 49 | 50 | return 0; 51 | } -------------------------------------------------------------------------------- /C++ Codes/vertex_cover_spoj_bfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5 + 1; 6 | 7 | vector gr[N]; 8 | int dp[N][2]; 9 | int vis[N]; 10 | 11 | int main() 12 | { 13 | freopen("input.txt", "r", stdin); 14 | freopen("output.txt", "w", stdout); 15 | 16 | int n, root; 17 | cin >> n; 18 | 19 | // corrected n-1 as edge count 20 | for (int i = 0; i < n - 1; i++) { 21 | int x, y; 22 | cin >> x >> y; 23 | gr[x].push_back(y); 24 | gr[y].push_back(x); 25 | } 26 | 27 | queue Q; 28 | 29 | for (int i = 1; i <= n; i++) { 30 | if (gr[i].size() == 1) Q.push(i); 31 | } 32 | 33 | while (!Q.empty()) { 34 | 35 | int cur = Q.front(); 36 | Q.pop(); 37 | 38 | vis[cur] = 1; 39 | root = cur; 40 | 41 | dp[cur][0] = 0; 42 | dp[cur][1] = 1; 43 | 44 | for (auto x : gr[cur]) { 45 | if (vis[x]) { 46 | // child nodes 47 | dp[cur][0] += dp[x][1]; 48 | dp[cur][1] += min(dp[x][0], dp[x][1]); 49 | } 50 | else { 51 | // parent node 52 | Q.push(x); 53 | } 54 | } 55 | 56 | } 57 | // the node which is visited in the end 58 | cout << min(dp[root][0], dp[root][1]); 59 | 60 | return 0; 61 | } -------------------------------------------------------------------------------- /C++ Codes/vertex_cover_spoj_dp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 1e5 + 1; 6 | 7 | vector gr[N]; 8 | int memo[N][2]; 9 | 10 | int dp(int cur, bool take, int par) { 11 | 12 | if (memo[cur][take] != -1) return memo[cur][take]; 13 | 14 | int ans = take; 15 | for (auto x : gr[cur]) { 16 | if (x != par) { 17 | // x is only the child vertex 18 | if (take) { 19 | ans += min(dp(x, 0, cur), 20 | dp(x, 1, cur)); 21 | } 22 | else { 23 | ans += dp(x, 1, cur); 24 | } 25 | } 26 | } 27 | return memo[cur][take] = ans; 28 | } 29 | 30 | int main() 31 | { 32 | freopen("input.txt", "r", stdin); 33 | freopen("output.txt", "w", stdout); 34 | 35 | int n; 36 | cin >> n; 37 | 38 | // corrected n-1 as edge count 39 | for (int i = 0; i < n - 1; i++) { 40 | int x, y; 41 | cin >> x >> y; 42 | gr[x].push_back(y); 43 | gr[y].push_back(x); 44 | } 45 | 46 | memset(memo, -1, sizeof(memo)); 47 | cout << min(dp(1, 0, -1), dp(1, 1, -1)); 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /C++ Codes/wildcard_pattern_matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | string s, p; 8 | vector> memo; 9 | bool dp(int i, int j) { 10 | if (i == s.size() && j == p.size()) return true; 11 | if (j == p.size()) return false; 12 | // if (i == s.size()) ; 13 | 14 | if (memo[i][j] != -1) return memo[i][j]; 15 | 16 | bool ans = false; 17 | 18 | if (i < s.size() && s[i] == p[j]) { 19 | ans |= dp(i + 1, j + 1); 20 | } 21 | else if (p[j] == '?') { 22 | if (i == s.size()) { 23 | return false; 24 | } 25 | else { 26 | ans |= dp(i + 1, j + 1); 27 | } 28 | } 29 | else if (p[j] == '*') { 30 | if (i < s.size()) { 31 | ans |= dp(i + 1, j); 32 | } 33 | ans |= dp(i, j + 1); 34 | } 35 | return memo[i][j] = ans; 36 | } 37 | bool isMatch(string ss, string pp) { 38 | this->s = ss; 39 | this->p = pp; 40 | memo.resize(ss.size() + 1, vector (pp.size() + 1, -1)); 41 | // 2d array structure filled with -1s 42 | return dp(0, 0); 43 | } 44 | }; 45 | 46 | int main() 47 | { 48 | freopen("input.txt", "r", stdin); 49 | freopen("output.txt", "w", stdout); 50 | 51 | string s, p; 52 | cin >> s >> p; 53 | 54 | Solution H; 55 | cout << H.isMatch(s, p); 56 | 57 | return 0; 58 | } -------------------------------------------------------------------------------- /Java Codes/AlphaCode.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Scanner; 6 | 7 | public class AlphaCode { 8 | 9 | 10 | public static String s; 11 | public static int[] memo; 12 | public static int dp(int i) { 13 | 14 | if (i == s.length()) return 1; 15 | 16 | if (memo[i] != -1) return memo[i]; 17 | 18 | int ans = 0; 19 | if (s.charAt(i) >= '1' && s.charAt(i) <= '9') { 20 | ans += dp(i + 1); 21 | } 22 | 23 | if (i + 1 < s.length() && (s.charAt(i) == '1')) { 24 | ans += dp(i + 2); 25 | } 26 | 27 | if (i + 1 < s.length() && (s.charAt(i) == '2' && s.charAt(i+1) <= '6')) { 28 | ans += dp(i + 2); 29 | } 30 | 31 | return memo[i] = ans; 32 | } 33 | 34 | public static void main(String[] args) { 35 | Scanner scn = new Scanner(System.in); 36 | while (true) { 37 | s = scn.next(); 38 | if (s.charAt(0) == '0') break; 39 | memo = new int[s.length()]; 40 | Arrays.fill(memo, -1); 41 | System.out.println(dp(0)); 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /Java Codes/AutoBiographicalNumber.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | public class AutoBiographicalNumber { 4 | 5 | 6 | 7 | 8 | public static final int N = 20; 9 | 10 | public static int length, num[] = new int[N], cnt[] = new int[N]; 11 | 12 | public static void auto_bio_graphical_number(int index) { 13 | 14 | // base case 15 | if (index == length) { 16 | for (int i = 0; i < length; i++) { 17 | if (num[i] != cnt[i]) return; 18 | } 19 | 20 | for (int i = 0; i < length; i++) { 21 | System.out.print(num[i]); 22 | } 23 | System.out.println(); 24 | 25 | return; 26 | } 27 | 28 | for (int _num = 0; _num < length; _num++) { 29 | num[index] = _num; 30 | cnt[_num]++; 31 | 32 | auto_bio_graphical_number(index + 1); 33 | 34 | // back tracking 35 | cnt[_num]--; 36 | num[index] = -1; 37 | 38 | } 39 | 40 | } 41 | 42 | public static void main(String[] args) { 43 | 44 | length = 4; 45 | auto_bio_graphical_number(0); 46 | 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Java Codes/BestTimeToBuyAndSellStocks.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | 5 | public class BestTimeToBuyAndSellStocks { 6 | 7 | 8 | 9 | static class Solution { 10 | public int memo[][][] = new int[1001][2][101]; 11 | int dp(int i, int buy, int k, int[] prices) { 12 | if (i == prices.length) return 0; 13 | if (memo[i][buy][k] != -1) return memo[i][buy][k]; 14 | // dont buy/sell 15 | int ans = dp(i + 1, buy, k, prices); 16 | if (k == 0) return 0; 17 | // buy 18 | if (buy == 1) { 19 | ans = Math.max(ans, -prices[i] + dp(i + 1, 0, k, prices)); 20 | } 21 | else { 22 | ans = Math.max(ans, prices[i] + dp(i + 1, 1, k - 1, prices)); 23 | } 24 | 25 | return memo[i][buy][k] = ans; 26 | } 27 | int maxProfit(int k, int[] prices) { 28 | for(int i = 0; i < memo.length; i++){ 29 | for(int j = 0; j < memo[0].length; j++){ 30 | Arrays.fill(memo[i][j], -1); 31 | } 32 | } 33 | return dp(0, 1, k, prices); 34 | } 35 | }; 36 | 37 | public static void main(String[] args) { 38 | Solution H = new Solution(); 39 | int[] prices = {3, 2, 6, 5, 0, 3}; 40 | System.out.println(H.maxProfit(2, prices)); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Java Codes/BottomUpVsTopDown.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.HashMap; 4 | import java.util.HashSet; 5 | import java.util.Scanner; 6 | 7 | public class BottomUpVsTopDown { 8 | 9 | 10 | public static HashMap mp = new HashMap<>(); 11 | 12 | // int memo[1e6]; 13 | 14 | public static int dp(int n) { 15 | if (n <= 1) return n; 16 | if (mp.containsKey(n)) 17 | return mp.get(n); 18 | int ans = Math.max(dp(n / 2) + dp(n / 3) + dp(n / 4), n); 19 | mp.put(n, ans); 20 | return ans; 21 | } 22 | 23 | public static void main(String[] args) { 24 | 25 | int n; 26 | Scanner scn = new Scanner(System.in); 27 | 28 | 29 | // // top down 30 | // while ((n = scn.nextInt()) != 0) { 31 | // // cout << n << '\n'; 32 | // 33 | // // bottom up 34 | // 35 | // int[] dp = new int[n+1]; 36 | // dp[0] = 0; 37 | // dp[1] = 1; 38 | // for (int i = 2; i <= n; i++) { 39 | // dp[i] = Math.max(i, dp[i / 2] + dp[i / 3] + dp[i / 4]); 40 | // } 41 | // System.out.println(dp(n)); 42 | // } 43 | 44 | while ((n = scn.nextInt()) != 0) { 45 | System.out.println(dp(n)); 46 | } 47 | 48 | 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /Java Codes/ColorfulKnapsack.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class ColorfulKnapsack { 7 | 8 | public static void main(String[] args) { 9 | 10 | 11 | Scanner scn = new Scanner(System.in); 12 | int j, k, n, m, ans = 0, cnt = 0, sum = 0; 13 | j = scn.nextInt(); 14 | n = scn.nextInt(); 15 | m = scn.nextInt(); 16 | 17 | int[][] dp = new int[105][10005]; 18 | ArrayList[] v = new ArrayList[105]; 19 | int[] a = new int[105]; 20 | for (int i = 0; i < j; i++) { 21 | a[i] = scn.nextInt(); 22 | } 23 | for (int i = 0; i < j; i++) { 24 | int x = scn.nextInt(); 25 | v[x].add(a[i]); 26 | } 27 | for (int x : v[1]) { 28 | dp[1][x]++; 29 | } 30 | for (int i = 1; i < n; i++) { 31 | for (j = 0; j <= m; j++) { 32 | if (dp[i][j] != 0) { 33 | for (int x : v[i + 1]) { 34 | if (j + x <= m) { 35 | dp[i + 1][j + x]++; 36 | } 37 | } 38 | } 39 | } 40 | } 41 | for (j = 1; j <= m; j++) { 42 | if (dp[n][j] != 0) { 43 | ans = Math.max(ans, j); 44 | } 45 | } 46 | if (ans == 0) System.out.println(-1); 47 | else System.out.println(m-ans); 48 | 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /Java Codes/CompanyQueries.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class CompanyQueries { 7 | 8 | 9 | 10 | public static final int N = 200001, M = 20; 11 | 12 | public static ArrayList[] gr = new ArrayList[N]; 13 | public static int[][] Par = new int[N][M]; 14 | 15 | public static void dfs(int cur, int par) { 16 | 17 | Par[cur][0] = par; 18 | for (int j = 1; j < M; j++) { 19 | Par[cur][j] = Par[Par[cur][j - 1]][j - 1]; 20 | } 21 | 22 | for (int x : gr[cur]) { 23 | if (x != par) { 24 | dfs(x, cur); 25 | } 26 | } 27 | } 28 | 29 | public static int giveKthPar(int x, int k) { 30 | 31 | int cur = x; 32 | for (int j = 0; j < M; j++) { 33 | if (((k >> j) & 1) != 0) { 34 | cur = Par[cur][j]; 35 | } 36 | } 37 | 38 | if (cur == 0) cur = -1; 39 | return cur; 40 | 41 | } 42 | 43 | public static void main(String[] args) { 44 | 45 | Scanner scn = new Scanner(System.in); 46 | 47 | int n = scn.nextInt(), q = scn.nextInt(); 48 | 49 | for (int i = 2; i <= n; i++) { 50 | int par = scn.nextInt(); 51 | gr[i].add(par); 52 | gr[par].add(i); 53 | } 54 | 55 | dfs(1, 0); 56 | 57 | // for (int i = 1; i <= n; i++) { 58 | // for (int j = 0; j < 3; j++) { 59 | // System.out.println(i + " " + Math.pow(2, j) + " " + Par[i][j]); 60 | // } 61 | // } 62 | 63 | while (q-- > 0) { 64 | int x = scn.nextInt(), k = scn.nextInt(); 65 | System.out.println(giveKthPar(x, k)); 66 | } 67 | 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /Java Codes/ConsecutiveSequence.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.Scanner; 6 | 7 | public class ConsecutiveSequence { 8 | 9 | public static void main(String[] args) { 10 | 11 | Scanner scn = new Scanner(System.in); 12 | int n = scn.nextInt(); 13 | int[] a = new int[n]; 14 | for (int i = 0; i < n; i++) { 15 | a[i] = scn.nextInt(); 16 | } 17 | HashMap dp = new HashMap<>(); 18 | 19 | for (int i = 0; i < n; i++) { 20 | dp.put(a[i], dp.getOrDefault(a[i]-1, 0) + 1); 21 | } 22 | 23 | int k = 0, start, end = 0; 24 | for (Map.Entry x : dp.entrySet()) { 25 | // x.first 26 | if (k < x.getValue()) end = x.getKey(); 27 | k = Math.max(k, x.getValue()); 28 | } 29 | System.out.println(k); 30 | 31 | start = end - k + 1; 32 | for (int i = 0; i < n; i++) { 33 | if (a[i] == start) { 34 | // zero-based inedxing 35 | System.out.println(i+1); 36 | start++; 37 | } 38 | if (start == end + 1) break; 39 | } 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Java Codes/CountOrdered.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CountOrdered { 6 | 7 | 8 | public static int[] memo = new int[1000]; 9 | public static int countOrdered(int n) { 10 | if (n == 0) return 1; 11 | if (memo[n] != -1) return memo[n]; 12 | int ans = 0; 13 | for (int i = 1; i <= n; i++) { 14 | ans += countOrdered(n - i); 15 | } 16 | return memo[n] = ans; 17 | } 18 | 19 | public static void main(String[] args) { 20 | 21 | Scanner scn = new Scanner(System.in); 22 | int n = scn.nextInt(); 23 | 24 | 25 | // O(n*n) solution 26 | int[] dp = new int[n + 1]; 27 | dp[0] = 1; 28 | 29 | int sum = 0; 30 | for (int i = 1; i <= n; i++) { 31 | dp[i] = sum + 1; 32 | sum += dp[i]; 33 | } 34 | 35 | System.out.println(dp[n]); 36 | 37 | // O(1) 38 | System.out.println(Math.pow(2, n-1)); 39 | 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Java Codes/CountSetBits.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | public class CountSetBits { 4 | public static void main(String[] args) { 5 | 6 | int n = 10; 7 | int[] dp = new int[n + 1]; 8 | dp[0] = 0; 9 | 10 | for (int i = 1; i <= n; i++) { 11 | dp[i] = dp[i / 2] + (i % 2); 12 | System.out.println(dp[i]); 13 | } 14 | // O(n) 15 | 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Java Codes/CountUnordered.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CountUnordered { 6 | 7 | 8 | 9 | // O(n*n*n) after memoisation 10 | public static int countUnordered(int min, int n) { 11 | 12 | if (n == 0) return 1; 13 | 14 | int ans = 0; 15 | for (int i = min; i <= n; i++) { 16 | ans += countUnordered(i, n - i); 17 | } 18 | 19 | return ans; 20 | 21 | } 22 | 23 | public static void main(String[] args) { 24 | 25 | Scanner scn = new Scanner(System.in); 26 | int n = scn.nextInt(); 27 | 28 | 29 | // O(n*n) solution 30 | int[] dp = new int[n + 1]; 31 | dp[0] = 1; 32 | 33 | for (int i = 1; i <= n; i++) { 34 | 35 | for (int j = i; j <= n; j++) { 36 | dp[j] += dp[j - i]; 37 | } 38 | 39 | for (int k = 0; k <= n; k++) { 40 | System.out.print(dp[k] + " "); 41 | } 42 | System.out.println(); 43 | } 44 | 45 | System.out.println(dp[n]); 46 | 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Java Codes/CountUnorderedTwo.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CountUnorderedTwo { 6 | 7 | 8 | 9 | // O(n*n*n) after memoisation 10 | public static int countUnordered(int min, int n) { 11 | 12 | if (n == 0) return 1; 13 | 14 | int ans = 0; 15 | for (int i = min; i <= n; i++) { 16 | ans += countUnordered(i, n - i); 17 | } 18 | 19 | return ans; 20 | 21 | } 22 | 23 | // O(n*n) 24 | public static int countUnordered2(int min, int n) { 25 | 26 | // memoise 27 | 28 | if (n == 0) return 1; 29 | if (min > n) return 0; 30 | if (min == n) return 1; 31 | 32 | // included in the partition 33 | int ans = countUnordered2(min, n - min) 34 | // exluded in the partition 35 | + countUnordered2(min + 1, n); 36 | 37 | return ans; 38 | 39 | } 40 | 41 | 42 | 43 | public static void main(String[] args) { 44 | 45 | Scanner scn = new Scanner(System.in); 46 | int n = scn.nextInt(); 47 | 48 | 49 | for (int i = 0; i <= 20; i++) { 50 | System.out.println(countUnordered(1, i)); 51 | } 52 | for (int i = 0; i <= 20; i++) { 53 | System.out.println(countUnordered2(1, i)); 54 | } 55 | 56 | // O(n*n) solution 57 | int[] dp = new int[n + 1]; 58 | dp[0] = 1; 59 | 60 | for (int i = 1; i <= n; i++) { 61 | 62 | for (int j = i; j <= n; j++) { 63 | dp[j] += dp[j - i]; 64 | } 65 | 66 | for (int k = 0; k <= n; k++) { 67 | System.out.print(dp[k] + " "); 68 | } 69 | System.out.println(); 70 | } 71 | 72 | System.out.println(dp[n]); 73 | 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /Java Codes/Diameter.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class Diameter { 7 | 8 | final static int N = (int) (2e5 + 1); 9 | 10 | static ArrayList[] gr = new ArrayList[N]; 11 | static int f[] = new int[N], g[] = new int[N]; 12 | 13 | 14 | public static void dfs(int cur, int par) { 15 | int max_1 = 0, max_2 = 0; 16 | 17 | for (int x : gr[cur]) { 18 | if (x != par) { 19 | dfs(x, cur); 20 | 21 | // g for the cur node 22 | g[cur] = Math.max(g[x] + 1, g[cur]); 23 | f[cur] = Math.max(f[x], f[cur]); 24 | 25 | // max 2 values of g[x] 26 | if (g[x] + 1 > max_1) { 27 | max_2 = max_1; 28 | max_1 = g[x] + 1; 29 | } 30 | else if (g[x] + 1 > max_2) { 31 | max_2 = g[x] + 1; 32 | } 33 | } 34 | } 35 | 36 | f[cur] = Math.max(f[cur], max_1 + max_2); 37 | 38 | } 39 | 40 | public static void main(String[] args) { 41 | 42 | Scanner scn = new Scanner(System.in); 43 | int n = scn.nextInt(); 44 | 45 | for (int i = 0; i < n - 1; i++) { 46 | int x = scn.nextInt(), y = scn.nextInt(); 47 | gr[x].add(y); 48 | gr[y].add(x); 49 | } 50 | 51 | dfs(1, -1); 52 | 53 | System.out.println(f[1]); 54 | 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Java Codes/DistanceTreeOne.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class DistanceTreeOne { 7 | 8 | final static int N = (int) (2e5 + 1); 9 | 10 | static ArrayList[] gr = new ArrayList[N]; 11 | static int f[] = new int[N], g[] = new int[N]; 12 | 13 | 14 | static void dfs_g(int cur, int par) { 15 | for (int x : gr[cur]) { 16 | if (x != par) { 17 | dfs_g(x, cur); 18 | g[cur] = Math.max(g[cur], g[x] + 1); 19 | } 20 | } 21 | } 22 | 23 | static void dfs_f(int cur, int par, int dis_par) { 24 | 25 | int max_1 = -1, max_2 = -1; 26 | 27 | for (int x : gr[cur]) { 28 | if (x != par) { 29 | if (g[x] > max_1) { 30 | max_2 = max_1; 31 | max_1 = g[x]; 32 | } 33 | else if (g[x] > max_2) 34 | max_2 = g[x]; 35 | } 36 | } 37 | 38 | for (int x : gr[cur]) { 39 | if (x != par) { 40 | 41 | int new_dis_par = dis_par; 42 | 43 | // for (auto y : gr[cur]) { 44 | // if (y != par && y != x) { 45 | // new_dis_par = max(g[y], new_dis_par); 46 | // } 47 | // } 48 | 49 | if (g[x] == max_1) 50 | new_dis_par = Math.max(new_dis_par, max_2); 51 | else 52 | new_dis_par = Math.max(new_dis_par, max_1); 53 | 54 | dfs_f(x, cur, new_dis_par + 1); 55 | 56 | // for any node in the subtree 57 | f[cur] = Math.max(f[cur], g[x] + 1); 58 | } 59 | } 60 | 61 | // for any node in the supertree 62 | // supertree = compliment of subtree 63 | f[cur] = Math.max(f[cur], dis_par + 1); 64 | 65 | } 66 | 67 | public static void main(String[] args) { 68 | 69 | Scanner scn = new Scanner(System.in); 70 | int n = scn.nextInt(); 71 | 72 | for (int i = 0; i < n - 1; i++) { 73 | int x = scn.nextInt(), y = scn.nextInt(); 74 | gr[x].add(y); 75 | gr[y].add(x); 76 | } 77 | 78 | dfs_g(1, -1); 79 | 80 | 81 | // O(N) 82 | dfs_f(1, -1, -1); 83 | 84 | for (int i = 1; i <= n; i++) { 85 | System.out.println(f[i]); 86 | } 87 | 88 | 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /Java Codes/EditDistance.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class EditDistance { 7 | 8 | 9 | 10 | static String a, b; 11 | 12 | static int[][] memo = new int[2000][2000]; 13 | 14 | static int edit_distance(int i, int j) { 15 | if (i == a.length() && j == b.length()) return 0; 16 | if (i == a.length()) return (b.length() - j); 17 | if (j == b.length()) return (a.length() - i); 18 | 19 | if (memo[i][j] != -1) return memo[i][j]; 20 | 21 | // i 0) { 37 | a = scn.next(); 38 | b = scn.next(); 39 | 40 | for(int i = 0; i < 2000; i++){ 41 | Arrays.fill(memo[i], -1); 42 | } 43 | 44 | System.out.println(edit_distance(0,0)); 45 | } 46 | 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Java Codes/ElevatorProblem.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | class Pair{ 6 | int first, second; 7 | Pair(int a, int b){ 8 | first = a; 9 | second = b; 10 | } 11 | } 12 | public class ElevatorProblem { 13 | 14 | public static Pair min(Pair a, Pair b) { 15 | if(a.first < b.first){ 16 | return a; 17 | } 18 | if(b.first < a.first){ 19 | return b; 20 | } 21 | if(a.second < b.second){ 22 | return a; 23 | } 24 | return b; 25 | } 26 | 27 | public static void main(String[] args) { 28 | 29 | Scanner scanner = new Scanner(System.in); 30 | int x = scanner.nextInt(), n = scanner.nextInt(); 31 | 32 | int[] weight = new int[n]; 33 | 34 | for (int i = 0; i < n; i++) { 35 | weight[i] =scanner.nextInt(); 36 | } 37 | 38 | Pair[] dp = new Pair[(1 << n)]; 39 | // dp[mask].first = f[mask] = rides 40 | // dp[mask].second = g[mask] = weight 41 | 42 | dp[0] = new Pair(1, 0); 43 | 44 | for (int mask = 1; mask < 1 << n; mask++) { 45 | dp[mask] = new Pair(n, 0); 46 | for (int y = 0; y < n; y++) { 47 | if (((mask >> y) & 1) != 0) { 48 | int new_mask = mask ^ (1 << y); 49 | Pair option = dp[new_mask]; 50 | // include yth person 51 | if (option.second + weight[y] <= x) { 52 | option.first = option.first; 53 | option.second += weight[y]; 54 | } 55 | else { 56 | // exclude the yth person 57 | // new ride with y 58 | option.first++; 59 | option.second = weight[y]; 60 | } 61 | dp[mask] = min(dp[mask], option); 62 | } 63 | } 64 | } 65 | 66 | System.out.println(dp[(1< 0) { 46 | if ((n & 1) != 0) res = res.multiply(T); 47 | T = T.multiply(T); 48 | n /= 2; 49 | } 50 | 51 | return (res.m[0][0] + res.m[0][1]) % mod; 52 | } 53 | 54 | public static void main(String[] args) { 55 | Scanner scn = new Scanner(System.in); 56 | int t = scn.nextInt(); 57 | while (t-- > 0) { 58 | int n = scn.nextInt(), m = scn.nextInt(); 59 | System.out.println((Fib(m+2) - Fib(n+1) + mod) % mod); 60 | } 61 | 62 | 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /Java Codes/FibonacciSum.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class FibonacciSum { 7 | 8 | 9 | static final int mod = (int) (1e9 + 7); 10 | static final int sz = 3; 11 | 12 | static class Mat { 13 | int[][] m = new int[sz][sz]; 14 | 15 | void identity() { 16 | for (int i = 0; i < sz; i++) { 17 | m[i][i] = 1; 18 | } 19 | } 20 | 21 | Mat multiply (Mat a) { 22 | Mat res = new Mat(); 23 | for (int i = 0; i < sz; i++) { 24 | for (int j = 0; j < sz; j++) { 25 | for (int k = 0; k < sz; k++) { 26 | res.m[i][j] += m[i][k] * a.m[k][j]; 27 | res.m[i][j] %= mod; 28 | } 29 | } 30 | } 31 | return res; 32 | } 33 | } 34 | 35 | static int Fibosum(int n) { 36 | // base case 37 | if (n == -1) return 0; 38 | if (n == 0) return 0; 39 | if (n == 1) return 1; 40 | 41 | Mat res = new Mat(); 42 | res.identity(); 43 | Mat T = new Mat(); 44 | T.m[0][0] = T.m[0][1] = T.m[0][2] = 1; 45 | T.m[1][1] = T.m[1][2] = 1; 46 | T.m[2][1] = 1; 47 | 48 | // n >= 2 49 | n -= 1; 50 | 51 | // log(n) 52 | while (n > 0) { 53 | if ((n & 1) != 0) res = res.multiply(T); 54 | T = T.multiply(T); 55 | n /= 2; 56 | } 57 | 58 | return (res.m[0][0] + res.m[0][1]) % mod; 59 | } 60 | 61 | public static void main(String[] args) { 62 | Scanner scn = new Scanner(System.in); 63 | int t = scn.nextInt(); 64 | while (t-- > 0) { 65 | int n = scn.nextInt(), m = scn.nextInt(); 66 | System.out.println((Fibosum(m) - Fibosum(n-1) + mod) % mod); 67 | } 68 | 69 | 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /Java Codes/GoodSequence.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Scanner; 6 | 7 | public class GoodSequence { 8 | 9 | 10 | 11 | static final int N = (int) (1e5 + 1); 12 | 13 | static int[] dp_prime = new int[N]; 14 | 15 | // O(sqrt(n)) 16 | static ArrayList give_prime_divisors(int n) { 17 | ArrayList div = new ArrayList<>(); 18 | for (int i = 2; i * i <= n; i++) { 19 | if (n % i == 0) { 20 | div.add(i); 21 | while (n % i == 0) n /= i; 22 | } 23 | } 24 | if (n > 1) div.add(n); 25 | return div; 26 | } 27 | 28 | public static void main(String[] args) { 29 | 30 | Scanner scn = new Scanner(System.in); 31 | int n = scn.nextInt(); 32 | 33 | int[] a = new int[n]; 34 | 35 | for (int i = 0; i < n; i++) { 36 | a[i] = scn.nextInt(); 37 | } 38 | 39 | 40 | for (int i = 0; i < n; i++) { 41 | ArrayList prime_div = give_prime_divisors(a[i]); 42 | 43 | int best_ending = 0; 44 | for (int x : prime_div) { 45 | best_ending = Math.max(best_ending, dp_prime[x]); 46 | } 47 | 48 | for (int x : prime_div) { 49 | dp_prime[x] = best_ending + 1; 50 | } 51 | } 52 | 53 | System.out.println(maxElement(dp_prime)); 54 | 55 | 56 | } 57 | 58 | private static int maxElement(int[] dp_prime) { 59 | int ans = Integer.MIN_VALUE; 60 | for(int x: dp_prime){ 61 | ans = Math.max(ans, x); 62 | } 63 | return ans; 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /Java Codes/HamiltonPathBacktrack.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class HamiltonPathBacktrack { 7 | 8 | 9 | final static int N = (int) (2e5 + 1); 10 | 11 | static ArrayList[] gr = new ArrayList[N]; 12 | static int vis[] = new int[N]; 13 | 14 | static int n, m; 15 | 16 | static boolean hamiltonian_path = false; 17 | 18 | // bool paths() 19 | 20 | // O(number_of_hamiltonian_paths) 21 | static void paths(int cur, int cnt) { 22 | if (cnt == n) { 23 | hamiltonian_path = true; 24 | return; 25 | } 26 | 27 | vis[cur] = 1; 28 | 29 | for (int x : gr[cur]) { 30 | if (vis[x] == 0) { 31 | paths(x, cnt + 1); 32 | } 33 | } 34 | 35 | // backtracking 36 | vis[cur] = 0; 37 | return; 38 | } 39 | 40 | public static void main(String[] args) { 41 | 42 | Scanner scn = new Scanner(System.in); 43 | int n = scn.nextInt(); 44 | 45 | for (int i = 0; i < n - 1; i++) { 46 | int x = scn.nextInt(), y = scn.nextInt(); 47 | gr[x].add(y); 48 | gr[y].add(x); 49 | } 50 | 51 | for (int i = 0; i < n; i++) { 52 | paths(i, 1); 53 | } 54 | 55 | System.out.println(hamiltonian_path); 56 | 57 | 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /Java Codes/HamiltonPathBottomUp.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class HamiltonPathBottomUp { 7 | 8 | public static void main(String[] args) { 9 | 10 | Scanner scn = new Scanner(System.in); 11 | int n = scn.nextInt(); 12 | 13 | ArrayList[] gr = new ArrayList[n]; 14 | for (int i = 0; i < n - 1; i++) { 15 | int x = scn.nextInt(), y = scn.nextInt(); 16 | gr[x].add(y); 17 | gr[y].add(x); 18 | } 19 | 20 | 21 | int[][] dp = new int[n][1 << n]; 22 | 23 | 24 | for (int i = 0; i < n; i++) { 25 | dp[i][1 << i] = 1; 26 | } 27 | 28 | for (int mask = 0; mask < (1 << n); mask++) { 29 | for (int cur = 0; cur < n; cur++) { 30 | if (dp[cur][mask] != 0) { 31 | for (int x : gr[cur]) { 32 | if (((mask >> x) & 1) == 0) { 33 | dp[x][mask | (1 << x)] = 1; 34 | } 35 | } 36 | } 37 | } 38 | } 39 | 40 | boolean ans = false; 41 | 42 | for (int i = 0; i < n; i++) { 43 | ans |= (dp[i][(1 << n) - 1] == 1); 44 | } 45 | 46 | System.out.println(ans); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /Java Codes/HamiltonPathRecursiveMemo.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.HashSet; 6 | import java.util.Scanner; 7 | 8 | 9 | public class HamiltonPathRecursiveMemo { 10 | 11 | static class Pair{ 12 | int first; 13 | HashSet second; 14 | 15 | public Pair(int first, HashSet second) { 16 | this.first = first; 17 | this.second = second; 18 | } 19 | } 20 | 21 | final static int N = 10; 22 | 23 | static ArrayList[] gr = new ArrayList[N]; 24 | static int vis[] = new int[N]; 25 | 26 | static int n, m; 27 | 28 | static boolean hamiltonian_path = false; 29 | 30 | 31 | static HashMap mp = new HashMap<>(); 32 | 33 | static boolean dp(int cur, HashSet St) { 34 | 35 | if (St.size() == n) { 36 | return true; 37 | } 38 | if (mp.containsKey(new Pair(cur, St))) { 39 | return mp.get(new Pair(cur, St)); 40 | } 41 | 42 | boolean ans = false; 43 | for (int x : gr[cur]) { 44 | if (!St.contains(x)) { 45 | 46 | HashSet temp = new HashSet<>(St); 47 | temp.add(x); 48 | 49 | ans |= dp(x, temp); 50 | } 51 | } 52 | 53 | mp.put(new Pair(cur, St), ans); 54 | return ans; 55 | 56 | } 57 | 58 | public static void main(String[] args) { 59 | 60 | Scanner scn = new Scanner(System.in); 61 | int n = scn.nextInt(); 62 | int m = scn.nextInt(); 63 | 64 | for (int i = 0; i < m; i++) { 65 | int x = scn.nextInt(), y = scn.nextInt(); 66 | gr[x].add(y); 67 | gr[y].add(x); 68 | } 69 | boolean hamiltonian_path = false; 70 | 71 | for (int i = 0; i < n; i++) { 72 | HashSet St = new HashSet<>(); 73 | St.add(i); 74 | hamiltonian_path |= dp(i, St); 75 | } 76 | 77 | 78 | System.out.println(hamiltonian_path); 79 | 80 | 81 | } 82 | 83 | 84 | } 85 | -------------------------------------------------------------------------------- /Java Codes/HamiltonPathUsingBitmask.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.HashSet; 6 | import java.util.Scanner; 7 | 8 | public class HamiltonPathUsingBitmask { 9 | 10 | final static int N = 10; 11 | 12 | static ArrayList[] gr = new ArrayList[N]; 13 | 14 | static int[][] memo = new int[N][1 << N]; 15 | 16 | static int n, m; 17 | 18 | static boolean dp(int cur, int mask) { 19 | if (mask == (1 << n) - 1) { 20 | return true; 21 | } 22 | 23 | if (memo[cur][mask] != -1) { 24 | return memo[cur][mask] != 0; 25 | } 26 | 27 | boolean ans = false; 28 | for (int x : gr[cur]) { 29 | // xth bit of mask is set or not 30 | if (((mask >> x) & 1) == 0) { 31 | ans |= dp(x, mask | (1 << x)); 32 | } 33 | } 34 | 35 | memo[cur][mask] = ans ? 1 : 0; 36 | 37 | return ans; 38 | } 39 | 40 | 41 | public static void main(String[] args) { 42 | 43 | Scanner scn = new Scanner(System.in); 44 | int n = scn.nextInt(); 45 | int m = scn.nextInt(); 46 | 47 | for (int i = 0; i < m; i++) { 48 | int x = scn.nextInt(), y = scn.nextInt(); 49 | gr[x].add(y); 50 | gr[y].add(x); 51 | } 52 | for (int i = 0; i < memo.length; i++) { 53 | Arrays.fill(memo[i], -1); 54 | 55 | } 56 | 57 | boolean hamiltonian_path = false; 58 | 59 | for (int i = 0; i < n; i++) { 60 | hamiltonian_path |= dp(i, (1 << i)); 61 | } 62 | 63 | 64 | System.out.println(hamiltonian_path); 65 | 66 | 67 | } 68 | 69 | 70 | 71 | } 72 | -------------------------------------------------------------------------------- /Java Codes/InterleavingStrings.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class InterleavingStrings { 7 | 8 | 9 | static class Solution { 10 | String s1, s2, s3; 11 | int[][] memo; 12 | boolean dp(int i, int j) { 13 | 14 | 15 | int k = i + j; 16 | if (k == s3.length()) return true; 17 | 18 | if (memo[i][j] != -1) return memo[i][j] != 0; 19 | 20 | boolean ans = false; 21 | if (i < s1.length() && s1.charAt(i) == s3.charAt(k)) { 22 | ans |= dp(i + 1, j); 23 | } 24 | 25 | if (j < s2.length() && s2.charAt(i) == s3.charAt(k)) { 26 | ans |= dp(i, j + 1); 27 | } 28 | 29 | memo[i][j] = ans ? 1 : 0; 30 | return ans; 31 | 32 | } 33 | boolean isInterleave(String s1, String s2, String s3) { 34 | this.s1 = s1; 35 | this.s2 = s2; 36 | this.s3 = s3; 37 | if (s1.length() + s2.length() != s3.length()) return false; 38 | memo = new int[s1.length()+1][s2.length()+1]; 39 | for(int i = 0; i < memo.length; i++){ 40 | Arrays.fill(memo[i] , -1); 41 | } 42 | return dp(0, 0); 43 | } 44 | }; 45 | 46 | public static void main(String[] args) { 47 | Scanner scanner = new Scanner(System.in); 48 | String s1 = scanner.next(), s2 =scanner.next(), s3 = scanner.next(); 49 | 50 | 51 | Solution H = new Solution(); 52 | System.out.println(H.isInterleave(s1, s2, s3)); 53 | } 54 | 55 | 56 | 57 | } 58 | -------------------------------------------------------------------------------- /Java Codes/InvestigationCode.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class InvestigationCode { 7 | 8 | 9 | static String n; 10 | static int a, b, k; 11 | 12 | // 10 * 2 * 100 * 100 states 13 | static int[][][][] memo = new int[10][2][90][90]; 14 | 15 | static int solver(int index, boolean last, int sum_mod, int sum_dig_mod) { 16 | 17 | if (index == n.length()) { 18 | if (sum_mod == 0 && sum_dig_mod == 0) { 19 | return 1; 20 | } 21 | return 0; 22 | } 23 | 24 | if (memo[index][last ? 1 : 0][sum_mod][sum_dig_mod] != -1) { 25 | return memo[index][last ? 1 : 0][sum_mod][sum_dig_mod]; 26 | } 27 | 28 | int till = (last ? n.charAt(index) - '0' : 9); 29 | int ans = 0; 30 | 31 | for (int digits = 0; digits <= till; digits++) { 32 | ans += solver(index + 1, last && (digits == till), 33 | (sum_mod * 10 + digits) % k, 34 | (sum_dig_mod + digits) % k); 35 | } 36 | 37 | return memo[index][last ? 1 : 0][sum_mod][sum_dig_mod] = ans; 38 | 39 | } 40 | 41 | static int f(int _n) { 42 | if (k > 90) return 0; 43 | n = String.valueOf(_n); 44 | for(int i = 0; i < memo.length; i++){ 45 | for(int j = 0; j < memo[i].length; j++){ 46 | for(int ij = 0; ij < memo[i][j].length; ij++){ 47 | Arrays.fill(memo[i][j][ij], -1); 48 | } 49 | } 50 | } 51 | return solver(0, true, 0, 0); 52 | } 53 | 54 | public static void main(String[] args) { 55 | 56 | // dont forget to add case ? 57 | // Case 1: 58 | // Case 2: 59 | 60 | Scanner scn = new Scanner(System.in); 61 | int t = scn.nextInt(); 62 | while (t-- > 0) { 63 | a = scn.nextInt(); 64 | b = scn.nextInt(); 65 | k = scn.nextInt(); 66 | System.out.println(f(b) - f(a-1)); 67 | 68 | } 69 | 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /Java Codes/Knapsack.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Knapsack { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | int size = scanner.nextInt(), n = scanner.nextInt(); 12 | 13 | 14 | int[] s = new int[n + 1], v = new int[n + 1]; 15 | for (int i = 1; i <= n; i++) { 16 | s[i] = scanner.nextInt(); 17 | v[i] = scanner.nextInt(); 18 | } 19 | 20 | int[] dp = new int[size + 1]; 21 | 22 | for (int i = 1; i <= n; i++) { 23 | for (int j = size; j >= 0; j--) { 24 | if (j - s[i] >= 0) dp[j] = Math.max(dp[j], dp[j - s[i]] + v[i]); 25 | } 26 | } 27 | 28 | System.out.println(dp[size]); 29 | 30 | 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /Java Codes/KnapsackRecursion.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | public class KnapsackRecursion { 4 | 5 | 6 | 7 | static final int N = 2001; 8 | 9 | int[] s = new int[N], v = new int[N]; 10 | int[][] memo = new int[N][N]; 11 | 12 | // O(n*size) 13 | int knapsack(int index, int size) { 14 | if (index == 0) return 0; 15 | 16 | int ans = memo[index][size]; 17 | 18 | if (ans != -1) return ans; 19 | ans = 0; 20 | 21 | // include 22 | if (s[index] <= size) { 23 | ans = v[index] + knapsack(index - 1, size - s[index]); 24 | } 25 | // exclude 26 | ans = Math.max(ans, knapsack(index - 1, size)); 27 | memo[index][size] = ans; 28 | return ans; 29 | 30 | } 31 | 32 | 33 | } 34 | -------------------------------------------------------------------------------- /Java Codes/LCS_unmemoised.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class LCS_unmemoised { 6 | 7 | 8 | 9 | static String s, t; 10 | 11 | static int lcs(int i, int j) { 12 | if (i == s.length() && j == t.length()) return 0; 13 | if (i == s.length()) return 0; 14 | if (j == t.length()) return 0; 15 | 16 | int ans = 0; 17 | if (s.charAt(i) == t.charAt(j)) { 18 | ans = 1 + lcs(i + 1, j + 1); 19 | } 20 | else { 21 | ans = Math.max(lcs(i, j + 1), lcs(i + 1, j)); 22 | } 23 | 24 | return ans; 25 | } 26 | 27 | public static void main(String[] args) { 28 | 29 | Scanner scn = new Scanner(System.in); 30 | s = scn.next(); 31 | t = scn.next(); 32 | 33 | System.out.println(lcs(0,0)); 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /Java Codes/LIS.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class LIS { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scn = new Scanner(System.in); 10 | 11 | int n = scn.nextInt(); 12 | int a[] = new int[n]; 13 | int dp[] = new int[n]; 14 | 15 | for (int i = 0; i < n; i++) { 16 | a[i] = scn.nextInt(); 17 | dp[i] = 1; 18 | } 19 | 20 | // O(n*n) 21 | for (int i = 0; i < n; i++) { 22 | 23 | // dp[i] -> lis if it ends on ith index 24 | for (int j = 0; j < i; j++) { 25 | 26 | if (a[j] <= a[i]) { 27 | dp[i] = Math.max(dp[i], dp[j] + 1); 28 | } 29 | 30 | } 31 | } 32 | 33 | int lis = 1; 34 | 35 | for (int i = 0; i < n; i++) { 36 | // cout << a[i] << " " << dp[i] << '\n'; 37 | lis = Math.max(lis, dp[i]); 38 | } 39 | 40 | System.out.println(lis); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Java Codes/LIS_nlogn.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.Comparator; 6 | import java.util.Scanner; 7 | 8 | public class LIS_nlogn { 9 | 10 | 11 | 12 | static class fenwick { 13 | int[] fn; 14 | int n; 15 | fenwick() {} 16 | fenwick(int n) { 17 | init(n); 18 | } 19 | void init(int _n) { 20 | n = _n + 10; 21 | fn = new int[n]; 22 | } 23 | // log(n) 24 | void update(int x, int val) { 25 | x++;// 1 based indexing 26 | while (x < n) { 27 | fn[x] = Math.max(fn[x], val); 28 | x += (x & (-x)); 29 | } 30 | } 31 | // log(n) 32 | int query(int x) { 33 | x++;//1 basaed indexing 34 | int ans = 0; 35 | while (x > 0) { 36 | ans = Math.max(ans, fn[x]); 37 | x -= (x & (-x)); 38 | } 39 | return ans; 40 | } 41 | } 42 | 43 | public static void main(String[] args) { 44 | 45 | 46 | Scanner scn = new Scanner(System.in); 47 | 48 | int n = scn.nextInt(); 49 | int a[] = new int[n]; 50 | int dp[] = new int[n]; 51 | ArrayList b = new ArrayList<>(); 52 | 53 | for (int i = 0; i < n; i++) { 54 | a[i] = scn.nextInt(); 55 | b.add(new Pair(a[i], 1)); 56 | } 57 | 58 | 59 | 60 | 61 | fenwick H = new fenwick(n); 62 | 63 | int[] lis = new int[n]; 64 | 65 | b.sort(new Comparator() { 66 | @Override 67 | public int compare(Pair o1, Pair o2) { 68 | if(o1.first == o2.first){ 69 | return o1.second - o2.second; 70 | } 71 | return o1.first - o2.first; 72 | } 73 | }); 74 | 75 | for (int i = 0; i < n; i++) { 76 | int val = b.get(i).first; 77 | int index = b.get(i).second; 78 | 79 | lis[index] = H.query(index - 1) + 1; 80 | 81 | H.update(index, lis[index]); 82 | } 83 | 84 | // for (int i = 0; i < n; i++) { 85 | // cout << lis[i] << " "; 86 | // } 87 | 88 | // n logn 89 | System.out.println(H.query(n-1)); 90 | 91 | // inversion count 92 | 93 | 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /Java Codes/LIS_todo.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class LIS_todo { 7 | 8 | 9 | static String n, m; 10 | 11 | static int[][][][][] memo1 = new int[11][2][2][11][11]; 12 | 13 | static int combination(int index, boolean first, boolean last, int prev, int len) { 14 | 15 | // cout << prev << " " << len << '\n'; 16 | 17 | if (index == n.length()) { 18 | if (len == 0) return 1; 19 | return 0; 20 | } 21 | 22 | if (memo1[index][first ? 1 : 0][last ? 1 : 0][prev][len] != -1) { 23 | return memo1[index][first ? 1 : 0][last ? 1 : 0][prev][len]; 24 | } 25 | 26 | int start = (first ? n.charAt(index) - '0' : 0); 27 | int till = (last ? m.charAt(index) - '0' : 9); 28 | int ans = 0; 29 | 30 | 31 | for (int digits = start; digits <= till; digits++) { 32 | ans += combination(index + 1, first && (digits == start), last && (digits == till), prev, len); 33 | if (digits > prev) { 34 | ans += combination(index + 1, first && (digits == start), last && (digits == till), digits, len - 1); 35 | } 36 | } 37 | 38 | return memo1[index][first ? 1 : 0][last ? 1 : 0][prev][len] = ans; 39 | 40 | } 41 | 42 | static int solver(int _n, int _m, int len) { 43 | n = String.valueOf(_n); 44 | m = String.valueOf(_m); 45 | int diff = m.length() - n.length(); 46 | while (diff-- > 0) { 47 | n = "0" + n; 48 | } 49 | for(int i = 0; i < memo1.length; i++){ 50 | for(int ii = 0; ii < memo1[i].length; ii++){ 51 | for(int iii = 0 ; iii < memo1[i][ii].length; iii++){ 52 | for(int i4 = 0; i4 < memo1[i][ii][iii].length; i4++){ 53 | Arrays.fill(memo1[i][ii][iii][i4], -1); 54 | } 55 | } 56 | } 57 | } 58 | return combination(0, true, true, 0, len); 59 | } 60 | 61 | public static void main(String[] args) { 62 | Scanner scn = new Scanner(System.in); 63 | int t = scn.nextInt(); 64 | 65 | for (int i = 1; i <= t; i++) { 66 | 67 | int a = scn.nextInt(), b = scn.nextInt(); 68 | 69 | for (int len = 10; len >= 0; len--) { 70 | if (solver(a, b, len) != 0) { 71 | System.out.println("Case " + i + ": " + len + " " + solver(a, b, len)); 72 | break; 73 | } 74 | } 75 | 76 | } 77 | 78 | 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /Java Codes/MagicNumber.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class MagicNumber { 7 | 8 | 9 | static int m, d, mod = (int) (1e9 + 7); 10 | static String n; 11 | 12 | // memoisation 13 | static int[][][] memo = new int[2000][2][2000]; 14 | 15 | static int dp(int index, boolean last, int dig_mod) { 16 | 17 | if (index == n.length()) { 18 | return dig_mod == 0 ? 1 : 0; 19 | } 20 | 21 | if (memo[index][last ? 1 : 0][dig_mod] != -1) return memo[index][last ? 1 : 0][dig_mod]; 22 | 23 | int till = (last ? n.charAt(index) - '0' : 9); 24 | int ans = 0; 25 | 26 | if (index % 2 == 1) { 27 | // even position 28 | if (d <= till) { 29 | ans += dp(index + 1, last && (d == till), (dig_mod * 10 + d) % m); 30 | ans %= mod; 31 | } 32 | } 33 | else { 34 | // odd positions 35 | for (int digits = 0; digits <= till; digits++) { 36 | // odd position cannot place d 37 | if (digits == d) continue; 38 | ans += dp(index + 1, last && (digits == till), (dig_mod * 10 + digits) % m); 39 | ans %= mod; 40 | } 41 | } 42 | return memo[index][last ? 1 : 0][dig_mod] = ans; 43 | } 44 | 45 | 46 | static int solve(String _n) { 47 | n = _n; 48 | for(int i = 0 ; i < memo.length; i++){ 49 | for(int j = 0; j < memo[i].length; i++){ 50 | Arrays.fill(memo, -1); 51 | } 52 | } 53 | return dp(0, true, 0); 54 | } 55 | 56 | public static void main(String[] args) { 57 | Scanner scn = new Scanner(System.in); 58 | m = scn.nextInt(); 59 | d = scn.nextInt(); 60 | 61 | StringBuilder a = new StringBuilder(scn.next()), b = new StringBuilder(scn.next()); 62 | 63 | int i = a.length() - 1; 64 | 65 | while (i >= 0 && a.charAt(i) == '0') { 66 | a.setCharAt(i, '9'); 67 | i--; 68 | } 69 | 70 | a.setCharAt(i, (char) (a.charAt(i)-1)); 71 | 72 | // cout << a << '\n'; 73 | 74 | // a = a - 1; 75 | System.out.println( (solve(b.toString()) - solve(a.toString()) + mod) % mod); 76 | 77 | 78 | 79 | 80 | 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /Java Codes/MakeFenceGreatAgain.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MakeFenceGreatAgain { 6 | 7 | 8 | 9 | static final int N = 300005; 10 | 11 | public static void main(String[] args) { 12 | 13 | Scanner sn = new Scanner(System.in); 14 | int t = sn.nextInt(); 15 | 16 | while (t-- > 0) { 17 | int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 18 | n = sn.nextInt(); 19 | int[] a = new int[n], b = new int[n]; 20 | for (i = 0; i < n; i++) { 21 | a[i] = sn.nextInt(); 22 | b[i] = sn.nextInt(); 23 | } 24 | long[][] dp = new long[n][3] ; 25 | for (i = 0; i < n; i++) { 26 | dp[i][0] = dp[i][1] = dp[i][2] = (long) 1e18; 27 | } 28 | dp[0][0] = 0; dp[0][1] = b[0]; dp[0][2] = 2L * b[0]; 29 | for (i = 1; i < n; i++) { 30 | for (j = 0; j < 3; j++) { 31 | for (k = 0; k < 3; k++) { 32 | if (a[i - 1] + j != a[i] + k) { 33 | dp[i][k] = Math.min(dp[i][k], dp[i - 1][j] + (long) k * b[i]); 34 | } 35 | } 36 | } 37 | } 38 | System.out.println(Math.min(dp[n-1][0], Math.min(dp[n-1][1], dp[n-1][2]))); 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Java Codes/MakeFenceGreatAgainRec.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MakeFenceGreatAgainRec { 6 | 7 | 8 | 9 | static final int N = 300005; 10 | static int n; 11 | static int[] a = new int[N], b = new int[N]; 12 | 13 | static long[][] dp = new long[N][3] ; 14 | 15 | 16 | static long solve(int pos, int prev, int state) { 17 | if (pos == n) return 0; 18 | if (dp[pos][state] != -1) return dp[pos][state]; 19 | long ans = (int) 1e18; 20 | if (a[pos] != prev) { 21 | ans = Math.min(ans, solve(pos + 1, a[pos], 0)); 22 | } 23 | if (a[pos] + 1 != prev) { 24 | ans = Math.min(ans, b[pos] + solve(pos + 1, a[pos] + 1, 1)); 25 | } 26 | if (a[pos] + 2 != prev) { 27 | ans = Math.min(ans, 2L * b[pos] + solve(pos + 1, a[pos] + 2, 2)); 28 | } 29 | return dp[pos][state] = ans; 30 | } 31 | 32 | public static void main(String[] args) { 33 | 34 | Scanner sn = new Scanner(System.in); 35 | int t = sn.nextInt(); 36 | 37 | while (t-- > 0) { 38 | int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 39 | n = sn.nextInt(); 40 | 41 | for (i = 0; i < n; i++) { 42 | a[i] = sn.nextInt(); 43 | b[i] = sn.nextInt(); 44 | } 45 | 46 | 47 | for (i = 0; i <= n; i++) { 48 | for (j = 0; j < 3; j++) { 49 | dp[i][j] = -1; 50 | } 51 | } 52 | System.out.println( Math.min(solve(0, -1, 0), Math.min(solve(0, -1, 1), solve(0, -1, 2)))); 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /Java Codes/MinimumStepsToReachOne.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class MinimumStepsToReachOne { 7 | 8 | 9 | final static int N = (int) 1e5; 10 | 11 | static int[] memo = new int[N]; 12 | 13 | static int dp(int n) { 14 | if (n == 1) return 0; 15 | 16 | int ans = memo[n]; 17 | 18 | if (ans != -1) return ans; 19 | memo[n] = Integer.MAX_VALUE; 20 | ans = memo[n]; 21 | 22 | if (n % 2 == 0) { 23 | ans = Math.min(ans, dp(n / 2)); 24 | } 25 | if (n % 3 == 0) { 26 | ans = Math.min(ans, dp(n / 3)); 27 | } 28 | ans = Math.min(ans, dp(n - 1)); 29 | ans += 1; 30 | 31 | return ans; 32 | } 33 | 34 | public static void main(String[] args) { 35 | 36 | Scanner scn = new Scanner(System.in); 37 | int n = scn.nextInt(); 38 | Arrays.fill(memo, -1); 39 | 40 | System.out.println(dp(n)); 41 | 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Java Codes/New.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class New { 7 | 8 | 9 | static final int N = 16; 10 | static int[][] a = new int[N][N]; 11 | static int n; 12 | static int[] memo = new int[(1 << N)]; 13 | 14 | static int dp(int mask) { 15 | if (memo[mask] != -1) return memo[mask]; 16 | int ans = 0; 17 | for (int i = 0; i < n; i++) { 18 | for (int j = 0; j < n; j++) { 19 | if (i == j) continue; 20 | if (((mask >> i) & 1) == 1) continue; 21 | if (((mask >> j) & 1) == 1) continue; 22 | ans = Math.max(ans, dp(mask ^ (1 << i) ^ (1 << j)) + a[i][j]); 23 | } 24 | } 25 | return memo[mask] = ans; 26 | } 27 | 28 | public static void main(String[] args) { 29 | 30 | Scanner scn = new Scanner(System.in); 31 | n = scn.nextInt(); 32 | for (int i = 0; i < n; i++) { 33 | for (int j = 0; j < n; j++) { 34 | a[i][j] = scn.nextInt(); 35 | } 36 | } 37 | Arrays.fill(memo, -1); 38 | System.out.println(dp(0)); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Java Codes/New2.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class New2 { 7 | 8 | 9 | static final int N = (int) (2e5 + 1); 10 | 11 | static ArrayList[] gr = new ArrayList[N]; 12 | 13 | static int[] g = new int[N], h = new int[N], f = new int[N]; 14 | static int n; 15 | 16 | static void dfs_g(int cur, int par) { 17 | for (int x : gr[cur]) { 18 | if (x != par) { 19 | dfs_g(x, cur); 20 | g[cur] += g[x] + h[x]; 21 | h[cur] += h[x]; 22 | } 23 | } 24 | h[cur] += 1; 25 | } 26 | 27 | static void dfs_f(int cur, int par, int sum_par) { 28 | 29 | // cout << cur << " " << par << " " << sum_par << '\n'; 30 | 31 | for (int x : gr[cur]) { 32 | if (x != par) { 33 | 34 | int new_sum_par = sum_par + (n - h[cur]); 35 | new_sum_par += (g[cur] - g[x] - h[x]); 36 | 37 | dfs_f(x, cur, new_sum_par); 38 | 39 | // for any node in the subtree 40 | f[cur] += g[x] + h[x]; 41 | } 42 | } 43 | 44 | // for any node in the supertree 45 | // supertree = compliment of subtree 46 | f[cur] += sum_par + (n - h[cur]); 47 | 48 | } 49 | 50 | public static void main(String[] args) { 51 | 52 | Scanner scn = new Scanner(System.in); 53 | n = scn.nextInt(); 54 | 55 | for (int i = 0; i < n - 1; i++) { 56 | int x = scn.nextInt(), y = scn.nextInt(); 57 | 58 | gr[x].add(y); 59 | gr[y].add(x); 60 | } 61 | 62 | // O(N) 63 | dfs_g(1, -1); 64 | 65 | // O(N) 66 | dfs_f(1, -1, 0); 67 | 68 | for (int i = 1; i <= n; i++) { 69 | System.out.println(f[i]); 70 | } 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /Java Codes/NoConsecOnes.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | public class NoConsecOnes { 4 | 5 | 6 | 7 | // one represents whether 8 | // the number at previous index is one 9 | static int fun(int index, int n, boolean previous_one) { 10 | 11 | // base case 12 | if (index == n + 1) return 1; 13 | 14 | int ans = 0; 15 | 16 | // either place 0 here 17 | ans += fun(index + 1, n, false); 18 | 19 | // or place 1 here 20 | if (!previous_one) { 21 | ans += fun(index + 1, n, true); 22 | } 23 | 24 | return ans; 25 | // ans for array [index.....n] 26 | } 27 | 28 | public static void main(String[] args) { 29 | 30 | 31 | for (int i = 1; i <= 10; i++) { 32 | System.out.println( fun(1, i, false)); 33 | } 34 | 35 | 36 | // fibonacci series 37 | // 1,1,2,3,5,8 ..... 38 | // ans = fib(n+2) 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Java Codes/O_N_KnapSack.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class O_N_KnapSack { 6 | 7 | 8 | public static void main(String[] args) { 9 | 10 | Scanner scn = new Scanner(System.in); 11 | int size = scn.nextInt(), n = scn.nextInt(); 12 | int[] s = new int[n + 1], v = new int[n + 1]; 13 | 14 | for (int i = 1; i <= n; i++) { 15 | s[i] = scn.nextInt(); 16 | v[i] = scn.nextInt(); 17 | } 18 | 19 | int[] dp = new int[size + 1]; 20 | 21 | 22 | 23 | for (int i = 1; i <= n; i++) { 24 | 25 | // 0/N knapsack 26 | for (int j = 0; j <= size; j++) { 27 | if (j - s[i] >= 0) dp[j] = Math.max(dp[j], dp[j - s[i]] + v[i]); 28 | } 29 | } 30 | 31 | System.out.println(dp[size]); 32 | 33 | 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /Java Codes/OptimalSelection.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class OptimalSelection { 7 | public static void main(String[] args) { 8 | 9 | 10 | Scanner scn = new Scanner(System.in); 11 | int k = scn.nextInt(), n = scn.nextInt(); 12 | int[][] price = new int[k][n]; 13 | long[][] dp = new long[1<> x) & 1) == 1) { 38 | // unset jth bit of mask 39 | int new_mask = mask ^ (1 << x); 40 | dp[mask][d] = Math.min(dp[mask][d], 41 | dp[new_mask][d - 1] + price[x][d]); 42 | } 43 | } 44 | } 45 | } 46 | 47 | System.out.println(dp[(1 << k) - 1][n - 1]); 48 | 49 | 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /Java Codes/OrderedPair.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class OrderedPair { 7 | 8 | 9 | static int[] memo = new int[1000]; 10 | 11 | // O(n*n) 12 | static int countWaysOrdered(int n) { 13 | if (n == 0) return 1; 14 | if (memo[n] != -1) return memo[n]; 15 | int ans = 0; 16 | 17 | // for (i....n) 18 | for (int i = 1; i <= n; i++) { 19 | ans += countWaysOrdered(n - i); 20 | } 21 | 22 | return memo[n] = ans; 23 | } 24 | 25 | public static void main(String[] args) { 26 | 27 | Scanner scn = new Scanner(System.in); 28 | int n = scn.nextInt(); 29 | 30 | Arrays.fill(memo, -1); 31 | 32 | System.out.println(countWaysOrdered(n)); 33 | 34 | // bottom up approach 35 | // O(n) 36 | int sum = 0; 37 | int[] dp = new int[n + 1]; 38 | 39 | for (int i = 1; i <= n; i++) { 40 | dp[i] = sum + 1; 41 | sum += dp[i]; 42 | } 43 | 44 | System.out.println(dp[n]); 45 | 46 | // 2^(n-1) 47 | // O(1) 48 | System.out.println(Math.pow(2, n - 1)); 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /Java Codes/PaintHouse.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class PaintHouse { 6 | 7 | public static void main(String[] args) { 8 | 9 | 10 | Scanner scn = new Scanner(System.in); 11 | int n = scn.nextInt(); 12 | 13 | int[][] cost = new int[3][n]; 14 | 15 | for (int i = 0; i < n; i++) { 16 | cost[0][i] = scn.nextInt(); 17 | } 18 | for (int i = 0; i < n; i++) { 19 | cost[1][i] = scn.nextInt(); 20 | } 21 | for (int i = 0; i < n; i++) { 22 | cost[2][i] = scn.nextInt(); 23 | } 24 | 25 | int[][] dp = new int[3][n]; 26 | 27 | dp[0][0] = cost[0][0]; 28 | dp[1][0] = cost[1][0]; 29 | dp[2][0] = cost[2][0]; 30 | 31 | for (int j = 1; j < n; j++) { 32 | dp[0][j] = dp[1][j] = dp[2][j] = Integer.MAX_VALUE; 33 | 34 | // for (int i = 0; i < 3; i++) { 35 | // for (int i_ = 0; i_ < 3; i_++) { 36 | // if (i != i_) { 37 | // dp[i][j] = min(dp[i_][j - 1] + cost[i][j]); 38 | // } 39 | // } 40 | // } 41 | 42 | dp[0][j] = Math.min(dp[2][j - 1], dp[1][j - 1]) + cost[0][j]; 43 | dp[1][j] = Math.min(dp[0][j - 1], dp[2][j - 1]) + cost[1][j]; 44 | dp[2][j] = Math.min(dp[0][j - 1], dp[1][j - 1]) + cost[2][j]; 45 | } 46 | 47 | System.out.println(Math.min(dp[0][n-1], Math.min(dp[1][n-1],dp[2][n-1]))); 48 | 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /Java Codes/PalindromicPartitioning.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.*; 4 | 5 | public class PalindromicPartitioning { 6 | 7 | 8 | 9 | static class Solution { 10 | 11 | String s; 12 | HashMap>> mp = new HashMap<>(); 13 | 14 | boolean is_palindrome(int i, int j) { 15 | while (i <= j) { 16 | if (s.charAt(i)!= s.charAt(j)) return false; 17 | i++; j--; 18 | } 19 | return true; 20 | } 21 | 22 | List> dp(int i) { 23 | 24 | if (i == s.length()) return new ArrayList<>(); 25 | 26 | if (mp.containsKey(i)) 27 | return mp.get(i); 28 | 29 | List> ans = new ArrayList<>(); 30 | 31 | for (int j = i; j < s.length(); j++) { 32 | if (is_palindrome(i, j)) { 33 | 34 | List> res = dp(j + 1); 35 | List> res1 = new ArrayList<>(); 36 | String substring = s.substring(i, j+1); 37 | 38 | 39 | for (int idx =0 ; idx < res.size(); idx++) { 40 | res1.add(new ArrayList<>(res.get(idx))); 41 | } 42 | for (int idx =0 ; idx < res1.size(); idx++) { 43 | res1.get(idx).add(0, substring); 44 | } 45 | 46 | if (res1.isEmpty()) { 47 | res1.add(new ArrayList<>(Arrays.asList(substring))); 48 | } 49 | 50 | ans.addAll(res1); 51 | } 52 | 53 | } 54 | 55 | mp.put(i, ans); 56 | return ans; 57 | } 58 | 59 | List> partition(String s) { 60 | this.s = s; 61 | return dp(0); 62 | } 63 | }; 64 | 65 | public static void main(String[] args) { 66 | 67 | 68 | Scanner scn = new Scanner(System.in); 69 | String s = "aab"; 70 | 71 | 72 | Solution H = new Solution(); 73 | List> res = H.partition(s); 74 | 75 | for (List x : res) { 76 | for (String y : x) { 77 | System.out.print(y + " "); 78 | } 79 | System.out.println(); 80 | } 81 | 82 | 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /Java Codes/PalindromicPartitioning2.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class PalindromicPartitioning2 { 7 | 8 | 9 | static class Solution { 10 | 11 | String s; 12 | int[][] memo; 13 | int[] memo1; 14 | 15 | // memoising? 16 | // O(n*n) 17 | boolean is_palindrome(int i, int j) { 18 | if (i == j) return true; 19 | if (i == j - 1) return (s.charAt(i) == s.charAt(j)); 20 | if (memo[i][j] != -1) return memo[i][j] == 1; 21 | boolean ans = is_palindrome(i + 1, j - 1) && (s.charAt(i) == s.charAt(j)); 22 | memo[i][j] = ans ? 1: 0; 23 | return ans; 24 | } 25 | 26 | // states O(n) 27 | int dp(int i) { 28 | if (i == s.length()) return 0; 29 | 30 | if (memo1[i] != -1) return memo1[i]; 31 | 32 | int ans = Integer.MAX_VALUE; 33 | // O(n) 34 | for (int j = i; j < s.length(); j++) { 35 | if (is_palindrome(i, j)) { 36 | ans = Math.min(ans, dp(j + 1)); 37 | } 38 | } 39 | ans += 1; 40 | return memo1[i] = ans; 41 | } 42 | 43 | int minCut(String s) { 44 | this.s = s; 45 | int n = s.length(); 46 | memo = new int[n][n]; 47 | for(int i = 0 ; i = n - k) return a[cur]; 24 | else return (long) -1e18; 25 | } 26 | int i; 27 | long ans = (long) -1e18; 28 | for (i = cur + 1; i < n && i <= cur + k; i++) { 29 | ans = Math.max(ans, a[cur] + dp(i, rem - 1)); 30 | } 31 | return memo[cur][rem] = ans; 32 | } 33 | 34 | static void solve() { 35 | int i, j; 36 | long ans = 0, cnt = 0, sum = 0; 37 | n = scn.nextInt(); 38 | m = scn.nextInt(); 39 | k = scn.nextInt(); 40 | for (i = 0; i < n; i++) { 41 | a[i] = scn.nextInt(); 42 | } 43 | ans = (int) -1e18; 44 | for (i = 0; i < k; i++) { 45 | ans = Math.max(ans, dp(i, m)); 46 | // cout << i << " " << dp(i, m) << '\n'; 47 | } 48 | if (ans < 0) ans = -1; 49 | System.out.println(ans); 50 | return ; 51 | } 52 | 53 | public static void main(String[] args) { 54 | solve(); 55 | } 56 | // 1879965082 57 | } 58 | -------------------------------------------------------------------------------- /Java Codes/PictureWithKittenHard.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class PictureWithKittenHard { 6 | 7 | 8 | 9 | final static int N = 5005; 10 | 11 | static int n, k, m; 12 | static int[] a = new int[N]; 13 | static Scanner scn = new Scanner(System.in); 14 | 15 | static class sparse_table { 16 | long[][] mat;// 0 based indexing 17 | int n, m; // size and log 18 | int[] p2;//log2 19 | void init(int _n, int _m) { 20 | n = _n; m = _m; 21 | mat = new long[n][m]; 22 | p2 = new int[n+1]; 23 | 24 | for (int i = 2; i <= n; i++) p2[i] = p2[i / 2] + 1; 25 | } 26 | void build(long a[]) { 27 | int i, j; 28 | for (i = 0; i < n; i++) mat[i][0] = a[i]; 29 | for (j = 1; j < m; j++) { 30 | for (i = 0; i + (1 << j) <= n; i++) { 31 | mat[i][j] = Math.max(mat[i][j - 1], mat[i + (1 << (j - 1))][j - 1]); 32 | } 33 | } 34 | } 35 | long query(int l, int r) { 36 | int pw = p2[r - l]; 37 | return Math.max(mat[l][pw], mat[r - (1 << pw) + 1][pw]); 38 | } 39 | } 40 | 41 | static sparse_table table = new sparse_table(); 42 | 43 | static void solve() { 44 | int i, j ; 45 | long ans = 0, cnt = 0, sum = 0; 46 | n = scn.nextInt(); 47 | k = scn.nextInt(); 48 | m = scn.nextInt(); 49 | 50 | for (i = 0; i < n; i++) { 51 | a[i] = scn.nextInt(); 52 | } 53 | long[] dp = new long[n]; 54 | for (i = 0; i < n; i++) { 55 | if (i >= n - k) dp[i] = a[i]; 56 | else dp[i] = (long) -1e16; 57 | } 58 | table.init(n, 13); 59 | for (j = 2; j <= m; j++) { 60 | table.build(dp); 61 | for (i = 0; i < n - 1; i++) { 62 | dp[i] = a[i] + table.query(i + 1, Math.min(i + k, n - 1)); 63 | } 64 | dp[n - 1] = (long) -1e16; 65 | } 66 | ans = (long) -1e16; 67 | for (i = 0; i < k; i++) { 68 | ans = Math.max(ans, dp[i]); 69 | } 70 | if (ans < 0) ans = -1; 71 | System.out.println(ans); 72 | return ; 73 | } 74 | 75 | public static void main(String[] args) { 76 | solve(); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /Java Codes/Plates.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Plates { 6 | 7 | 8 | 9 | static Scanner scn = new Scanner(System.in); 10 | static int solve() { 11 | int n = scn.nextInt(), k = scn.nextInt(), p = scn.nextInt(); 12 | 13 | int[][] a = new int[n+1][k+1]; 14 | int[][] pref = new int[n+1][k+1]; 15 | 16 | for (int i = 1; i <= n; i++) { 17 | for (int j = 1; j <= k; j++) { 18 | a[i][j] = scn.nextInt(); 19 | pref[i][j] = pref[i][j - 1] + a[i][j]; 20 | } 21 | } 22 | 23 | int[][] dp = new int[n+1][p+1]; 24 | 25 | 26 | for (int i = 1; i <= n; i++) { 27 | for (int j = 1; j <= p; j++) { 28 | // dp[i][j] 29 | // pick j plates from first i rows 30 | for (int x = 0; x <= Math.min(k, j); x++) { 31 | dp[i][j] = Math.max(dp[i][j], pref[i][x] + 32 | dp[i - 1][j - x]); 33 | } 34 | } 35 | } 36 | return dp[n][p]; 37 | } 38 | 39 | public static void main(String[] args) { 40 | 41 | int t, z = 1; 42 | t = scn.nextInt(); 43 | while (z <= t) { 44 | System.out.println("Case #" + z++ + ": " + solve()); 45 | } 46 | 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Java Codes/Prac.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Prac { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scn = new Scanner(System.in); 10 | int n = scn.nextInt(), m = scn.nextInt(); 11 | 12 | int[] a = new int[n], b= new int[n], c= new int[m], d= new int[m]; 13 | for (int i = 0; i < n; i++) { 14 | a[i] = scn.nextInt(); 15 | b[i] = scn.nextInt(); 16 | } 17 | for (int i = 0; i < m; i++) { 18 | c[i] = scn.nextInt(); 19 | d[i] = scn.nextInt(); 20 | } 21 | 22 | for (int j = 0; j < m; j++) { 23 | int cnt = 0; 24 | for (int i = 0; i < n; i++) { 25 | cnt += Math.abs(a[i] - c[j]) + Math.abs(b[i] - d[j]); 26 | } 27 | System.out.println(cnt); 28 | } 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /Java Codes/RecursionSimpleDigitDp.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class RecursionSimpleDigitDp { 6 | 7 | 8 | static String s; 9 | 10 | static void fun(String ans, int index, boolean last) { 11 | 12 | if (index == s.length()) { 13 | System.out.println(ans); 14 | return; 15 | } 16 | 17 | int till = (last ? (s.charAt(index) - '0') : 9); 18 | 19 | for (int i = 0; i <= till; i++) { 20 | fun(ans + i, index + 1, (last && (i == till)) ); 21 | } 22 | 23 | } 24 | 25 | public static void main(String[] args) { 26 | 27 | Scanner scn = new Scanner(System.in); 28 | s = scn.next(); 29 | 30 | fun("", 0, true); 31 | 32 | 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Java Codes/RegularExpressionMatching.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class RegularExpressionMatching { 7 | 8 | 9 | 10 | static class Solution { 11 | String s, p; 12 | int[][] memo; 13 | boolean dp(int i, int j) { 14 | if (i == s.length() && j == p.length()) return true; 15 | if (j == p.length()) return false; 16 | // memoisation 17 | boolean ans = memo[i][j] == 1; 18 | if (ans) return ans; 19 | memo[i][j] = 0; 20 | ans = false; 21 | 22 | if (j + 1 < p.length() && p.charAt(j+1) == '*') { 23 | // when character matches due to * 24 | if (i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.')) { 25 | ans |= dp(i + 1, j); 26 | } 27 | // no character matches 28 | ans |= dp(i, j + 2); 29 | } 30 | else { 31 | if (i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.')) { 32 | ans |= dp(i + 1, j + 1); 33 | } 34 | } 35 | 36 | memo[i][j] = ans ? 1: 0; 37 | return ans; 38 | } 39 | boolean isMatch(String s, String p) { 40 | this.s = s; 41 | this.p = p; 42 | memo = new int[s.length()+1][p.length()+1]; 43 | for(int i = 0; i < memo.length; i++){ 44 | Arrays.fill(memo[i] , -1); 45 | } 46 | return dp(0, 0); 47 | } 48 | }; 49 | 50 | public static void main(String[] args) { 51 | 52 | Scanner scn = new Scanner(System.in); 53 | String s = scn.next(), p = scn.next(); 54 | 55 | 56 | Solution H = new Solution(); 57 | 58 | System.out.println(H.isMatch(s, p)); 59 | 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /Java Codes/RoadCutting.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class RoadCutting { 7 | 8 | 9 | static int[] memo = new int[100000]; 10 | 11 | // Space Complexity -> O(n) 12 | // Time complexity -> O(n*n) 13 | static int rodCutting(int n, int prices[]) { 14 | if (n == 0) return 0; 15 | 16 | if (memo[n] != -1) return memo[n]; 17 | 18 | // O(n) extra work inside each state 19 | int ans = 0; 20 | for (int i = 1; i <= n; i++) { 21 | ans = Math.max(ans, prices[i] + rodCutting(n - i, prices)); 22 | } 23 | 24 | return memo[n] = ans; 25 | } 26 | 27 | public static void main(String[] args) { 28 | 29 | Scanner scanner = new Scanner(System.in); 30 | int n = scanner.nextInt(); 31 | int[] prices = new int[n + 1]; 32 | 33 | for (int i = 1; i <= n; i++) { 34 | prices[i] = scanner.nextInt(); 35 | } 36 | 37 | Arrays.fill(memo, -1); 38 | System.out.println(rodCutting(n, prices)); 39 | 40 | 41 | 42 | 43 | 44 | 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /Java Codes/SPP.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SPP { 6 | 7 | 8 | 9 | static final int N = 100005; 10 | 11 | static int mod; 12 | 13 | static final int M = 20; 14 | static int sz; 15 | 16 | static class Mat { 17 | int[][] m = new int[M][M]; 18 | 19 | void eye() 20 | { 21 | for (int i = 0; i < sz; i++) 22 | m[i][i] = 1; 23 | } 24 | 25 | Mat multiply( Mat a) { 26 | Mat r = new Mat(); 27 | for (int i = 0; i < sz; i++) 28 | for (int j = 0; j < sz; j++) 29 | for (int k = 0; k < sz; k++) 30 | r.m[i][j] = (r.m[i][j] + m[i][k] * a.m[k][j]) % mod; 31 | return r; 32 | } 33 | } 34 | 35 | static int solve(int b[], int c[], int e, int n) 36 | { 37 | Mat r = new Mat(), a = new Mat(); 38 | r.eye(); 39 | a.m[0][0] = 1; 40 | for (int i = 1; i < sz; i++) { 41 | a.m[0][i] = c[i - 1]; 42 | a.m[1][i] = c[i - 1]; 43 | } 44 | for (int i = 2; i < sz; i++) { 45 | a.m[i][i - 1] = 1; 46 | } 47 | while (e != 0) { 48 | if ((e & 1) == 1) 49 | r = r.multiply(a); 50 | a = a.multiply(a); 51 | e >>= 1; 52 | } 53 | int ans = 0; 54 | for (int i = 0; i < n; i++) { 55 | ans += b[i]; 56 | } 57 | ans = r.m[0][0] * ans; 58 | ans %= mod; 59 | for (int i = 1; i < sz; i++) { 60 | ans += r.m[0][i] * b[n - i]; 61 | ans %= mod; 62 | } 63 | return ans; 64 | } 65 | 66 | static int give(int k, int b[], int c[], int n) { 67 | if (k < n) { 68 | int ans = 0; 69 | for (int i = 0; i <= k; i++) { 70 | ans += b[i]; 71 | ans %= mod; 72 | } 73 | return ans; 74 | } 75 | else { 76 | return solve(b, c, k - n + 1, n) ; 77 | } 78 | } 79 | 80 | public static void main(String[] args) { 81 | 82 | Scanner scanner = new Scanner(System.in); 83 | 84 | int t = scanner.nextInt(); 85 | while (t-- > 0) { 86 | int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; 87 | n = scanner.nextInt(); 88 | sz = n + 1; 89 | int[] b = new int[n], c = new int[n]; 90 | for (i = 0; i < n; i++) { 91 | b[i] = scanner.nextInt(); 92 | } 93 | for (i = 0; i < n; i++) { 94 | c[i] = scanner.nextInt(); 95 | } 96 | int l, r; 97 | l = scanner.nextInt(); 98 | r = scanner.nextInt(); 99 | mod = scanner.nextInt(); 100 | 101 | System.out.println((give(r, b, c, n) - give(l - 1, b, c, n) + mod) % mod); 102 | } 103 | } 104 | } 105 | -------------------------------------------------------------------------------- /Java Codes/SUPW.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SUPW { 6 | 7 | public static void main(String[] args) { 8 | 9 | 10 | Scanner scn = new Scanner(System.in); 11 | 12 | int n = scn.nextInt(); 13 | 14 | int[] a = new int[n], dp = new int[n]; 15 | 16 | for (int i = 0; i < n; i++) { 17 | a[i] = scn.nextInt(); 18 | } 19 | 20 | dp[0] = a[0]; 21 | dp[1] = a[1]; 22 | dp[2] = a[2]; 23 | 24 | for (int i = 3; i < n; i++) { 25 | dp[i] = Math.min(Math.min(dp[i - 1], dp[i - 2]), dp[i - 3]) + a[i]; 26 | } 27 | 28 | for (int i = 0; i < n; i++) { 29 | System.out.print(dp[i] + " "); 30 | } 31 | System.out.println(); 32 | 33 | System.out.println(Math.min(Math.min(dp[n - 1], dp[n - 2]), dp[n - 3])); 34 | 35 | 36 | 37 | 38 | 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Java Codes/SUPW_k.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SUPW_k { 6 | 7 | 8 | static class segmenttree { 9 | int[] st; 10 | int n; 11 | void init(int _n) { 12 | n = _n; 13 | st = new int[4 * _n]; 14 | } 15 | void build(int l, int r, int node, int a[]) { 16 | if (l == r) { 17 | st[node] = a[l]; 18 | return; 19 | } 20 | int mid = (l + r) / 2; 21 | build(l, mid, node * 2 + 1, a); 22 | build(mid + 1, r, node * 2 + 2, a); 23 | st[node] = Math.min(st[2 * node + 1], st[2 * node + 2]); 24 | } 25 | 26 | void update(int l, int r, int indup, int val, int node) { 27 | if (l == r) { 28 | st[node] = val; 29 | return; 30 | } 31 | else { 32 | int mid = (l + r) / 2; 33 | if (indup >= l && indup <= mid) { 34 | update(l, mid, indup, val, node * 2 + 1); 35 | } 36 | else { 37 | update(mid + 1, r, indup, val, node * 2 + 2); 38 | } 39 | st[node] = Math.min(st[2 * node + 1], st[2 * node + 2]); 40 | } 41 | } 42 | 43 | int query(int si, int se, int l, int r, int node) { 44 | if (se < l || si > r || l > r) { 45 | return Integer.MAX_VALUE; 46 | } 47 | if (si >= l && se <= r) { 48 | return st[node]; 49 | } 50 | int mid = (si + se) / 2; 51 | int q1 = query(si, mid, l, r, node * 2 + 1); 52 | int q2 = query(mid + 1, se, l, r, node * 2 + 2); 53 | return Math.min(q1, q2); 54 | } 55 | void build(int n, int a[]) { 56 | init(n); 57 | build(0, n - 1, 0, a); 58 | } 59 | int query(int l, int r) { 60 | return query(0, n - 1, l, r, 0); 61 | } 62 | void update(int index, int val) { 63 | update(0, n - 1, index, val, 0); 64 | } 65 | } 66 | 67 | public static void main(String[] args) { 68 | 69 | Scanner scn = new Scanner(System.in); 70 | int n = scn.nextInt(), k = scn.nextInt(); 71 | int[] a = new int[n], b = new int[n], dp = new int[n]; 72 | 73 | for (int i = 0; i < n; i++) { 74 | a[i] = scn.nextInt(); 75 | b[i] = Integer.MAX_VALUE; 76 | } 77 | 78 | segmenttree H = new segmenttree(); 79 | 80 | H.build(n, b); 81 | 82 | for (int i = 0; i < k; i++) { 83 | dp[i] = a[i]; 84 | H.update(i, dp[i]); 85 | } 86 | 87 | for (int i = k; i < n; i++) { 88 | int mn = H.query(i - k, i - 1); 89 | dp[i] = mn + a[i]; 90 | H.update(i, dp[i]); 91 | } 92 | 93 | // for (int i = 0; i < n; i++) { 94 | // cout << dp[i] << " "; 95 | // } 96 | 97 | System.out.println(H.query(n-k, n-1)); 98 | } 99 | } 100 | -------------------------------------------------------------------------------- /Java Codes/SplitArrayLargestSum.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | 5 | public class SplitArrayLargestSum { 6 | 7 | 8 | static class Solution { 9 | 10 | int[][] memo; 11 | int dp(int i, int[] nums, int m) { 12 | if (i == nums.length) { 13 | if (m == 0) return 0; 14 | return (int) 1e9; 15 | } 16 | if (m <= 0) return (int) 1e9; 17 | // i>=0 && i0 18 | // I can make partitions 19 | if (memo[i][m] != -1) return memo[i][m]; 20 | int ans = (int) 1e9, sum = 0; 21 | for (int j = i; j < nums.length; j++) { 22 | // i....j 23 | sum += nums[j]; 24 | ans = Math.min(ans, Math.max(sum, dp(j + 1, nums, m - 1))); 25 | } 26 | return memo[i][m] = ans; 27 | } 28 | int splitArray(int[] nums, int m) { 29 | memo = new int[nums.length+1][m+1]; 30 | for(int i = 0; i < memo.length; i++){ 31 | Arrays.fill(memo[i], -1); 32 | } 33 | return dp(0, nums, m); 34 | } 35 | } 36 | 37 | public static void main(String[] args) { 38 | 39 | Solution H = new Solution(); 40 | int[] a = {1, 2, 3, 4, 5}; 41 | System.out.println(H.splitArray(a, 2)); 42 | 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /Java Codes/Spoj3Tile.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Spoj3Tile { 6 | public static void main(String[] args) { 7 | 8 | Scanner scanner = new Scanner(System.in); 9 | int n; 10 | while ((n = scanner.nextInt()) != 0) { 11 | if (n == -1) break; 12 | 13 | int[] f = new int[n + 1], g = new int[n + 1]; 14 | 15 | f[0] = g[0] = 1; 16 | f[1] = g[1] = 0; 17 | 18 | for (int i = 2; i <= n; i++) { 19 | f[i] = f[i - 2] + 2 * g[i - 2]; 20 | g[i] = g[i - 2] + f[i]; 21 | } 22 | 23 | System.out.println(f[n]); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Java Codes/SubsetSum.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class SubsetSum { 7 | 8 | 9 | 10 | final static int N = 1000; 11 | 12 | static int[] a = new int[N]; 13 | static int n; 14 | static int[][] memo; 15 | 16 | static boolean subsetSum(int index, int sum) { 17 | 18 | // no elements left for sum 19 | if (index == -1) return (sum == 0); 20 | 21 | if (memo[index][sum] != -1) return memo[index][sum] == 1; 22 | 23 | boolean ans = false; 24 | // include a[index] in sum 25 | if (sum >= a[index]) { 26 | ans |= subsetSum(index - 1, sum - a[index]); 27 | } 28 | // exclude a[index] 29 | ans |= subsetSum(index - 1, sum); 30 | 31 | memo[index][sum] = ans ? 1 : 0; 32 | return ans; 33 | } 34 | 35 | public static void main(String[] args) { 36 | 37 | Scanner scn = new Scanner(System.in); 38 | int sum = scn.nextInt(); 39 | n = scn.nextInt(); 40 | 41 | 42 | for (int i = 0; i < n; i++) { 43 | a[i] = scn.nextInt(); 44 | } 45 | 46 | memo = new int[n][sum+1]; 47 | for(int i = 0 ; i < n; i++){ 48 | Arrays.fill(memo[i], -1); 49 | } 50 | 51 | System.out.println(subsetSum(n - 1, sum)); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /Java Codes/SubsetSumBitset.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.BitSet; 4 | import java.util.Scanner; 5 | 6 | public class SubsetSumBitset { 7 | 8 | public static void shiftLeft(BitSet bs, int n) { 9 | for (int i = bs.length() - 1; i >= 0; i = bs.previousSetBit(i - 1)) { 10 | bs.clear(i);//from w w w.ja v a2s . c om 11 | bs.set(i + 1); 12 | } 13 | } 14 | 15 | 16 | public static void main(String[] args) { 17 | 18 | Scanner scn = new Scanner(System.in); 19 | int N = 13; 20 | 21 | int sum = scn.nextInt(), n = scn.nextInt(); 22 | 23 | int[] a = new int[n + 1]; 24 | a[0] = 0; 25 | for (int i = 1; i <= n; i++) { 26 | a[i] = scn.nextInt(); 27 | } 28 | 29 | BitSet bt = new BitSet(N); 30 | bt.set(0); 31 | 32 | // O(n) 33 | for (int i = 1; i <= n; i++) { 34 | BitSet x = (BitSet) bt.clone(); 35 | shiftLeft(bt, a[i]); 36 | bt.or(x); 37 | } 38 | 39 | System.out.println(bt.get(sum)); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Java Codes/SubsetSumOneRow.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SubsetSumOneRow { 6 | 7 | public static void main(String[] args) { 8 | 9 | 10 | 11 | Scanner scn = new Scanner(System.in); 12 | 13 | int sum = scn.nextInt(), n = scn.nextInt(); 14 | 15 | int[] a = new int[n + 1]; 16 | a[0] = 0; 17 | for (int i = 1; i <= n; i++) { 18 | a[i] = scn.nextInt(); 19 | } 20 | 21 | boolean[] dp = new boolean[sum + 1]; 22 | // one row dp[j] 23 | 24 | dp[0] = true; 25 | 26 | for (int j = 1; j <= sum; j++) { 27 | dp[j] = false; 28 | } 29 | 30 | // O(n*sum) 31 | for (int i = 1; i <= n; i++) { 32 | for (int j = sum; j >= 0; j--) { 33 | 34 | if (j - a[i] >= 0) { 35 | dp[j] |= dp[j - a[i]]; 36 | } 37 | 38 | } 39 | 40 | } 41 | System.out.println(dp[sum]); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Java Codes/SubsetSumRepeating.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class SubsetSumRepeating { 7 | 8 | 9 | 10 | static final int N = 1000; 11 | 12 | static int[] a = new int[N]; 13 | static int n; 14 | 15 | static int[][] memo; 16 | 17 | // whether sum is possible from subset of 18 | // a[.....index] 19 | // O(n x sum) 20 | static boolean subsetSumRepeatingNumbers(int index, int sum) { 21 | 22 | // no elements left for sum 23 | if (index == -1) return (sum == 0); 24 | 25 | if (memo[index][sum] != -1) return memo[index][sum] == 1; 26 | 27 | boolean ans = false; 28 | // include a[index] in sum multiple times 29 | if (sum >= a[index]) { 30 | ans |= subsetSumRepeatingNumbers(index, sum - a[index]); 31 | } 32 | // exclude a[index] 33 | ans |= subsetSumRepeatingNumbers(index - 1, sum); 34 | 35 | memo[index][sum] = ans ? 1: 0; 36 | return ans; 37 | } 38 | 39 | public static void main(String[] args) { 40 | 41 | Scanner scn = new Scanner(System.in); 42 | int sum = scn.nextInt(); 43 | n = scn.nextInt(); 44 | 45 | 46 | for (int i = 0; i < n; i++) { 47 | a[i] = scn.nextInt(); 48 | } 49 | 50 | memo = new int[n][sum+1]; 51 | for(int i = 0 ; i < n; i++){ 52 | Arrays.fill(memo[i], -1); 53 | } 54 | 55 | System.out.println(subsetSumRepeatingNumbers(n - 1, sum)); 56 | 57 | 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /Java Codes/SubsetSumTabulation.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SubsetSumTabulation { 6 | public static void main(String[] args) { 7 | 8 | 9 | Scanner scn = new Scanner(System.in); 10 | 11 | int sum = scn.nextInt(), n = scn.nextInt(); 12 | 13 | int[] a = new int[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | a[i] = scn.nextInt(); 17 | } 18 | 19 | boolean[][] dp = new boolean[n+1][sum + 1]; 20 | 21 | dp[0][0] = true; 22 | 23 | for (int j = 1; j <= sum; j++) { 24 | dp[0][j] = false; 25 | } 26 | 27 | for (int i = 1; i <= n; i++) { 28 | for (int j = 0; j <= sum; j++) { 29 | 30 | // exlcusion 31 | dp[i][j] = dp[i - 1][j]; 32 | 33 | // inclusion 34 | if (j - a[i] >= 0) { 35 | dp[i][j] |= dp[i - 1][j - a[i]]; 36 | } 37 | } 38 | } 39 | 40 | // cout << dp[n][sum]; 41 | 42 | 43 | for (int i = 0; i <= n; i++) { 44 | for (int j = 0; j <= sum; j++) { 45 | System.out.print(dp[i][j] + " "); 46 | } 47 | System.out.println(); 48 | } 49 | 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /Java Codes/SubsetSumTwoRows.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SubsetSumTwoRows { 6 | public static void main(String[] args) { 7 | 8 | 9 | Scanner scn = new Scanner(System.in); 10 | 11 | int sum = scn.nextInt(), n = scn.nextInt(); 12 | 13 | int[] a = new int[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | a[i] = scn.nextInt(); 17 | } 18 | 19 | boolean[][] dp = new boolean[2][sum + 1]; 20 | 21 | // first row dp[0][j] 22 | // second row dp[1][j] 23 | 24 | dp[0][0] = true; 25 | 26 | for (int j = 1; j <= sum; j++) { 27 | dp[0][j] = false; 28 | } 29 | 30 | for (int i = 1; i <= n; i++) { 31 | for (int j = 0; j <= sum; j++) { 32 | // dp[ith] row is 2nd row 33 | dp[1][j] = dp[0][j]; 34 | if (j - a[i] >= 0) { 35 | dp[1][j] |= dp[0][j - a[i]]; 36 | } 37 | } 38 | 39 | // copy 2st row to 0th row 40 | // for next i calculation 41 | for (int j = 0; j <= sum; j++) { 42 | dp[0][j] = dp[1][j]; 43 | } 44 | 45 | } 46 | 47 | System.out.println(dp[1][sum]); 48 | 49 | 50 | 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /Java Codes/SumOfDigitsSpoj.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class SumOfDigitsSpoj { 7 | 8 | 9 | static String n; 10 | 11 | static int[][][] memo = new int[10][2][90]; 12 | 13 | static int dp(int index, boolean last, int sum) { 14 | 15 | if (index == n.length()) { 16 | return sum; 17 | } 18 | 19 | if (memo[index][last ? 1 : 0][sum] != -1) return memo[index][last ? 1 : 0][sum]; 20 | 21 | int till = (last ? n.charAt(index) - '0' : 9); 22 | int ans = 0; 23 | 24 | for (int digits = 0; digits <= till; digits++) { 25 | ans += dp(index + 1, last && (digits == till), sum + digits); 26 | } 27 | 28 | return memo[index][last ? 1 : 0][sum] = ans; 29 | } 30 | 31 | static int solve(int _n) { 32 | n = String.valueOf(_n); 33 | for(int i = 0; i < memo.length; i++){ 34 | for(int j = 0; j < memo[0].length; j++){ 35 | Arrays.fill(memo[i][j], -1); 36 | } 37 | } 38 | return dp(0, true, 0); 39 | } 40 | 41 | public static void main(String[] args) { 42 | 43 | Scanner scn = new Scanner(System.in); 44 | while (true) { 45 | 46 | int a = scn.nextInt(), b = scn.nextInt(); 47 | 48 | if (a == -1 && b == -1) break; 49 | 50 | System.out.println(solve(b) - solve(a - 1)); 51 | 52 | } 53 | 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /Java Codes/Tiling3.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Tiling3 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scn = new Scanner(System.in); 10 | int n = scn.nextInt(); 11 | 12 | int[] f = new int[n + 1], g = new int[n + 1]; 13 | f[0] = g[0] = 0; 14 | f[1] = g[1] = 1; 15 | f[2] = g[2] = 2; 16 | 17 | for (int i = 3; i <= n; i++) { 18 | f[i] = f[i - 1] + f[i - 2] + 2 * g[i - 2]; 19 | g[i] = g[i - 1] + f[i - 1]; 20 | } 21 | 22 | System.out.println(f[n]); 23 | 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Java Codes/ToDoDigitDp.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Locale; 5 | import java.util.Scanner; 6 | 7 | public class ToDoDigitDp { 8 | 9 | 10 | 11 | static final int N = 100005; 12 | 13 | static String s; 14 | static int[][][] dp = new int[2001][2][2000]; 15 | static int m, mod = (int) (1e9 + 7); 16 | 17 | static int work(int pos, boolean last, int modpro) { 18 | if (pos == s.length()) { 19 | if (modpro == 0) { 20 | return 1; 21 | } 22 | return 0; 23 | } 24 | if (dp[pos][last ? 1 : 0][modpro] != -1) { 25 | return dp[pos][last? 1 : 0][modpro]; 26 | } 27 | int till = (last ? s.charAt(pos) - '0' : 9); 28 | int ans = 0; 29 | for (int i = 0; i <= till; i++) { 30 | ans += work(pos + 1, last && (i == s.charAt(pos) - '0'), (modpro * 10 + i) % m); 31 | ans %= mod; 32 | } 33 | return dp[pos][last ? 1: 0][modpro] = ans % mod; 34 | } 35 | 36 | static int solve(int n) { 37 | s = String.valueOf(n); 38 | 39 | for(int i = 0; i < dp.length; i++){ 40 | for(int j = 0; j < dp[0].length; j++) 41 | Arrays.fill(dp[i][j], -1); 42 | } 43 | int ans = work(0, true, 0); 44 | return ans; 45 | } 46 | 47 | public static void main(String[] args) { 48 | 49 | Scanner scn = new Scanner(System.in); 50 | int t = scn.nextInt(); 51 | while (t-- > 0) 52 | { 53 | int i = scn.nextInt(), j=scn.nextInt(); 54 | m=scn.nextInt(); 55 | System.out.println(solve(j) - solve(i - 1)); 56 | } 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /Java Codes/TowerOfHanoi.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | public class TowerOfHanoi { 4 | 5 | 6 | static void TowerOfHanoi(int n, char from, char helper, char to) { 7 | 8 | if (n == 0) return; 9 | 10 | // cout << n << " " << from << " " << helper << " " << to << '\n'; 11 | 12 | TowerOfHanoi(n - 1, from, to, helper); 13 | // reached here 14 | // nth rod to to 15 | System.out.println(from + " -> " + to); 16 | 17 | TowerOfHanoi(n - 1, helper, from, to); 18 | 19 | } 20 | 21 | public static void main(String[] args) { 22 | 23 | int n = 4; 24 | 25 | TowerOfHanoi(n, 'A', 'B', 'C'); 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Java Codes/TreeDis2.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class TreeDis2 { 7 | 8 | 9 | 10 | static final int N = (int) (2e5 + 1); 11 | 12 | static ArrayList[] gr = new ArrayList[N]; 13 | static int[] g = new int[N], h = new int[N], f = new int[N]; 14 | static int n; 15 | 16 | static void dfs_g(int cur, int par) { 17 | for (int x : gr[cur]) { 18 | if (x != par) { 19 | dfs_g(x, cur); 20 | g[cur] += g[x] + h[x]; 21 | h[cur] += h[x]; 22 | } 23 | } 24 | h[cur] += 1; 25 | } 26 | 27 | static void dfs_f(int cur, int par, int sum_par) { 28 | 29 | for (int x : gr[cur]) { 30 | if (x != par) { 31 | 32 | int new_sum_par = sum_par + (n - h[cur]); 33 | 34 | int current_child_values = g[x] + h[x]; 35 | 36 | new_sum_par += (g[cur] - current_child_values); 37 | 38 | dfs_f(x, cur, new_sum_par); 39 | 40 | // for any node in the subtree 41 | f[cur] += (g[x] + h[x]); 42 | } 43 | } 44 | 45 | // for any node in the supertree 46 | // supertree = compliment of subtree 47 | f[cur] += sum_par + (n - h[cur]); 48 | 49 | } 50 | 51 | public static void main(String[] args) { 52 | 53 | Scanner scn = new Scanner(System.in); 54 | int n = scn.nextInt() ; 55 | 56 | for (int i = 0; i < n - 1; i++) { 57 | int x = scn.nextInt(), y = scn.nextInt(); 58 | 59 | gr[x].add(y); 60 | gr[y].add(x); 61 | } 62 | 63 | // O(N) 64 | dfs_g(1, -1); 65 | 66 | // O(N) 67 | dfs_f(1, -1, 0); 68 | 69 | for (int i = 1; i <= n; i++) { 70 | System.out.println(f[i]); 71 | } 72 | 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /Java Codes/VertexCoverSpoj.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Map; 6 | import java.util.Scanner; 7 | 8 | public class VertexCoverSpoj { 9 | 10 | 11 | static final int N = (int) (1e5 + 1); 12 | 13 | static ArrayList[] gr = new ArrayList[N]; 14 | static int[][] memo = new int[N][2]; 15 | 16 | static int dp(int cur, int take, int par) { 17 | 18 | if (memo[cur][take] != -1) return memo[cur][take]; 19 | 20 | int ans = take ; 21 | for (int x : gr[cur]) { 22 | if (x != par) { 23 | // x is only the child vertex 24 | if (take == 1) { 25 | ans += Math.min(dp(x, 0, cur),dp(x, 1, cur)); 26 | } 27 | else { 28 | ans += dp(x, 1, cur); 29 | } 30 | } 31 | } 32 | return memo[cur][take] = ans; 33 | } 34 | 35 | public static void main(String[] args) { 36 | 37 | Scanner sn = new Scanner(System.in); 38 | int n = sn.nextInt(); 39 | // corrected n-1 as edge count 40 | for (int i = 0; i < n - 1; i++) { 41 | int x = sn.nextInt(), y = sn.nextInt(); 42 | 43 | gr[x].add(y); 44 | gr[y].add(x); 45 | } 46 | 47 | for(int i = 0 ; i < memo.length; i++){ 48 | Arrays.fill(memo[i], -1); 49 | } 50 | 51 | System.out.println( Math.min(dp(1, 0, -1), dp(1, 1, -1))); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /Java Codes/VertexCoverSpojBFS.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.Queue; 6 | import java.util.Scanner; 7 | 8 | public class VertexCoverSpojBFS { 9 | 10 | 11 | static final int N = (int) (1e5 + 1); 12 | 13 | static ArrayList[] gr = new ArrayList[N]; 14 | static int[][] dp = new int[N][2]; 15 | 16 | static int[] vis = new int[N]; 17 | 18 | public static void main(String[] args) { 19 | 20 | Scanner scn = new Scanner(System.in); 21 | int n = scn.nextInt(), root = -1; 22 | 23 | for (int i = 0; i < n - 1; i++) { 24 | int x = scn.nextInt(), y = scn.nextInt(); 25 | 26 | gr[x].add(y); 27 | gr[y].add(x); 28 | } 29 | 30 | Queue Q = new LinkedList<>(); 31 | 32 | for (int i = 1; i <= n; i++) { 33 | if (gr[i].size() == 1) Q.add(i); 34 | } 35 | 36 | while (!Q.isEmpty()) { 37 | 38 | int cur = Q.poll(); 39 | 40 | vis[cur] = 1; 41 | root = cur; 42 | 43 | dp[cur][0] = 0; 44 | dp[cur][1] = 1; 45 | 46 | for (int x : gr[cur]) { 47 | if (vis[x] == 1) { 48 | // child nodes 49 | dp[cur][0] += dp[x][1]; 50 | dp[cur][1] += Math.min(dp[x][0], dp[x][1]); 51 | } 52 | else { 53 | // parent node 54 | Q.add(x); 55 | } 56 | } 57 | 58 | } 59 | // the node which is visited in the end 60 | System.out.println(Math.min(dp[root][0], dp[root][1])); 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /Java Codes/VertexCoverSpojDfs.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.Queue; 6 | import java.util.Scanner; 7 | 8 | public class VertexCoverSpojDfs { 9 | 10 | 11 | 12 | static final int N = (int) (1e5 + 1); 13 | 14 | static ArrayList[] gr = new ArrayList[N]; 15 | static int[][] dp = new int[N][2]; 16 | 17 | static void dfs(int cur, int par) { 18 | 19 | dp[cur][0] = 0; 20 | dp[cur][1] = 1; 21 | 22 | for (int x : gr[cur]) { 23 | if (x != par) { 24 | 25 | dfs(x, cur); 26 | // coming back from dfs 27 | // dp[x] wil be filled 28 | 29 | dp[cur][0] += dp[x][1]; 30 | dp[cur][1] += Math.min(dp[x][0], dp[x][1]); 31 | 32 | } 33 | } 34 | 35 | } 36 | 37 | 38 | 39 | public static void main(String[] args) { 40 | 41 | Scanner scn = new Scanner(System.in); 42 | int n = scn.nextInt() ; 43 | 44 | for (int i = 0; i < n - 1; i++) { 45 | int x = scn.nextInt(), y = scn.nextInt(); 46 | 47 | gr[x].add(y); 48 | gr[y].add(x); 49 | } 50 | 51 | dfs(1, 0); 52 | 53 | // the node which is visited in the end 54 | System.out.println(Math.min(dp[1][0], dp[1][1])); 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Java Codes/WildCardMatching.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class WildCardMatching { 7 | 8 | 9 | static class Solution { 10 | String s, p; 11 | int[][] memo; 12 | boolean dp(int i, int j) { 13 | if (i == s.length() && j == p.length()) return true; 14 | if (j == p.length()) return false; 15 | // if (i == s.size()) ; 16 | 17 | if (memo[i][j] != -1) return memo[i][j] == 1; 18 | 19 | boolean ans = false; 20 | 21 | if (i < s.length() && s.charAt(i) == p.charAt(j)) { 22 | ans |= dp(i + 1, j + 1); 23 | } 24 | 25 | else if (p.charAt(j) == '?') { 26 | if (i == s.length()) { 27 | return false; 28 | } 29 | else { 30 | ans |= dp(i + 1, j + 1); 31 | } 32 | } 33 | else if (p.charAt(j) == '*') { 34 | if (i < s.length()) { 35 | ans |= dp(i + 1, j); 36 | } 37 | ans |= dp(i, j + 1); 38 | } 39 | memo[i][j] = ans ? 1 : 0; 40 | return ans; 41 | } 42 | 43 | boolean isMatch(String ss, String pp) { 44 | this.s = ss; 45 | this.p = pp; 46 | memo = new int[ss.length()+1][pp.length()+1]; 47 | for(int i = 0 ; i < memo.length; i++){ 48 | Arrays.fill(memo[i], -1); 49 | } 50 | // 2d array structure filled with -1s 51 | return dp(0, 0); 52 | } 53 | }; 54 | 55 | public static void main(String[] args) { 56 | 57 | Scanner sn = new Scanner(System.in); 58 | String s = sn.next(), p = sn.next(); 59 | 60 | Solution H = new Solution(); 61 | boolean ans = H.isMatch(s, p); 62 | System.out.println(ans); 63 | 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /Java Codes/subsetSumOneRowRepeatingValues.java: -------------------------------------------------------------------------------- 1 | package DP; 2 | 3 | import java.util.Scanner; 4 | 5 | public class subsetSumOneRowRepeatingValues { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scn = new Scanner(System.in); 10 | 11 | int sum = scn.nextInt(), n = scn.nextInt(); 12 | 13 | int[] a = new int[n + 1]; 14 | a[0] = 0; 15 | for (int i = 1; i <= n; i++) { 16 | a[i] = scn.nextInt(); 17 | } 18 | 19 | boolean[] dp = new boolean[sum + 1]; 20 | // one row dp[j] 21 | 22 | 23 | dp[0] = true; 24 | 25 | for (int j = 1; j <= sum; j++) { 26 | dp[j] = false; 27 | } 28 | 29 | // O(n*sum) 30 | for (int i = 1; i <= n; i++) { 31 | for (int j = sum; j >= 0; j--) { 32 | 33 | if (j - a[i] >= 0) { 34 | dp[j] |= dp[j - a[i]]; 35 | } 36 | 37 | } 38 | 39 | } 40 | System.out.println(dp[sum]); 41 | } 42 | } 43 | --------------------------------------------------------------------------------