From d5e0940078255f763083d17aa0e7f47b100f73ad Mon Sep 17 00:00:00 2001 From: Sagar Barapatre Date: Tue, 19 Jan 2021 22:24:45 +0530 Subject: [PATCH 1/2] Add files via upload --- .../0:1 Knapsack/0:1Knapsack | Bin 0 -> 12976 bytes .../0:1 Knapsack/0:1Knapsack.cpp | 39 ++++++++ .../0:1 Knapsack/equal_partition | Bin 0 -> 22836 bytes .../0:1 Knapsack/equal_partition.cpp | 67 +++++++++++++ .../minimum_subset_sum_difference | Bin 0 -> 22964 bytes .../minimum_subset_sum_difference.cpp | 66 +++++++++++++ .../0:1 Knapsack/subset_sum | Bin 0 -> 12808 bytes .../0:1 Knapsack/subset_sum.cpp | 59 +++++++++++ .../0:1 Knapsack/subsets_with_sum_equal_to | Bin 0 -> 14284 bytes .../subsets_with_sum_equal_to.cpp | 58 +++++++++++ .../Longest Common Subsequence/LCS | Bin 0 -> 24668 bytes .../Longest Common Subsequence/LCS.cpp | 58 +++++++++++ .../Longest Common Subsequence/diff_utility | Bin 0 -> 24912 bytes .../diff_utility.cpp | 88 +++++++++++++++++ .../longest_common_substring | Bin 0 -> 24844 bytes .../longest_common_substring.cpp | 58 +++++++++++ .../longest_palindromic_subsequence | Bin 0 -> 34592 bytes .../longest_palindromic_subsequence.cpp | 58 +++++++++++ ...m_number_of_deletion_to_make_it_palindrome | Bin 0 -> 34592 bytes ...mber_of_deletion_to_make_it_palindrome.cpp | 58 +++++++++++ .../minimum_number_of_insertion_or_deletion | Bin 0 -> 25460 bytes ...inimum_number_of_insertion_or_deletion.cpp | 59 +++++++++++ .../Longest Common Subsequence/output.txt | 1 + .../Longest Common Subsequence/printing_LCS | Bin 0 -> 32060 bytes .../printing_LCS.cpp | 69 +++++++++++++ .../Longest Common Subsequence/printing_SCS | Bin 0 -> 31604 bytes .../printing_SCS.cpp | 92 ++++++++++++++++++ .../sequence_pattern_matching | Bin 0 -> 24868 bytes .../sequence_pattern_matching.cpp | 60 ++++++++++++ .../shortest_common_supersequence | Bin 0 -> 25004 bytes .../shortest_common_supersequence.cpp | 58 +++++++++++ .../Longest Increasing Subsequence/LIS | Bin 0 -> 14416 bytes .../Longest Increasing Subsequence/LIS.cpp | 59 +++++++++++ .../LIS_with_maximum_sum.cpp | 50 ++++++++++ .../longest_bitonic_subsequence | Bin 0 -> 40356 bytes .../longest_bitonic_subsequence.cpp | 53 ++++++++++ .../Longest Increasing Subsequence/output.txt | 1 + .../Matrix Chain Multiplication/MCS | Bin 0 -> 14428 bytes .../Matrix Chain Multiplication/MCS.cpp | 38 ++++++++ ..._sequence_formes_by_adjacent_in_matrix.cpp | 85 ++++++++++++++++ ...minimum_cost_reach_last_cell_of_matrix.cpp | 43 ++++++++ .../size_of_largest_submatrix_with_one's.cpp | 66 +++++++++++++ .../Unbounded Knapsack/rod_cutting | Bin 0 -> 12976 bytes .../Unbounded Knapsack/rod_cutting.cpp | 37 +++++++ .../Unbounded Knapsack/unbounded_kanpsack | Bin 0 -> 12976 bytes .../Unbounded Knapsack/unbounded_kanpsack.cpp | 39 ++++++++ .../Dynamic Programming/edit_distance.cpp | 56 +++++++++++ ...d_number_of_time_pattern_appears_in_string | Bin 0 -> 21244 bytes ...mber_of_time_pattern_appears_in_string.cpp | 44 +++++++++ .../find_probability_that_person_is_safe.cpp | 67 +++++++++++++ ...on_to_linear_equation_with_k_variables.cpp | 42 ++++++++ .../word_break_problem.cpp | 66 +++++++++++++ 52 files changed, 1694 insertions(+) create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack.cpp create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition.cpp create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/minimum_subset_sum_difference create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/minimum_subset_sum_difference.cpp create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum.cpp create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to create mode 100644 Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/LCS create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/LCS.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/diff_utility create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/diff_utility.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/longest_common_substring create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/longest_common_substring.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/longest_palindromic_subsequence create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/longest_palindromic_subsequence.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/output.txt create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/printing_LCS create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/printing_LCS.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/printing_SCS create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/printing_SCS.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence create mode 100644 Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS_with_maximum_sum.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence.cpp create mode 100644 Data Structures/Dynamic Programming/Longest Increasing Subsequence/output.txt create mode 100644 Data Structures/Dynamic Programming/Matrix Chain Multiplication/MCS create mode 100644 Data Structures/Dynamic Programming/Matrix Chain Multiplication/MCS.cpp create mode 100644 Data Structures/Dynamic Programming/Matrix/longest_sequence_formes_by_adjacent_in_matrix.cpp create mode 100644 Data Structures/Dynamic Programming/Matrix/minimum_cost_reach_last_cell_of_matrix.cpp create mode 100644 Data Structures/Dynamic Programming/Matrix/size_of_largest_submatrix_with_one's.cpp create mode 100644 Data Structures/Dynamic Programming/Unbounded Knapsack/rod_cutting create mode 100644 Data Structures/Dynamic Programming/Unbounded Knapsack/rod_cutting.cpp create mode 100644 Data Structures/Dynamic Programming/Unbounded Knapsack/unbounded_kanpsack create mode 100644 Data Structures/Dynamic Programming/Unbounded Knapsack/unbounded_kanpsack.cpp create mode 100644 Data Structures/Dynamic Programming/edit_distance.cpp create mode 100644 Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string create mode 100644 Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string.cpp create mode 100644 Data Structures/Dynamic Programming/find_probability_that_person_is_safe.cpp create mode 100644 Data Structures/Dynamic Programming/total_possible_solution_to_linear_equation_with_k_variables.cpp create mode 100644 Data Structures/Dynamic Programming/word_break_problem.cpp diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack b/Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack new file mode 100644 index 0000000000000000000000000000000000000000..f3f13172e58d41be342d2e052c8f87681f87bfde GIT binary patch literal 12976 zcmeHO-EUMy6rWv+R4LrjNWf1vnj(m4w*msGBrR~`G_a+zZ9+)MWV_wAn{GeS-Nlkv zEi9lnmxYZl@}Nm$Q1L}cM8jhXq-{u4H2biLeOMkOyGd&rQe#6R>+jr;cJ~(k0C6VF zojGUD{N|kB%EhxsF{_Fon;>M7<&$tqYBZ|_>Ou^J#v_| zrNvb$K2jo_Em%N^R`qCWsfjVavQ)<`8Llv@Pg%o4#6m-{C0i%n*lGlW;ZG3|6_U%$ zuK6ruBgLW+(OA4ax~OvE9aT)cD$Bx_?Fr=;-jaWWC%QwCfzTj~oOlrnuf_r(nRs6; z%lr%W_eGZicH(_z;cc`4NG`!!1U5TD1f#LRa9@|Dcj8^M@NCXVE-p@NA>w`Sh5I^0 zxUaJxhEBZe79O1;DkM8G%n|cR=j0Nq5C)e?$z#1|N%O z?jrYM^g#76U!~(Xo+`o;OPn?unCL|Z*S?a}x;xym)Lru*G)dNi?`;2)V zaYCkY)e4N(plX*_@b|0(i*k#=wNLm++N#pGSUH=$_uFE$Lt$7X5D}9`s>Ok z+0I1QF8`a*c~FfQm1h`3rM}5!mHTz{D^cyT1@RM311(roXkCP8tYJ{M$^!`3k}vQl zxNTcaT@9QHw;O)$F1BYb{5dSO_n(Z$LcKNntSQE7oAD%n#;_Q*TP>ORl|?cj8ITM} z2LAgDv~leZerjd}k#K!w4L%;Z&bX#7Xv6bdi|4r3meqXIx^KELu1)E_c{I1Vb`N7y zT$|v^clUX6#}9PNB+LwgphY*D%aJV?#m?dE*|_9jGNCqSWk^#wpWI!??8ITM}1|$QL0m*=5;E815ef&OvUsBjPt4&$$6B(=w zN-`iBkPJu$BmY+&x*ZV?&^1>><0vgZS|(5_>3 z*oHf0-ceTz`9$SI)V26QqY`XC!3!oQvVk!z)+ w&3^F~GTuYcXj2%bmhn#E-zi$Xru{(^uE;DH0cP05GaSINIT473zy@Rg0wK_~#sB~S literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack.cpp b/Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack.cpp new file mode 100644 index 0000000..75dad2a --- /dev/null +++ b/Data Structures/Dynamic Programming/0:1 Knapsack/0:1Knapsack.cpp @@ -0,0 +1,39 @@ +// A Dynamic Programming based +// solution for 0-1 Knapsack problem +#include + +using namespace std; + +// Returns the maximum value that +// can be put in a knapsack of capacity W +int knapSack(int W, int wt[], int val[], int n) +{ + int i, w; + int K[n + 1][W + 1]; + + // Build table K[][] in bottom up manner + for (i = 0; i <= n; i++) { + for (w = 0; w <= W; w++) { + if (i == 0 || w == 0) + K[i][w] = 0; + else if (wt[i - 1] <= w) + K[i][w] = max( + val[i - 1] + K[i - 1][w - wt[i - 1]], + K[i - 1][w]); + else + K[i][w] = K[i - 1][w]; + } + } + + return K[n][W]; +} + +int main() +{ + int val[] = { 60, 100, 120 }; + int wt[] = { 10, 20, 30 }; + int W = 50; + int n = sizeof(val) / sizeof(val[0]); + printf("%d\n", knapSack(W, wt, val, n)); + return 0; +} diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition b/Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition new file mode 100644 index 0000000000000000000000000000000000000000..33edba398aab4c999c45cbb6e26d807a155b8d50 GIT binary patch literal 22836 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 literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition.cpp b/Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition.cpp new file mode 100644 index 0000000..551eb01 --- /dev/null +++ b/Data Structures/Dynamic Programming/0:1 Knapsack/equal_partition.cpp @@ -0,0 +1,67 @@ +// A Dynamic Programming based +// C++ program to partition problem +#include +using namespace std; + +// Returns true if arr[] can be partitioned +// in two subsets of equal sum, otherwise false +bool findPartiion (int arr[], int n) +{ + int sum = 0; + int i, j; + + // Calculate sum of all elements + for (i = 0; i < n; i++) + sum += arr[i]; + + if (sum % 2 != 0) + return false; + + bool part[sum / 2 + 1][n + 1]; + + // initialize top row as true + for (i = 0; i <= n; i++) + part[0][i] = true; + + // initialize leftmost column, + // except part[0][0], as 0 + for (i = 1; i <= sum / 2; i++) + part[i][0] = false; + + // Fill the partition table in botton up manner + for (i = 1; i <= sum / 2; i++) + { + for (j = 1; j <= n; j++) + { + part[i][j] = part[i][j - 1]; + if (i >= arr[j - 1]) + part[i][j] = part[i][j] || + part[i - arr[j - 1]][j - 1]; + } + } + + /* // uncomment this part to print table + for (i = 0; i <= sum/2; i++) + { + for (j = 0; j <= n; j++) + cout<9mp#PCvLG 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 h_6D^z%$ZV|m$GJEUeelfv +using namespace std; + +// Returns the minimum value of the difference of the two sets. +int findMin(int arr[], int n) +{ + // Calculate sum of all elements + int sum = 0; + for (int i = 0; i < n; i++) + sum += arr[i]; + + // Create an array to store results of subproblems + bool dp[n+1][sum+1]; + + // Initialize first column as true. 0 sum is possible + // with all elements. + for (int i = 0; i <= n; i++) + dp[i][0] = true; + + // Initialize top row, except dp[0][0], as false. With + // 0 elements, no other sum except 0 is possible + for (int i = 1; i <= sum; i++) + dp[0][i] = false; + + // Fill the partition table in bottom up manner + for (int i=1; i<=n; i++) + { + for (int j=1; j<=sum; j++) + { + // If i'th element is excluded + dp[i][j] = dp[i-1][j]; + + // If i'th element is included + if (arr[i-1] <= j) + dp[i][j] |= dp[i-1][j-arr[i-1]]; + } + } + + // Initialize difference of two sums. + int diff = INT_MAX; + + // Find the largest j such that dp[n][j] + // is true where j loops from sum/2 t0 0 + for (int j=sum/2; j>=0; j--) + { + // Find the + if (dp[n][j] == true) + { + diff = sum-2*j; + break; + } + } + return diff; +} + +// Driver program to test above function +int main() +{ + int arr[] = {3, 1, 4, 2, 2, 1}; + int n = sizeof(arr)/sizeof(arr[0]); + cout << "The minimum difference between 2 sets is " + << findMin(arr, n); + return 0; +} diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum b/Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum new file mode 100644 index 0000000000000000000000000000000000000000..45be003894457783c6ca34f2683d47b6021b32af GIT binary patch literal 12808 zcmeHOUrbY17(W-w#6RPr58|?!HBO9<1;uElLz9Bs?HWPdu!%95$5JXZP$0Bbd?3+u zBwX%@Jnmsndr;oSUfdq5Yi#4lWW;4W_<+gg+Kpx19u{LVyWe;2xzHBK-u0a1{Q17~ z{r#O&dKy0;Jp1GMdd9SMj9sf>jBP=muVieLd9h;bHFOi5^E1sK80U?TP7}AZX{F?< z6xrDW2b`ZZ&Ydk45&AWyJSJ&`!l=I@w>gi6hGWaJ<@WNMkPNnWBOz);dz_^+df2sM zlJjUR-WgqDmD}5rxG%L8@dXF^ zqss}G+q)?3ZI=d!F3ESvu(RMi7>x~u`@1E-+}^OX_paP0y113ZiVe=={a3>MT|C@> zX+Y4W=Q}O!(H){jbh!;@#~JCKe1^_>YxCJ=e*E;Q4(GPuK9t-O_rA!Pj+;8k5R3Ef zfo0Uzw&$85C3$6_?cBFwn&Qf$J8_YOY~HfCK#Nuumzy)^eE}Z58tEM9j?*a#`c%x z37T4!OpJU`ciT?4C_aZye2X^iM{q{Sb zUzq#i`Go`EdC^6V`bNgkY3*RSwc>58YtY@c2l+2gD8xT~uQ^a|=Se|J}yHvj8YBUy#G_*(+;cYiYiYEzYgu`A*6TYe`1QY@a0foTJ zhk)O-elZh^7friT!*{4@Gt)Ajn$}3(iZ5FJtnFVc+_h$He-_hEruEpg+80dgj;Vk7 zz)alH&BWt8G`=yd43ws`bNCW7_ohs1!L-}KZJ#&ok!ftrri~eb7s6AvG1Fu$>Nj>0 z9W-VjIt_z&Oxr(o&r_jcKatcdV8O&qfjvdYRkQo`9@5NRXnu#&>mIuN#zg!{bhPbGfS%;4Wmp0D(YCgCrY z$byrB6N>J>X~*I0dpJw_#*bEGPL;E-{i^xKj#jT`^V7ut*!;&+t@*x&{>UwTl%CtR zv3dZm^^sKKPpvJOZmIWNN0_bSo2y&L+HZ{;w?t?wqu!;Bd8%`;Oi2r%lDWU07YdS< z60B72JFsvni^Zp6YIniP`o<4d0DD}36fVpx;G+v;`=6ReW_@GvoBHUhus&|w+@Ir=FJ?zF=_B)GVG zl^fhN+L1;^AEoC}W715de2AV1eN&Px%-Y9;2hGO0;;aHEiJA66R z4^D)g8dzgPygA>1KDFYRY|?MtgP5t;%HM6YrWiIuvqorxkk44LQiDQ3A)pXY2q**; z0tx|zfI>hapb$_9CE+$=z)%$@5Osd84R(lH{X~ z1_?)Fy(mH+LKQf+qE%&hzg00c;rkt9A?L;&|w|R*J4;e0YttwPo)*?I(jwgMBI9364O!W z;r@SsT0x_N0}X6ek52nkpG!2#g=r==(T-y*ru}6!)qfQ450=ps6xDiAy*AaYP+dte t&x^|KRnp^pB@A33gySg#yX3$G%q1M>2wluqoFWRx>0ogrmjkg7`wxx4Yjgkr literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum.cpp b/Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum.cpp new file mode 100644 index 0000000..155d29e --- /dev/null +++ b/Data Structures/Dynamic Programming/0:1 Knapsack/subset_sum.cpp @@ -0,0 +1,59 @@ +// A Dynamic Programming solution +// for subset sum problem +#include + +using namespace std; + +// Returns true if there is a subset of set[] +// with sun equal to given sum +bool isSubsetSum(int set[], int n, int sum) +{ + // The value of subset[i][j] will be true if + // there is a subset of set[0..j-1] with sum + // equal to i + bool subset[n + 1][sum + 1]; + + // If sum is 0, then answer is true + for (int i = 0; i <= n; i++) + subset[i][0] = true; + + // If sum is not 0 and set is empty, + // then answer is false + for (int i = 1; i <= sum; i++) + subset[0][i] = false; + + // Fill the subset table in botton up manner + for (int i = 1; i <= n; i++) { + for (int j = 1; j <= sum; j++) { + if (j < set[i - 1]) + subset[i][j] = subset[i - 1][j]; + if (j >= set[i - 1]) + subset[i][j] = subset[i - 1][j] + || subset[i - 1][j - set[i - 1]]; + } + } + + /* // uncomment this code to print table + for (int i = 0; i <= n; i++) + { + for (int j = 0; j <= sum; j++) + printf ("%4d", subset[i][j]); + printf("\n"); + }*/ + + return subset[n][sum]; +} + +// Driver program to test above function +int main() +{ + int set[] = { 3, 34, 4, 12, 5, 2 }; + int sum = 9; + int n = sizeof(set) / sizeof(set[0]); + if (isSubsetSum(set, n, sum) == true) + printf("Found a subset with given sum"); + else + printf("No subset with given sum"); + return 0; +} +// This code is contributed by Arjun Tyagi. diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to b/Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to new file mode 100644 index 0000000000000000000000000000000000000000..134b0a0845a09779d5fe2f5e5fe9cefaaefbd4e4 GIT binary patch literal 14284 zcmeHOZ)_CD6`wPgh7`gX2x(}Wa4k>~sK6HtfdG|l*s>NFjL()36&lX##dqO+Hn)4k zG`+~eO~SI6_(K#`>WA`yMp0C$RH~|cDKg>IJ4GnaimFthl2QL;UAgTkQCl}^x&Gel z+`qMn@W-Y*^89&k-h1=rx3h2Vtamp)`OCeB84E06Y@~rPwiNaDLyW!5!Wc2O5>-Xz zyt8$$azyDmNZk4os3+&7$j&+}z0u%-{0+>G^l?RAG-|H9G$(RKDJhTQ?@+F;740_e3jBJDjU z^@y&+ZV-tAk0(;c2QlZh_qwzfmwH5hntyaoz9;PLY3*+1yAK|Sx~B!_q3)cN z&x`DFei>DgAr|NTgVkLUJ-5AekQD_=q+c%dJQtM-^yHU=>e{K92z&ejEsDpl@}4K*;yHClkbhJ+u zmGk}W2lgp@+FkS+Yx3+9G?nY*5DKk9wOqc6cp^m5(Ao>p50@v=)8s`cgr9NOBYd7f z9R~d+^shHFwhfNbGw4L6BJ7|i|B2s-dcU#``eesj@Vc=u>SEMQ86&+ZndsfrcRJYz znhNQVA3rj-zItK!xqrX<=C7yrhu+=@w}hV9W9ajYq0-pJa#_QAjBEW_hb@wwW3*6B zAre~`Ylt)Pa2O^6RbSwbwqe7@$VNDo=oNl$tCeQ~gu{CI=xM{$2R61z6|vga(2_rK zI8Oc3k|uop;v?WA@c)TGk81r<9i2X=+7GS79jDq%wUimv$`-B6wAJI-J=3Lkt($g_ zgYGw~byu}ICROXI8v5}Kb!_n%u5YG}-Yr7w9n~s8@v<|F4+!ehIn|m}?GA7|ZmV|o zGNx|kmFomEgx|82>pPU`&}(an)|BfIy$qvQRlDb{eDDm#QizOB1T5wH)QwW9lvfHa zv#>*PLa%+D^las_dZNJ8t9KhnPYt}MY8{1q@Ej(gUJ&Yqse(|?x#~Hw>`D-MWx{1m z2#X&Joe4Nnw0m-+e-5bHM>~Q)361R%6S+|boC4M%Ki_lL%wWy;vF3ywynrq@$BY%c zU@Nn&o6*l+SO0E^2b!dgQ4LdE!E%-D~rm!f0nGnECOa%ap zWaR`aH}%22QVGvvy7D}(PD*Uw1>3QMXMg}sz%A8Y@gc4%)n2CBnHhEaN0xFa^fKMa zwsJ|erjK58Uc`+ST6BD4Xw`RVT^3r!^7(pH>A_<9fK3$C+~33W8r0%zZcT4<5s_6X$5_;j|M zg`w=sS>>Ms-Lb3#@}~1I*XB)!KFiW3#M291$v`Yya4vv*R>=z{5O$oqV4PF(p)0h@ z&ZF0?U(%vh#~m?y4YNYlRj{*@&UvsxiwHie=N%^ns`l}KW2qQ9kW5KP#Ya|Dtu zNOQ~A?k78QjSn{p(zO2pfFG3hp6$3kARPWkARPWkARPWkARPWkARPW zkARPWkARQBXCHxP{I7ui-|z?g4}to>%6>-n4RU_5>>rnXSoYtL{d(D}vj6NO=kL%* zz(>GGz(>GGz(>GGz(>GGz(>GGz(>GG;C}~!rK{Pu$lIkYoF6$5H8*n}Y1Rfaros-T z*?0|ii)Nl4(%UuVnM9u=W_bVbFh`oZF_?-a6Xt1ts)>y+g9>u$W7-L>#ZU15Of208 zX-csbsrI}V+2TlzA9pb_7%B9)Ipkfskr~i2Wh`|4+2=a6H94rolKS?Hq4VQ0O*fUU z1JNe#I>L;`I^k`JL4)_k41H_AZbDHxMFyX!-C$%h<`WtpG|aRf8)(-KM0q5l#bar1 zreg`yz%CVK^AJ$bNI5)z9;MNkd7{%1yPZ5{5ky*X%Yi7d5w=dU_y{ zikZ6DX^VIQ1ioROKz4W<>G@So==40YdcHQ~SuIOeSZRQG{6M1LtZ`M4u^1l&HHd v%e5+kH8#1HjHUV!oRdlX(oM#7ws-gLn%{sW^=7Otpd3mkP9gB)1w;8SlcdgF literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to.cpp b/Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to.cpp new file mode 100644 index 0000000..3766733 --- /dev/null +++ b/Data Structures/Dynamic Programming/0:1 Knapsack/subsets_with_sum_equal_to.cpp @@ -0,0 +1,58 @@ +// A Dynamic Programming solution +// for subset sum problem +#include + +using namespace std; + +// Returns true if there is a subset of set[] +// with sun equal to given sum +int isSubsetSum(int set[], int n, int sum) +{ + // The value of subset[i][j] will be true if + // there is a subset of set[0..j-1] with sum + // equal to i + int subset[n + 1][sum + 1]; + + // If sum is 0, then answer is true + for (int i = 0; i <= n; i++) + subset[i][0] = true; + + // If sum is not 0 and set is empty, + // then answer is false + for (int i = 1; i <= sum; i++) + subset[0][i] = false; + + // Fill the subset table in botton up manner + for (int i = 1; i <= n; i++) { + for (int j = 1; j <= sum; j++) { + if (j < set[i - 1]) + subset[i][j] = subset[i - 1][j]; + if (j >= set[i - 1]) + subset[i][j] = subset[i - 1][j] + + subset[i - 1][j - set[i - 1]]; + } + } + + /* // uncomment this code to print table + for (int i = 0; i <= n; i++) + { + for (int j = 0; j <= sum; j++) + printf ("%4d", subset[i][j]); + printf("\n"); + }*/ + + return subset[n][sum]; +} + +// Driver program to test above function +int main() +{ + int set[] = { 2, 3, 5, 8, 10}; + int sum = 10; + int n = sizeof(set) / sizeof(set[0]); + cout<YE0>PwOUCFs}J_W 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 +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AGGTAB"; + string Y = "GXTXAYB"; + + int m = X.length(); + int n = Y.length(); + + cout << "Length of LCS is " + << lcs( X, Y, m, n ); + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/diff_utility b/Data Structures/Dynamic Programming/Longest Common Subsequence/diff_utility new file mode 100644 index 0000000000000000000000000000000000000000..e681e86a600c4a8c98d54a2d4ac08a0c33a80aff GIT binary patch literal 24912 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 +#include +using namespace std; + +// define maximum possible length of string X and Y +#define M 20 +#define N 25 + + + +// lookup[i][j] stores the length of LCS of substring X[0..i-1], Y[0..j-1] +int lookup[M][N]; + +// Function to display the differences between two strings +void diff(string X, string Y, int m, int n) +{ + // if last character of X and Y matches + if (m > 0 && n > 0 && X[m - 1] == Y[n - 1]) + { + diff(X, Y, m - 1, n - 1); + cout << " " << X[m - 1]; + } + + // current character of Y is not present in X + else if (n > 0 && (m == 0 || lookup[m][n - 1] >= lookup[m - 1][n])) + { + diff(X, Y, m, n - 1); + cout << " +" << Y[n - 1]; + } + + // current character of X is not present in Y + else if (m > 0 && (n == 0 || lookup[m][n - 1] < lookup[m - 1][n])) + { + diff(X, Y, m - 1, n); + cout << " -" << X[m - 1]; + } +} + +// Function to fill lookup table by finding the length of LCS +// of substring X[0..m-1] and Y[0..n-1] +void lcs_length(string X, string Y, int m, int n) +{ + // first column of the lookup table will be all 0 + for (int i = 0; i <= m; i++) + lookup[i][0] = 0; + + // first row of the lookup table will be all 0 + for (int j = 0; j <= n; j++) + lookup[0][j] = 0; + + // fill the lookup table in bottom-up manner + for (int i = 1; i <= m; i++) + { + for (int j = 1; j <= n; j++) + { + // if current character of X and Y matches + if (X[i - 1] == Y[j - 1]) + lookup[i][j] = lookup[i - 1][j - 1] + 1; + + // else if current character of X and Y don't match + else + lookup[i][j] = max(lookup[i - 1][j], lookup[i][j - 1]); + } + } +} + +// Implement Diff Utility +int main() +{ +#ifndef ONLINE_JUDGE + + freopen("input.txt", "r", stdin); + + freopen("output.txt", "w", stdout); + +#endif + string X = "ABCDFGHJQZ"; + string Y = "ABCDEFGIJKRXYZ"; + int m = X.length(), n = Y.length(); + + // fill lookup table + lcs_length(X, Y, m, n); + + // find difference by reading lookup table in top-down manner + diff(X, Y, m, n); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/longest_common_substring b/Data Structures/Dynamic Programming/Longest Common Subsequence/longest_common_substring new file mode 100644 index 0000000000000000000000000000000000000000..09f32c424c8c4a22df5dcbf7eab9c03662ff7e0f GIT binary patch literal 24844 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 +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = 0 /* max(L[i - 1][j], L[i][j - 1]) */; + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AGGTAB"; + string Y = "GXTXAYB"; + + int m = X.length(); + int n = Y.length(); + + cout << "Length of LCS is " + << lcs( X, Y, m, n ); + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/longest_palindromic_subsequence b/Data Structures/Dynamic Programming/Longest Common Subsequence/longest_palindromic_subsequence new file mode 100644 index 0000000000000000000000000000000000000000..90a75466a9fa89abf85bd6e2cd204843b3397f64 GIT binary patch literal 34592 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 +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AGBCBA"; + string Y = string(X.rbegin(), X.rend()); //here reverse iterators are used i.e rbegin and rend... see carefully + + int m = X.length(); + int n = Y.length(); + + cout << "Length of LCS is " + << lcs( X, Y, m, n ); + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome new file mode 100644 index 0000000000000000000000000000000000000000..e3aef5db5e826e6eade15f351741795313e3988b GIT binary patch literal 34592 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 S)nJgtYqMB9vIACEQT`j`x?0r$ literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome.cpp b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome.cpp new file mode 100644 index 0000000..d6e276d --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_deletion_to_make_it_palindrome.cpp @@ -0,0 +1,58 @@ +/* Dynamic Programming C++ implementation of LCS problem */ +#include +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AGBCBA"; + string Y = string(X.rbegin(), X.rend()); //here reverse iterators are used i.e rbegin and rend... see carefully + + int m = X.length(); + int n = Y.length(); + + cout << "Length of LCS is " + << m - lcs( X, Y, m, n ); + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion new file mode 100644 index 0000000000000000000000000000000000000000..83d0977e8ff6e79225c73f029d05d3d41af1b38c GIT binary patch literal 25460 zcmeHQeRv$jd7nGULB@tVAZeTi@R_gJC4rM{87mG?%IRPp6f1;q<|M z_=7~rfviN!BBHjC#|0i9l>$`~LiD5*6cSX)CYDMF7ODHhO%rk?q*)b1RO&iPfT+KB zX7+AxC4nuQ^af-J8`~91B)uGeL{DqcV;y=N zh1~R(ULfclmjnot+_Tp#{+c5ZP2U~SJCa&5+~B5He4(JnI}IX)^XO#>i-@L063KY9 zty!keqPJYoQ)GTIu=8@$*0faHu4r4M7Hw;4M?p8e8cFX_NrbSQhLb+&$v#e}YQwe- z+Q#d))Cp|~$bR}|X<&Xy4E<#kXzVFT)0*2IY63hry_G1-uYjm85!W{iefA>0ECfL( zo6K0y#TPKYTzuJm*0fkyOYCWFXpdW;2a;oylbMC zv8(e^1UMUy0K!s)D^rR1m9c2Um5qC1)FxdYL?AvMUi|2p)~_n={c6p5pLp#Dmz`0D zv;YEFWz2Ub4-^-&JlFddi2Er|UMtZpqBFSIP7zOPm*hfu)Ms`^03WZY)6Rs%KOqqnasXrSR+=M3Ez7%3*3Bl?F`Z@OtH# z@5{TON@L0dC7a5`dS%M@fO*LK`Wx@jO`LG{?>2yShd|r}nU`1d=9<;=3k4_YRb(94G8~KA%b_ z+BuYMM-({(q3u(R-++sK)^ng-g+ZEM3ROn&?UN|Q_>E|dcnoD?@*jRbGb57@^Q6O* zok#+uV{^-M$}GMeQm|A50)O8te@5DIE|{2BD_%F0yM5hchfL*e)i`?70qYy*LBvb? zq(1q<^E3vX#6N9)35HHBQl`|dXZ$xEXu86;d@nJ`e9M_EA8?jO8&lQ+OmmbE%vJuj zqhyE1lsAcp+FQP!bgj2DW4#8G0vr^0+viN2dR#THKF%wY zzX^kDjhqV_Mz=bX6&ID?r}m~YMt2obtxuzbO*M`5aqC(;#jGDPK~a=XTMxWBGh=jD zW=Zk-W-leIf`&a!jTi^5D@Bv*>~iSB%hVI|X-cw&C~kBIbJ?9~>!?W(2%=ALc=6#cn`=--*G-1~G$WQ|+9>_oduverLS3F~`rP{#s@ z3YF?6LS`=|@QzV~=-4Mj^ULgV=-3j`F-o$2hEW7}{#-V1-}2aPOJ1!hm~!4wcFZw= z|4E7WLj#N#U`s}f+V4(2k%#WdL$q3EOJao5*1a~>oE*QDO}f!pe3HCCM`gk0_H1F~ zLhrbQtg37(#zClMDUwX(P4%{CNN;aCfY!&Y^RwkdZK&_!{3NnmBe1c)C8{x|8uyft z%q|Co+zgs?zVZ1}1ZAIpzKQusb8`vJO+GJu%d6PD^HDW1eT_~S18|bcSl56r%xw#8 zWmIFo6(>Avx>nls^6bG(y|e`G`44{34nm1)R$HovRur^4HcU%^_19oEtl* zymR$$=8aYQMd{h}H&Z^XKE{~E`4KkNHmP~`mya(mPj)xg9@%Ed8K!kMeR4QO+o!WU z$r~e?B7MP{fJLPjx_2eo%F10x8G^+qPSVmMR1QOGB5>8R^~GLW4A3#_r%ZAJto2^s z{iErZAn8$b%q0&o-h4g6`h~R=tXM(b2w$U!w~TcQyi=!AHxm|0?V^_(ugm9=Fpi^bQWIe8b~lYXH^zK&_|7RMOT*h;gI4BUhZq zL2(3q8L_?rYS~_rKMP*ac!{*9!(`#eay*Q3yjPQ#B89JP6GrWGlWUxa3$%AJN|K84 z;ymeANoEX$^wofFnRq;sQe`b2y1T)WBFuy)urtTZnJo^E@lAC+%9kZs%2?Lw2t zAVL$?e%Jwf_1i&&KJvSnnVdQ}?E!T4jx#R7>>qJ@jKaR%c6169t9s;m0xM+HXD|Xs zuv3}nQ4aCJGJ0>M7QRF4rY+7F379-Xtr+!nOB)4ip-fNKb5BM&g4&h}ug6e^IMd%2 z6b2#sL3O<{0sBx?@NI-)!;{+_&G~BoTT+o z6hwsFtsZMX(oJ5sd&KDeFpB&3k^{%NF?j;^al$M1?Y)a~Xc#8>@_#2$G5M%w#HiZi zQO$Gscwn?J9#bSzJ|3%(W!*;5=q5cyC%L*lz>}y)a#U7OI|!_F#5l;cWi!_zEJ6k? zOx&eLX__CTv+xy7c&blx!)pVX8kP<-8}m(zW#Sko103U zb0xRl+w^SvUx((w$CUYGA9#XZd<+R$Gebv4lsg|#q=ULzI zv)n)9t6>^R!atP!s9k@_e0Pu7lXwgNe z8I1zTbe1^8`dB(bYbiNMa=oFIvU`sFUec@Ah5CAkHAFrA}d2y-mK5e zgm$3O0AF19Qg>~CIM6d;Q|M8CO}!!ln47=0o6Da(&zJgiqJ8$4YLkQ;Zy!md7Y|4aJ_L*vBXarr?)S z?6Z_c2T?6AQ|v;Dy+yJ2Qfw)-Ve(AGFf#Y)p6%=+#xC;TUCiprA1r3Qp0fsv*~6Z? z;bOMeyBP7m@m_=UpL+eT7PD#ZC*MH4Xer{a6)i>j7mF98>R7RMe39poMQ}F0x9EIC zUs`mD<6{$a+xV5eQ+ zc^|u&v5S{$?Bi&sW$_n1o?BMfwNzz8h=r65Y+H*SXiK#==B(q&TOgVU zd^F(7jJ758IOQf}Hku+H=#&i%GVsmuN{J=B-XB2h46uMlC4x>Ba1o|=MfCo55WA}w zo*5|Pqj+}wIb#!eR>ISG8BdHM-V2?D`l8o^UgjBrN0NCD^G;zo8axvi`{B$|JYlmt z&SRbl(5ied^JK^uFI)u)6eLiPKtTcp2^1tykU&8K1ql=+P>?`D0tE>aB=9FCfeHCN z`uXyCnSAZ@C`h0nfr11I5-3QZAc2Ae z3KA$tpdf*Q1m=;zITy1X^a;W_m72DFOI>ocrj@RVw5O5^yFSkP9I54z zh}Mo@)a&8a>TTM#pr$BwS81Wmb!)U%mR6no#uC*hPAjsFD6Ivh2!2T1#}bSLTQ7cV zzg179T6KspQ6k1|vlzIwvGzzfrdOmAy4Dnq=t*KTsEGk%34dPUb=v0K#GSNZt7X#)N1-eubj#0zO_BcjOQPyf0wP=!r+)5sg>&i7Er=B{ws!}1nP#!6ldd#g!tD$!a@79ecU%9*~mP)jUws)L-^|cATEg9cK z!l+x#Wzn)=BDM%RPM$(6p+spQ(jI4BsmwOrp1jPg@~(!#O6W-_a$`d@sfF>EC?fbM zD+&{%#r0%MynUAtPv6}2%Of#899KR=?e~i!b;$}?fYxYRIH~hFG2r1wjqF(>c{Bdt zLL7hbf+`I13R+}$SZmOmqiq@{L8OIphH^QWkum&{41ITp4$A^t$Py#DT%8!UYmJMB za@Mmc9F0+h3Cd{IThUX3M+jn4!kPh!%cJ4%q~=KwFQ4SM31DBI{q9< zm~8HJOAUAOUrRomsw2)wL<*qvnPs!!M^td z1EIhUf2cAL4EX84P%sn-R04zo!M@@^W>GNE5eNqTNW&GVr1XG)M<5XJ_j`gt)`ai) z&c?xa2;TzI`S;f)rr!+_{#S|V`#!<}eD6o)rzE~v;vMq*{HqeDC8qBKFZ85YM&c5D zi^%Isyj|i-{8*Ie4@ium<#)t``fx5QHt-y<=7OH1YH>u)Nbk=TRpV|n{i7O?(nlL_{w*T(ZbrRF} zx>UYFV)|~Ea7tqOewT2M#Pl66;rj?=02Id((YB^3b`+eMQiS74teK*WdnZof~9aEw93MfB+}k5GH`?J?m_-0+XD5>%#FV9Mgx<1YL|7haB< zB1x40j0^vh3s1Z7mH4>XS)YEJ=fwZ$!oP6gWf&W0`Bg5w!G&*d;XW6B)PBH3gHt7Hz3@Ipdfq_VLQU75I&7?6M}{iMrc6ThER|2R|q>0A_#wI9s&$| z*VE|$FU()S>2c&ry-R*hu7L%+WtukIo7A|c>E4u5V<)g3brj3` z^0|#@j^l-Sr+Hh@(?txM&r>Cp-FBWTA-*ee5ILEx=E+veZZc1{qHBA(!0HR?D&JD( z8k8qmxrF?~tX#Tt)0s=nYUqjWHs`3A-DV;$e}9S7GS|kE5?nh=OrV<8t>N9(QJkc0-lpO7fes)}wTX?T zbi!8AmWsvjw-vP{4x{M&jL1rpv@q6fYrWIS;R#JS=wav@I$XhdpyH@qvj&3}oBKrV zoemd4MvKJ4ZOu41z|lhXtinNlVcjgnSqjbqwT^b2y6SP9o1C)bDsUE<&|>Xv&61ip zs9Yd_>jZy9&c);@kp+{~?L*6U$cCMszl9~He4te*~ zvb&FUWq6n8vO&+?c6-QThkPc#q#US-PyUhTuUz%^u|2NzGIu~ z@a6$NWKzeQlAM=TQz~^R=W*rv3^`9MvJ*y>uVCfbSBiLLim{oelQ5=vq;ewL6>Y>D z+&uepf;7t$P?J=kcflboo!^H%HCEroiIj`+ zEEfc#%J)HBPKLt^ky70XQ{ouvlbQBdeNN0cy`wECk2hl8&Nn^h$b4stnA3V2-h$_} zxF+`z1DTENeqB0QTQ?(7Zr1ZmYqntdY?|4r<+Ns-Hg0tM?-gSDYBnpSYgQM&#gEKc4g literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion.cpp b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion.cpp new file mode 100644 index 0000000..3da5edb --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Common Subsequence/minimum_number_of_insertion_or_deletion.cpp @@ -0,0 +1,59 @@ +/* Dynamic Programming C++ implementation of LCS problem */ +#include +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "HEAP"; + string Y = "PEA"; + + int m = X.length(); + int n = Y.length(); + + cout << "The number of deletion is : " + << m - lcs( X, Y, m, n )<qPhA`S@RfI>{v@4xq- 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 z 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 +#include +#include +using namespace std; + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +string lcs( string X, string Y, int m, int n ) +{ +int L[m+1][n+1]; + +/* Following steps build L[m+1][n+1] in bottom up fashion. Note + that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */ +for (int i=0; i<=m; i++) +{ + for (int j=0; j<=n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + else if (X[i-1] == Y[j-1]) + L[i][j] = L[i-1][j-1] + 1; + else + L[i][j] = max(L[i-1][j], L[i][j-1]); + } +} + +// Following code is used to print LCS + +string str = ""; +// Create a character array to store the lcs string +// char lcs[index+1]; +// lcs[index] = '\0'; // Set the terminating character + +// Start from the right-most-bottom-most corner and +// one by one store characters in lcs[] +int i = m, j = n; +while (i > 0 && j > 0) +{ + // If current character in X[] and Y are same, then + // current character is part of LCS + if (X[i-1] == Y[j-1]) + { + str.push_back(X[i-1]); // Put current character in result + i--; j--; // reduce values of i, j and index + } + + // If not same, then find the larger of two and + // go in the direction of larger value + else if (L[i-1][j] > L[i][j-1]) + i--; + else + j--; +} + +// Print the lcs +reverse(str.rbegin(), str.rend()); +return str; +} + +/* Driver program to test above function */ +int main() +{ +string X = "AGGTAB"; +string Y = "GXTXAYB"; +int m = (X.length()); +int n = (Y.length()); +cout<<"The LCS of these strings is : "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 kQdSnE)D|YKD5Slzs-WV^D +#include +using namespace std; + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +string lcs( string X, string Y, int m, int n ) +{ + int L[m+1][n+1]; + + /* Following steps build L[m+1][n+1] in bottom up fashion. Note + that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */ + for (int i=0; i<=m; i++) + { + for (int j=0; j<=n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + else if (X[i-1] == Y[j-1]) + L[i][j] = L[i-1][j-1] + 1; + else + L[i][j] = max(L[i-1][j], L[i][j-1]); + } + } + + // Following code is used to print LCS + //int index = L[m][n]; + + // Create a character array to store the lcs string + string str = ""; // Set the terminating character + + // Start from the right-most-bottom-most corner and + // one by one store characters in lcs[] + int i = m, j = n; + while (i > 0 && j > 0) + { + // If current character in X[] and Y are same, then + // current character is part of LCS + if (X[i-1] == Y[j-1]) + { + str.push_back(X[i-1]); // Put current character in result + i--; + j--; // reduce values of i, j and index + } + + // If not same, then find the larger of two and + // go in the direction of larger value + else if (L[i-1][j] > L[i][j-1]) + { + str.push_back(X[i - 1]); + i--; + } + + else + { + str.push_back(Y[j - 1]); + j--; + } + } + + + while (i > 0) + { + str.push_back(X[i - 1]); + i-- ; + } + + // If X reaches its end, put remaining characters + // of Y in the result string + while (j > 0) + { + str.push_back(Y[j - 1]); + j--; + } + + // reverse the string and return it + reverse(str.rbegin(), str.rend()); + return str; + + } + +/* Driver program to test above function */ +int main() +{ + string X = "AGGTAB"; + string Y = "GXTXAYB"; + int m = X.length(); + int n = Y.length(); + // lcs(X, Y, m, n); + cout << "LCS of " << X << " and " << Y << " is " << lcs(X, Y, m, n); + return 0; +} diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching b/Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching new file mode 100644 index 0000000000000000000000000000000000000000..5be11d2c7eccc5287d1ea362447405eb7596cd89 GIT binary patch literal 24868 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 G+5Z7CQ#)w@ literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching.cpp b/Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching.cpp new file mode 100644 index 0000000..21f151f --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Common Subsequence/sequence_pattern_matching.cpp @@ -0,0 +1,60 @@ +/* Dynamic Programming C++ implementation of LCS problem */ +#include +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AXY"; + string Y = "ADXCPY"; + + int m = X.length(); + int n = Y.length(); + + if(lcs(X, Y, m, n) == m) + cout<<"True\n"; + else + cout<<"False\n"; + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence b/Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence new file mode 100644 index 0000000000000000000000000000000000000000..2a042a4625d812b86b0afecf569fd2b00bd89809 GIT binary patch literal 25004 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 literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence.cpp b/Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence.cpp new file mode 100644 index 0000000..1784bf0 --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Common Subsequence/shortest_common_supersequence.cpp @@ -0,0 +1,58 @@ +/* Dynamic Programming C++ implementation of LCS problem */ +#include +using namespace std; + +// int max(int a, int b); + +/* Returns length of LCS for X[0..m-1], Y[0..n-1] */ +int lcs( string X, string Y, int m, int n ) +{ + int L[m + 1][n + 1]; + int i, j; + + /* Following steps build L[m+1][n+1] in + bottom up fashion. Note that L[i][j] + contains length of LCS of X[0..i-1] + and Y[0..j-1] */ + for (i = 0; i <= m; i++) + { + for (j = 0; j <= n; j++) + { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X[i - 1] == Y[j - 1]) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = max(L[i - 1][j], L[i][j - 1]); + } + } + + /* L[m][n] contains length of LCS + for X[0..n-1] and Y[0..m-1] */ + return L[m][n]; +} + +/* Utility function to get max of 2 integers */ +// int max(int a, int b) +// { +// return (a > b)? a : b; +// } + +// Driver Code +int main() +{ + string X = "AGGTAB"; + string Y = "GXTXAYB"; + + int m = X.length(); + int n = Y.length(); + + cout << "Length of shortest common supersequence is " + << m + n - lcs( X, Y, m, n ); + + return 0; +} + +// This code is contributed by rathbhupendra diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS new file mode 100644 index 0000000000000000000000000000000000000000..ccfd03ae4b7625a113cfc35c03157012713afff1 GIT binary patch literal 14416 zcmeHOU2Igx6`nQFI3dXz;xwdf;thnBG!od@CQv{!KSQo%>=@hIA~$5bzP`3stbeq7 zmmjIynz~3_Zj3BNsq#Qoq)JItp^CJ9K&s?IakEy1Qd9YX2S4mf;ku&Iszs_*HQ9b= z?%e&kKoq}JYIH|CKj+LjXU=>xcV>5W?w|kt_s|uc_oQMZ*^6kZQ)V(gI;8l1 zdlSkYtrsPt%ah->5b4pA@zDVh9~~Tnpx@p_Wv@>eA=+=F+&+!_9CCLd|tD4JA-a5? zB~7t`{{9vp1tk(PH37S%;GEBHr_R>ad9Vvo>M5<9=@;Xs}2>L1%`nEIH z0-EsIfP4k?3#gZy7&{6_X$?A&Dbd_1lmB?ED{uf=ktU%3Vg<(~@VK!E@{`Eh(y8RO zM7)37!0E&QXi8s4CO_(~W^VOd-@`6k{9XR;k6sSLEvYBx7{=(x)ON94U-fOYYmmLP z1@k96`SMK!n#RS{yx(-_&h zU#UQvv2P-iKbPP*)vqX;@C{OcK!8Ai!2be)sAm0Do4nVj*=s(+!KK+uv-q-RW%5?~ zo}Io|_}I#8)?F}i+SH!2^ld|%ybBh;s#(j>UYXUboMvah$=uG$V>ine==6oy z6`L>Y=J&!=?-8x@1c5HLNfhT9#Tb4MuSSAXX(PV`DM+zckG7qA6zrxwc)y-(9le+$GB#% zc}XhD^~m!3)Cp#-WY%a?d;4)OX;aMxDrW{ZH2c{CvF!EeJmPjnslvRSpGkqezmn`U zE#I6Yz_Z))h3nRzH0zFLr5$am>0Nh)?~uqfjn+PT)#)Z}waQVfax|Cai_#&vzKgqg zK0HOYre^PLqak#@s9n!h5pY`Qx@LXi`~&L^lONiAQ3AENG)q9i6+3gqIq_+s0Nv-H zYkln8maxq8~>~ zf1%bds5M8e9JOYsRR_JL-%_iWTEC(sp%mJHFLw0%_8^Eo$n@Kk z64CQdF-E@yv4`;;auvRBk~Q#Fu~43vj2)3>Py`4B2m}ZO2m}ZO2m}ZO2m}ZO2m}ZO z2m}ZO2z==gIE4QQ#u^WYcBLCLQ4k zyn@xNo2SQ(R-JE;54b&I=+r5J!1vVHXe<#oPm2@vYj>gcW)u6rz1Qz5)FK9&;wv6Qi6$S|SEPmsY45hG_ZX*IdxK7GjR<7JUm`JCFUBByBuAWG7 z>GsZYRR!U}2G?whTs&I0lzAMX=1Ii*lee00Q3qr31o1n;A50o!;|7UQ3JJWwQ6*T- zNDQhwS=GoeUS}}$v}xcii5RW#w%*1>Jk=SGvqlPSS;ca-DDuyddaibQRjw-1HxZ)v zFUB@P;%WS0)rt5P`roQg(c_B#K+zQcLj8-LJYr*reg?5Gq(7nPdZH2Y=DkO;pXkRC zdmeG+q0YjP_ueakSXPX#l;!jfeDtq7zgO(bcdFR?+@CA5D>N z6e3S?@q{gfFySvm8M9uC`dMV!2o#r30bJ{m>HP-^+oJe-dSBsd$P_2F5?c|5^Um9L zLOi%Bh1{?HBZm&jFL2nDi9O_)DV?+{Iba^t`a(y`O4W*o%1RaGaZ*xpFOd?h?vE0q z^7bh4%TFL&9KN#$jECGY6&H*=iz+zol_Od5!f{*jx+$Jk58OH>kGxg-e7rIL&O=?@ zjiS3raN1q!Ha*;Aj1D9oad*%Kg$vicW<2{nqNiSP-u;@8X4HP$rS76J+&T}vhni2u z2aHkNCS_xnuEJL66d}j0)z#J`y4t{0c)KpEv5JC4o39@@Q1%vD!f3)M60-4R{6x$& I@c7B}Uy-TA%>V!Z literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS.cpp b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS.cpp new file mode 100644 index 0000000..a72e306 --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS.cpp @@ -0,0 +1,59 @@ +#include + + +using namespace std; + +int lis(int input[], int n) +{ + int out[n + 1]; + out[0] = 1; + for (int i = 1 ; i < n ; i++) + { + out[i] = 1; + for (int j = i - 1 ; j >= 0 ; j--) + { + if (input[j] > input[i]) + continue; + int possibleAns = out[j] + 1; + + if (possibleAns > out[i]) + out[i] = possibleAns; + + } + } + + int ans = 0; + for (int i = 0 ; i < n ; i++) + { + if (out[i] > ans) + ans = out[i]; + + } + // out.clear(); + return ans; + +} + +int main() +{ +#ifndef ONLINE_JUDGE + + freopen("input.txt", "r", stdin); + + freopen("output.txt", "w", stdout); + +#endif + int n; + cin >> n; + int input[n + 1]; + + for (int i = 0; i < n; ++i) + { + cin >> input[i]; + } + + cout << lis(input, n) << endl; + + // input.clear(); + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS_with_maximum_sum.cpp b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS_with_maximum_sum.cpp new file mode 100644 index 0000000..d37b035 --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/LIS_with_maximum_sum.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +using namespace std; + +// Iterative function to find maximum sum of an increasing subsequence +int MSIS(int arr[], int n) +{ + // array to store sub-problem solution. sum[i] stores the maximum + // sum of the increasing subsequence that ends with arr[i] + int sum[n] = { 0 }; + + // base case + sum[0] = arr[0]; + + // start from second element in the array + for (int i = 1; i < n; i++) + { + // do for each element in subarray arr[0..i-1] + for (int j = 0; j < i; j++) + { + // find increasing subsequence with maximum sum that ends with + // arr[j] where arr[j] is less than the current element arr[i] + + if (sum[i] < sum[j] && arr[i] > arr[j]) + sum[i] = sum[j]; + } + + // include arr[i] in MSIS + sum[i] += arr[i]; + } + + // find increasing subsequence with maximum sum + int msis = INT_MIN; + for (int x : sum) + msis = max(msis, x); + + return msis; +} + +int main() +{ + int arr[] = { 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11 }; + int n = sizeof(arr) / sizeof(arr[0]); + + cout << "Maximum sum of increasing subsequence is " << + MSIS(arr, n); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence new file mode 100644 index 0000000000000000000000000000000000000000..143de97e9252355cdea3905d9c257092b369bc3b GIT binary patch literal 40356 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 MOw9RlgG*8V3kW12hyVZp literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence.cpp b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence.cpp new file mode 100644 index 0000000..50ecb8d --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/longest_bitonic_subsequence.cpp @@ -0,0 +1,53 @@ +#include +#include +using namespace std; + +// Function to find Longest Bitonic Subsequence in an array +int calculateLBS(vector arr) +{ + // I[i] stores the length of the longest increasing subsequence + // ending with arr[i] + vector I(arr.size()); + + // D[i] stores the length of the longest decreasing subsequence + // starting with arr[i] + vector D(arr.size()); + + int n = arr.size() - 1; + + I[0] = 1; + for (int i = 1; i <= n; i++) { + for (int j = 0; j < i; j++) { + if (arr[j] < arr[i] && I[j] > I[i]) + I[i] = I[j]; + } + I[i]++; + } + + D[n] = 1; + for (int i = n - 1; i >= 0; i--) { + for (int j = n; j > i; j--) { + if (arr[j] < arr[i] && D[j] > D[i]) + D[i] = D[j]; + } + D[i]++; + } + + // consider each element as peak and calculate LBS + int lbs = 1; + for (int i = 0; i <= n; i++) + lbs = max (lbs, I[i] + D[i] - 1); + + return lbs; +} + +int main() +{ + + vector arr { 4, 2, 5, 9, 7, 6, 10, 3, 1 }; + + cout << "Length of Longest Bitonic Subsequence is " << + calculateLBS(arr); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Longest Increasing Subsequence/output.txt b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/output.txt new file mode 100644 index 0000000..6799a4f --- /dev/null +++ b/Data Structures/Dynamic Programming/Longest Increasing Subsequence/output.txt @@ -0,0 +1 @@ +Length of Longest Bitonic Subsequence is 7 \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Matrix Chain Multiplication/MCS b/Data Structures/Dynamic Programming/Matrix Chain Multiplication/MCS new file mode 100644 index 0000000000000000000000000000000000000000..2dd4af3780ebaadd48d597bf186548097e3de5a3 GIT binary patch literal 14428 zcmeHOZ)_CD6`wOEK!Kd05Yjf_O9(9uDx70X_!E$gz0F!+ID9?{xkbZyy|y>po!z@V zFl{e27%G;HTYqXRwNm*|sa3vIsj4VxRdhfayHVPb3RP4>m7~&XExFWbKj2mtl>vWD!V=eF|Ac z<~-K)lG3TPAEnmH6slAg)CgxQ9>95ra=fF`MEKWKwlS$MMKfiDBogPQK4?k>l^?J1 z6BrEIk5;=jq)X9lsAfa1;Fg@{%zRgFuE~!#`nZdCP+EAp=dfJjmEt2j-lwMq^el}0 zc()|pD-wWo;(ad7i?3JHxIU=q112|RM$I9V=DNcUoqO%)Zbk94{} z<2CxndlLSH*XPSkGX85+*3f zWI5_Va*&BSN8wQOy!$*_V^1RYL9a#q_D-xT44mdPhD?cM$`n7AWd*NLE7EcJf2N|v zRq*j;5#&|KJMy{gj+D{0qx)>i&{t;2a|8WU`)9?J3IRgTbZ(y30s-ir#Rse`jVyEg=srKWhW+_7%YUE zm>9kuvh$9Wzis`|PTaPXTTVSX?ZmCnbzz}Q4Lc!K8@H>!t=etVs#cf?|FrroDLW*G zu3L#a>PX?PI+DNRwBS*8jg`2IXAc)c2x9UyAu4xOtqmOf1{|#a$2#KRU9>n>^<_(W zU@H&Q;kTnFZuEp}F93lt$!7$7&Zt&?8qv(Cc7EE4<8**+1h(5f<8ZBK--tja)RCnl z^aOkL0UT+ny+XCxX2z5|gbTczsx@|X7VSnt@0_nc)P5s~|gu(#fEdI`uHQ%4$(5-y!w2;r9mh7j!h zjJoGTJfRrANC$Ua5u<24al=vJ7G5dGTT?#X*~Bz#YEIlJjnCynaG`*Y<*ME4sG)Iq zP1C4welq8E@!-OA`0BJXMr@I}r8rJeC~c%nsMfg4Vz_n)_8xzP52U<Y++GwFV&JFYmTi3xZOgOI++)A20EAgg7U;E0JSEI*IjcPaiiD;yu zfmf#!mhL1iY+pW}!pvnFRu~gAdu+EGo0#1ed>3=}5|UN@tg{Wm=hGdB4hl3u2^S4lcg(s@XT{`(t4>)B?; zHrH}?5Z|2oR(vxQ`pVOl-)ITMZK3aNOOWY92Nd>{tRu317B$%*g=+BSi~gqtb?ilC z`hS!X=|fne^#31WtpeIp(yMU^tC~P#W3_-M^J7#5DPSOAAYdS1AYdS1AYdS1AYdS1 zAYdS1AYdS1;L%`UCw?!W-yH7ZcLb{M$$CcCRkDATte=o|MApyA`hcueSw9-=1)~fY z2p9+$2p9+$2p9+$2p9+$2p9+$2p9+$`2S#F&1Uu`igZmQ=bcC5WN zHd@x&pqXa}^j1xI-so0D5APiu(3-phIy8sj4nSM7NhZj0k;{HV)Mj*&ycy+huv=kjSCUAg6MJcrzXcBT5YWJ=$Y&*{7;sp+QD zek2~{ZXhgIQ(?T@=+E)4WKQ4JtDA6CP7~mhPVW>x7vyn~=?c~i%$4N026hR*u7=6K9747SI;z*1a?nb2ZxYI)YuS-29_4lPtcV4Lf zG2Cw<|A_qEYQNNDQtyPmDKx}}q@JaIT)6SxpSVE!3fymwxOjkPVc>c1lfVr+-F$ZY zpAouyADfHNu4sK4neIMqLSBr2gkkTRTaBF0U#wg#W=@OQzuC~X_c6AaGP4CXn9|<4sI6tO zZgZQ;VjabHQgV_Te5s*wZ!fi%?>K0!+-nxtWze+1nNV>ch+U_m#XTatEok0BQHthp zJ+`@4Ls8lfb?|sS{n5$`vL4 zLU|A}M40cwn?8Cj*J>bM8F2%TH;|KftheS$W?BjZGrU2`{ypwVg){9Tu{E4Ay7dgs zsS*>1O9y2uBAJ_98Atme3eP=KT?*v0<_ya)xt2<1dU1%PQh4)Do-^#F=H{|@(o*^h Sc)FOlfvj;F2N6ENNdE +using namespace std; + +int tdp[5][5];//size of array + 1 + +int MCS(int m[], int i, int j) +{ + if(i == j) + { + tdp[i][j] = 0; + return 0; + } + + if(tdp[i][j] != -1) + return tdp[i][j]; + + int ans = INT_MAX; + for(int k=i ; k +#include +#include +using namespace std; + +// N x N matrix +#define N 5 + +// Function to check if cell (i, j) is a valid cell or not +bool isValid(int i, int j) +{ + return (i >= 0 && i < N && j >= 0 && j < N); +} + +// Find longest path starting from cell (i, j) formed by adjacent +// numbers in the matrix +string findLongestPath(int mat[N][N], int i, int j) +{ + // if the cell is invalid + if (!isValid (i, j)) + return 0; + + // string to store path starting (i, j) + string path; + + // recur top cell if its value is +1 of value at (i, j) + if (i > 0 && mat[i - 1][j] - mat[i][j] == 1) + path = findLongestPath(mat, i - 1, j); + + // recur right cell if its value is +1 of value at (i, j) + if (j + 1 < N && mat[i][j + 1] - mat[i][j] == 1) + path = findLongestPath(mat, i, j + 1); + + // recur bottom cell if its value is +1 of value at (i, j) + if (i + 1 < N && mat[i + 1][j] - mat[i][j] == 1) + path = findLongestPath(mat, i + 1, j); + + // recur left cell if its value is +1 of value at (i, j) + if (j > 0 && mat[i][j - 1] - mat[i][j] == 1) + path = findLongestPath(mat, i, j - 1); + + // note that as matrix contains all distinct elements, + // there is only one path possible from current cell + + // return path starting from (i, j) + return to_string(mat[i][j]) + " - " + path; +} + +int main() +{ + int mat[N][N] = + { + { 10, 13, 14, 21, 23 }, + { 11, 9, 22, 2, 3 }, + { 12, 8, 1, 5, 4 }, + { 15, 24, 7, 6, 20 }, + { 16, 17, 18, 19, 25 } + }; + + string res; // stores longest path found so far + string str; // stores current path + int resSize = INT_MIN; // stores no. of elements in res + + // from each cell (i, j), find the longest path starting from it + for (int i = 0; i < N; i++) + { + for (int j = 0; j < N; j++) + { + // str would be like 1 - 2 - 3 - 4 - 5 - + string str = findLongestPath(mat, i, j); + + // find number of elements involved in current path + int size = count(str.begin(), str.end(), '-'); + + // update result if longer path is found + if (size > resSize) + res = str, resSize = size; + } + } + + // print the path + cout << res.substr(0, res.length() - 3); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Matrix/minimum_cost_reach_last_cell_of_matrix.cpp b/Data Structures/Dynamic Programming/Matrix/minimum_cost_reach_last_cell_of_matrix.cpp new file mode 100644 index 0000000..ef8959b --- /dev/null +++ b/Data Structures/Dynamic Programming/Matrix/minimum_cost_reach_last_cell_of_matrix.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +#include +using namespace std; + +// M x N matrix +#define M 5 +#define N 5 + +// Naive recursive function to find the minimum cost to reach +// cell (m, n) from cell (0, 0) +int findMinCost(int cost[M][N], int m, int n) +{ + // base case + if (n == 0 || m == 0) + return INT_MAX; + + // if we're at first cell (0, 0) + if (m == 1 && n == 1) + return cost[0][0]; + + // include cost of the current cell in path and recur to find minimum + // of the path from adjacent left cell and adjacent top cell. + return min (findMinCost(cost, m - 1, n), findMinCost(cost, m, n - 1)) + + cost[m - 1][n - 1]; +} + +int main() +{ + int cost[M][N] = + { + { 4, 7, 8, 6, 4 }, + { 6, 7, 3, 9, 2 }, + { 3, 8, 1, 2, 4 }, + { 7, 1, 7, 3, 7 }, + { 2, 9, 8, 9, 3 } + }; + + cout << "The minimum cost is " << findMinCost(cost, M, N); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Matrix/size_of_largest_submatrix_with_one's.cpp b/Data Structures/Dynamic Programming/Matrix/size_of_largest_submatrix_with_one's.cpp new file mode 100644 index 0000000..5f9f9f2 --- /dev/null +++ b/Data Structures/Dynamic Programming/Matrix/size_of_largest_submatrix_with_one's.cpp @@ -0,0 +1,66 @@ +#include +using namespace std; + +// M x N matrix +#define M 8 +#define N 6 + +// Function to find the size of largest square sub-matrix of 1's +// present in the given binary matrix +int findLargestSquare(int mat[M][N]) +{ + // lookup[i][j] stores the size of maximum square + // sub-matrix ending at mat[i][j] + int lookup[M][N]; + + // max stores the size of largest square sub-matrix of 1's + int max = 0; + + // fill in bottom-up manner + for (int i = 0; i < M; i++) + { + for (int j = 0; j < N; j++) + { + lookup[i][j] = mat[i][j]; + + // if we are not at the first row or first column and + // current cell has value 1 + if (i && j && mat[i][j]) + + // largest square sub-matrix ending at mat[i][j] will be + // 1 plus minimum of largest square sub-matrix ending at + // mat[i][j-1], mat[i-1][j] and mat[i-1][j-1] + + lookup[i][j] = min (min (lookup[i][j - 1], lookup[i - 1][j]), + lookup[i - 1][j - 1]) + 1; + + // update maximum size found so far + if (max < lookup[i][j]) + max = lookup[i][j]; + } + } + + // return size of largest square matrix + return max; +} + +int main() +{ + // input boolean matrix + int mat[M][N] = + { + { 0, 0, 1, 0, 1, 1 }, + { 0, 1, 1, 1, 0, 0 }, + { 0, 0, 1, 1, 1, 1 }, + { 1, 1, 0, 1, 1, 1 }, + { 1, 1, 1, 1, 1, 1 }, + { 1, 1, 0, 1, 1, 1 }, + { 1, 0, 1, 1, 1, 1 }, + { 1, 1, 1, 0, 1, 1 } + }; + + cout << "The size of largest square sub-matrix of 1's is " << + findLargestSquare(mat); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/Unbounded Knapsack/rod_cutting b/Data Structures/Dynamic Programming/Unbounded Knapsack/rod_cutting new file mode 100644 index 0000000000000000000000000000000000000000..e382d721141f0a2a7bcfd6d6f64a094a5df2adc1 GIT binary patch literal 12976 zcmeHO-D^}w6rYW;rcLaPp+QSO+*)G&BH2`JwNXgaODE{Y)J;GH88(}ZS+e;cyW2)+ zs5Qp+a*6JPP#-LW(iYo?R%k3jUlJop5Zb0?ANC=X^`UYXVhNImAk^*e+>d1UM*jgj zgL7xjnKQpR=Qne+v&-@KM-LvaW6ZOLv2#U?u??u{wTuljFM5opDA4YDxsEt=`1CUI- zFPByRg?f8pD*?OluGx5-YygrA@RotCju4?(yg$-&#@4&>#%w%?Gm`U*8(WA(&qtA- zb`k06=!Kyh@0N{6XNU^PZVYS0deS+$iYmmBhL#3#_;^#mIxRR41?R*$FLq1YO_gj& zCB&KD71o}P=fKb;`^aFnb>8x2^2&u!^ zsnD6EO8&cffU2M*G2e+ff8a$3UQ}A6CK2neiALIL+RsMYAyat;mHfE3rF7RXH{Ub9 z*SfkV+y5zf8#*tl8Kd$7W2n@(xU4AJfqprvQ??;~!l|bP^9rqt5Y07A>ehJy;aTwo z{)Be!tgfwwQ;{~)&wcs!%!5CNh4z87v3R(<`j9=vTx~0!0QtN7}PF++k*F!Zlm}bfae0HLjV#@GaG%cj2x$Ymu+7o;tQv~#@ z+;bc1)O7KALdZTOGhH=we|jkE;h{hDvSghJN6Lpu+A&O_5{$}VdDF$ZD7HI3XbQ9M(8WN^&*3oGg+Pg#SEwX%!ZgJh(p zu?!E*ARhANE}yuE*vOaPc*vj9i!Y%`KVd{GzLW(3Gaq1YXxyWzsqEO}T+UXdO;tL3 z2`a2P_hkAO_2Tnb9Q%sMD=Tr=;Ccl-SmOI1YU&kbm~Kb9dWCEArzed7wnr&dHZ%MD zc)2#Xgxy`>I$AxkVEhDgK6J->da|Qh*?fUqWGnVQKGHhRM-myFyYGNypSx*wj_jcH zky2CV_4U>0Y5qm%wpqH2zJ9BzGjNpXo`s`B*D8H5t@~5Pj(-v6$ia1FGIfI)KbU}( zhiNiJ1poFw($rZiqS|pd=|e=H!b~Ym=EZ}9j8_1$fEEMWxn$J9=DJ52rZ1S;^(L-r zz{^aQ$iac3S0IBnV@2-7>u{q1M{ixw>C_r^Mas2_bN4*T&l9I7lewy|aP7)feQiF! zr7IXaHuBmx=rja!RU;6Soutg(&*gHRbXCmGQO`%cKhb0C0J?N99YCeG<|WkEQLEam zyXULuQ^{}XPD$T+_n@Up-&d(npGYmk-LV|iF3TN9AzR6SWI!??8ITM}1|$QL0m*=5 zKr$d1kPJu$o;?OW#_t34Bfv$wP1^0V7paU$G9Vd{3`hnf1CjyBfMh^2AQ_MhNCqSW z|6c|+yvYI-eMP;XRQO=1ON2VR#F<2}zny*1&yw|&9BU@Yi#FtWBdI+}_AzS)8OP#X zNJ8#M7C44tB`&0nU?fWVa_IYzcpmSt06YSD%teBgcLy=Co)vX>its=rE$vZCAr4Z(=@X*;0gV* zOyuUv9WJ@YB~xBAC7)2f2i!9ApYwHIWPGopMTphp36ocBs%wi1w%OdA0*$rt&Q7h` zdo11*i0>An_So+3;6P(URZkpk5rN(Gk6bGpZ3>8YkntXl#Tp|pwT<_Rz+Tbfv+R#r YaCv5-C@>=yp6LLN&4 + +using namespace std; + +// Returns the maximum value that +// can be put in a knapsack of capacity W +int knapSack(int W, int wt[], int val[], int n) +{ + int i, w; + int K[n + 1][W + 1]; + + // Build table K[][] in bottom up manner + for (i = 0; i <= n; i++) { + for (w = 0; w <= W; w++) { + if (i == 0 || w == 0) + K[i][w] = 0; + else if (wt[i - 1] <= w) + K[i][w] = max(val[i - 1] + K[i][w - wt[i - 1]], K[i - 1][w]); + else + K[i][w] = K[i - 1][w]; + } + } + + return K[n][W]; +} + +int main() +{ + int val[] = { 60, 100, 120 }; + int wt[] = { 10, 20, 30 }; + int W = 50; + int n = sizeof(val) / sizeof(val[0]); + printf("%d\n", knapSack(W, wt, val, n)); + return 0; +} diff --git a/Data Structures/Dynamic Programming/Unbounded Knapsack/unbounded_kanpsack b/Data Structures/Dynamic Programming/Unbounded Knapsack/unbounded_kanpsack new file mode 100644 index 0000000000000000000000000000000000000000..e382d721141f0a2a7bcfd6d6f64a094a5df2adc1 GIT binary patch literal 12976 zcmeHO-D^}w6rYW;rcLaPp+QSO+*)G&BH2`JwNXgaODE{Y)J;GH88(}ZS+e;cyW2)+ zs5Qp+a*6JPP#-LW(iYo?R%k3jUlJop5Zb0?ANC=X^`UYXVhNImAk^*e+>d1UM*jgj zgL7xjnKQpR=Qne+v&-@KM-LvaW6ZOLv2#U?u??u{wTuljFM5opDA4YDxsEt=`1CUI- zFPByRg?f8pD*?OluGx5-YygrA@RotCju4?(yg$-&#@4&>#%w%?Gm`U*8(WA(&qtA- zb`k06=!Kyh@0N{6XNU^PZVYS0deS+$iYmmBhL#3#_;^#mIxRR41?R*$FLq1YO_gj& zCB&KD71o}P=fKb;`^aFnb>8x2^2&u!^ zsnD6EO8&cffU2M*G2e+ff8a$3UQ}A6CK2neiALIL+RsMYAyat;mHfE3rF7RXH{Ub9 z*SfkV+y5zf8#*tl8Kd$7W2n@(xU4AJfqprvQ??;~!l|bP^9rqt5Y07A>ehJy;aTwo z{)Be!tgfwwQ;{~)&wcs!%!5CNh4z87v3R(<`j9=vTx~0!0QtN7}PF++k*F!Zlm}bfae0HLjV#@GaG%cj2x$Ymu+7o;tQv~#@ z+;bc1)O7KALdZTOGhH=we|jkE;h{hDvSghJN6Lpu+A&O_5{$}VdDF$ZD7HI3XbQ9M(8WN^&*3oGg+Pg#SEwX%!ZgJh(p zu?!E*ARhANE}yuE*vOaPc*vj9i!Y%`KVd{GzLW(3Gaq1YXxyWzsqEO}T+UXdO;tL3 z2`a2P_hkAO_2Tnb9Q%sMD=Tr=;Ccl-SmOI1YU&kbm~Kb9dWCEArzed7wnr&dHZ%MD zc)2#Xgxy`>I$AxkVEhDgK6J->da|Qh*?fUqWGnVQKGHhRM-myFyYGNypSx*wj_jcH zky2CV_4U>0Y5qm%wpqH2zJ9BzGjNpXo`s`B*D8H5t@~5Pj(-v6$ia1FGIfI)KbU}( zhiNiJ1poFw($rZiqS|pd=|e=H!b~Ym=EZ}9j8_1$fEEMWxn$J9=DJ52rZ1S;^(L-r zz{^aQ$iac3S0IBnV@2-7>u{q1M{ixw>C_r^Mas2_bN4*T&l9I7lewy|aP7)feQiF! zr7IXaHuBmx=rja!RU;6Soutg(&*gHRbXCmGQO`%cKhb0C0J?N99YCeG<|WkEQLEam zyXULuQ^{}XPD$T+_n@Up-&d(npGYmk-LV|iF3TN9AzR6SWI!??8ITM}1|$QL0m*=5 zKr$d1kPJu$o;?OW#_t34Bfv$wP1^0V7paU$G9Vd{3`hnf1CjyBfMh^2AQ_MhNCqSW z|6c|+yvYI-eMP;XRQO=1ON2VR#F<2}zny*1&yw|&9BU@Yi#FtWBdI+}_AzS)8OP#X zNJ8#M7C44tB`&0nU?fWVa_IYzcpmSt06YSD%teBgcLy=Co)vX>its=rE$vZCAr4Z(=@X*;0gV* zOyuUv9WJ@YB~xBAC7)2f2i!9ApYwHIWPGopMTphp36ocBs%wi1w%OdA0*$rt&Q7h` zdo11*i0>An_So+3;6P(URZkpk5rN(Gk6bGpZ3>8YkntXl#Tp|pwT<_Rz+Tbfv+R#r YaCv5-C@>=yp6LLN&4 + +using namespace std; + +// Returns the maximum value that +// can be put in a knapsack of capacity W +int knapSack(int W, int wt[], int val[], int n) +{ + int i, w; + int K[n + 1][W + 1]; + + // Build table K[][] in bottom up manner + for (i = 0; i <= n; i++) { + for (w = 0; w <= W; w++) { + if (i == 0 || w == 0) + K[i][w] = 0; + else if (wt[i - 1] <= w) + K[i][w] = max( + val[i - 1] + K[i][w - wt[i - 1]], + K[i - 1][w]); + else + K[i][w] = K[i - 1][w]; + } + } + + return K[n][W]; +} + +int main() +{ + int val[] = { 60, 100, 120 }; + int wt[] = { 10, 20, 30 }; + int W = 50; + int n = sizeof(val) / sizeof(val[0]); + printf("%d\n", knapSack(W, wt, val, n)); + return 0; +} diff --git a/Data Structures/Dynamic Programming/edit_distance.cpp b/Data Structures/Dynamic Programming/edit_distance.cpp new file mode 100644 index 0000000..d832895 --- /dev/null +++ b/Data Structures/Dynamic Programming/edit_distance.cpp @@ -0,0 +1,56 @@ +#include +#include +using namespace std; + +// Function to find Levenshtein Distance between string X and Y +// m and n are the number of characters in X and Y respectively +int dist(string X, int m, string Y, int n) +{ + // for all i and j, T[i,j] will hold the Levenshtein distance between + // the first i characters of X and the first j characters of Y + // note that T has (m+1)*(n+1) values + + int T[m + 1][n + 1] = { 0 }; + + // source prefixes can be transformed into empty string by + // dropping all characters + + for (int i = 1; i <= m; i++) + T[i][0] = i; // (case 1) + + // target prefixes can be reached from empty source prefix + // by inserting every character + + for (int j = 1; j <= n; j++) + T[0][j] = j; // (case 1) + + int substitutionCost; + + // fill the lookup table in bottom-up manner + for (int i = 1; i <= m; i++) + { + for (int j = 1; j <= n; j++) + { + if (X[i - 1] == Y[j - 1]) // (case 2) + substitutionCost = 0; // (case 2) + else + substitutionCost = 1; // (case 3c) + + T[i][j] = min(min(T[i - 1][j] + 1, // deletion (case 3b) + T[i][j - 1] + 1), // insertion (case 3a) + T[i - 1][j - 1] + substitutionCost); // replace (case 2 & 3c) + } + } + + return T[m][n]; +} + +int main() +{ + string X = "kitten", Y = "sitting"; + + cout << "The Levenshtein Distance is " << + dist(X, X.length(), Y, Y.length()); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string b/Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string new file mode 100644 index 0000000000000000000000000000000000000000..a58650e3cc55958ed00d48a43df8d2eab6948904 GIT binary patch literal 21244 zcmeHPeQX@X6`yk)VsOYgDHIwYxg%SGr$r=ZEh^xApYp)I;v$0IQ%qwLLls8hDw)lBLhDLMfXFVd z|9Th$`Y+1NGK5R>#R;SeA?NW#vN@h3+2z$PGv)1QUKv1c{#ymg7aWJ5es#;NxEHL zmy}l_^9dJTcG;XKJ0A*lw(wAAYXk-D@_MDbs1!ojE~8LB^^>QCoSi%N?cmjWb~l>6 z#besZEX9DuB{BLhqd;v>B+lC+1>FRAdUkuZ-YVl&F?vZ{bQvdg+KR@rqHK+JhdAQ8wD?D};{{p4_9gbU^6 zIn7jlyw}$3-lgoUF}=^2U)t%B9Kdv4USh`NcM8_E67vbF5`0v5nV&JTDTSEm{ef$gg|;6+ROj2;-&B0e&RRD_pW(-$2&(OOr!-CS8}E9NM90YV>z%^*W7$S`fFOr2$`95>EpWc^f-LYe1nui0-R5$>qdIUA^#1yit~}{J3JUalQq?aWIAi<{`_k_6)(!6EkCNW(nCw3lXxIrfGP!KR zcnCXD>O3W@_MELaa3){cy_|{iM=l-%@33;2M5ujL_h1)N?du*hz6+lM-(}*Au>n|E zgWTh4UvkX23JO@1UQjZ|CG1~WlriIWaOguQp3&l*y33 zyACy_lPO~uLR9@|m*qVu(LlPS|41Zb4W;#?(R_AyuW^KUpqJ5wM9!G*jL~jpj2Rq> zv~pQJa+d5pa7KTFMv7kd>bM^`kJc3-+5yewp@LrH2CJq;W+G$Ex2m{|%}e-v&^V8T zyL{UAKx<}=MrxB8+N0;9N34sq640CP{c+(%If8z*&8L)O@VjYa5hj9+U}_DBkb zpaI#Q181hKf3ivT1grfE>q{#WYPw8K*BGjcW)Ms!!vi!rj1?pu6}tzr#!aS~P){+8 z>jbDHFs5SK5jDG)r@&%9F1`Km6uGgV@5L)?sE6?0{hcdS5r%fu7_@U9~J!!e--N6J@FW+?Z!Z#+`G-J8~yp% z1q+)s)7tKvQ&?t|ifTHMcy`|IMK5%+VrGgjMo%b$_h z(Kxv}gr+^#{!I|a-@^pojyD`^{B26LQR;7$Iz=gZf@r@QrN;*-wU1ISQ|c#_dY)4B zbTWRNQswZ*_|GT>RyO`)O5IAdM<{g%rhJm7f1@qpt2#{-TB91l1ia6I66;A`W7CGvdsNqH{)w2Tj8 zGlKRYMkIby#$z&mU&fbY{Hct~q`aGDyhg@e8Q&@6uZ@EpLmdw|9&kM1c);<1;{nG5 zjt3kMI3933;CR6Cz*oQni&wFObS!kSpY#2@8xxy3_f-ZX$%Ml8#@Mj}YE>|CII7hI zl}(`*Mda|dt}c$x+~bkXKsb~*%pdf!V@tq-Z|VcVLp<1ih_@vJu@;o3Pi)1f_PiNi zi{sOHI$?*apaP#S*dB=SL@W?W#8J%mT)8(2y5GuagDbIf?7gp*xl&mrs6DKQB-(aC=%z*fw;D%O-q1Ld5{Ep z3LWCxg#1tt`qP*5HNoAD+^(zw+V()0Do#XV&|XotaC{UWN|62?By#QCMOOQihFy(S zoWyzOE^epKG7QI;OW)*&Ia|36dWED`&214JYI6X5H$QvxnnKh-$7c zWR-1hne>3@htvh*i9`5CK87DDAfAJ^{@EG`g^At{dWY5#*Aj%HKrkO25Xih-9H(hY zI9uEifFvC1Dd}j(?=on?WJ1HwJp`yvuiMY=paVRtqzXf*Ga<**?7EMFb`FKuahE0K zGls|Wu6e9~Jr4aG_p*7VWB6dafBj&ocdW!)?>SiS_jo-O^snCI@l(>9a(Sg$i*Y7s z5jOg=H<6{joe^%nG#BWRNk^8A1 z6NV41-}xxVc}2o>#*6ru5k{TX?>tcVb0fq09h5x+r$n-sVLcavWin2GaaB<~56 zE_yMN?3X5{EOEV#J3tQq(}sO!W-k9>8~&3Ge`v!SQL{-h>ua&$qz(7k@UKmbyLtWI zmj4%9{y%IuYr_*ZOb6?rAE@TF0?|r@RS0M@advMt;x!1jBCJJNhd^IG+<~wW!G}P< zCvh7B9hcpJK;v;U!d&Ee7}oIr-OQ7JAh0iXg)1}XQ|Cc0=1BW8P4Yg+0$osSnx(lw zsktx8a}}0bj^`>!tXc&^u4DwG+08S_r^Gy=_yI9bFI<`NY-n4PL73(- zvgjF7tkFdj^QqEWu&t$f$}?tOhuJN`p)RF^#+0=J&#K2&`)YP}D&i@YM9C2_JB2Fa zp@%g*Hx=mgxw;CPuKvD;#?8F3k}Cz=wUt_DOL&GyJbGy6KAZe~e4m#qO5;{uAZB*P z`0%#|9=Ulm66#E7F=^JE{Iea8+;JX`bhZ^cX;uyA+h*!V;%rKqe`d_mY$!=)$J-;Z znT+3xQ4;Bh#@9APFT+5yk^VpSRmx6n{WV)3RD9kXEuu683x-ea_CQMuwRNPG{&1|{ z#~T`bb01&Tn~EkL*=N5X&tsOWZN{II%9qm4Fm0OJzWAoD-c)4XXH{6d8BiPYVKDd< z#U`PsR4#8$bD+;0Z(3S|o_7S9LKSm?n(Lc^mr F`!6wa6B_^k literal 0 HcmV?d00001 diff --git a/Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string.cpp b/Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string.cpp new file mode 100644 index 0000000..9365156 --- /dev/null +++ b/Data Structures/Dynamic Programming/find_number_of_time_pattern_appears_in_string.cpp @@ -0,0 +1,44 @@ +#include +using namespace std; + +// Function to count number of times the pattern Y[0..n) +// appears in given string X[0..m) as a subsequence +int count(string X, string Y, int m, int n) +{ + // T[i][j] stores number of of times the pattern Y[0..j) + // appears in given string X[0..i) as a subsequence + int T[m + 1][n + 1]; + + // if pattern Y is empty, we have found subsequence + for (int i = 0; i <= m; i++) + T[i][0] = 1; + + // if input string X is empty + for (int j = 1; j <= n; j++) + T[0][j] = 0; + + // if current character of both string and pattern matches, + // 1. exclude current character in both string and pattern + // 2. exclude only current character in the string + + // else if current character of string and pattern do not match, + // exclude current character in the string + + for (int i = 1; i <= m; i++) + for (int j = 1; j <= n; j++) + T[i][j] = ((X[i - 1] == Y[j - 1]) ? T[i - 1][j - 1] : 0) + + T[i - 1][j]; + + // return last entry in lookup table + return T[m][n]; +} + +int main() +{ + string X = "subsequence"; // input string + string Y = "sue"; // pattern + + cout << count(X, Y, X.size(), Y.size()) << endl; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/find_probability_that_person_is_safe.cpp b/Data Structures/Dynamic Programming/find_probability_that_person_is_safe.cpp new file mode 100644 index 0000000..23856d6 --- /dev/null +++ b/Data Structures/Dynamic Programming/find_probability_that_person_is_safe.cpp @@ -0,0 +1,67 @@ +/// C++ program to find the probability +// that we do not cross boundary of a +// matrix after N moves. +#include +using namespace std; + +// check if (x, y) is valid matrix coordinate +bool isSafe(int x, int y, int m, int n) +{ + return (x >= 0 && x < m && + y >= 0 && y < n); +} + +// Function to calculate probability +// that after N moves from a given +// position (x, y) in m x n matrix, +// boundaries of the matrix will not be crossed. +double findProbability(int m, int n, int x, + int y, int N) +{ + // boundary crossed + if (!isSafe(x, y, m, n)) + return 0.0; + + // N steps taken + if (N == 0) + return 1.0; + + // Initialize result + double prob = 0.0; + + // move up + prob += findProbability(m, n, x - 1, + y, N - 1) * 0.25; + + // move right + prob += findProbability(m, n, x, + y + 1, N - 1) * 0.25; + + // move down + prob += findProbability(m, n, x + 1, + y, N - 1) * 0.25; + + // move left + prob += findProbability(m, n, x, + y - 1, N - 1) * 0.25; + + return prob; +} + +// Driver code +int main() +{ + // matrix size + int m = 5, n = 5; + + // coordinates of starting point + int i = 1, j = 1; + + // Number of steps + int N = 2; + + cout << "Probability is " + << findProbability(m, n, i, j, N); + + return 0; +} diff --git a/Data Structures/Dynamic Programming/total_possible_solution_to_linear_equation_with_k_variables.cpp b/Data Structures/Dynamic Programming/total_possible_solution_to_linear_equation_with_k_variables.cpp new file mode 100644 index 0000000..ddfba2f --- /dev/null +++ b/Data Structures/Dynamic Programming/total_possible_solution_to_linear_equation_with_k_variables.cpp @@ -0,0 +1,42 @@ +#include +using namespace std; + +// Function to count total number of possible solutions of a +// linear equation of k variables +int count(int coeff[], int k, int rhs) +{ + // if rhs becomes 0, return 1 (solution found) + if (rhs == 0) + return 1; + + // return 0 (solution do not exist) if rhs becomes negative or + // no coefficient is left + if (rhs < 0 || k < 0) + return 0; + + // Case 1. include current coefficient coeff[k] in solution and + // recur with remaining value (rhs - coeff[k]) + + int include = count(coeff, k, rhs - coeff[k]); + + // Case 2. exclude current coefficient coeff[k] from solution and + // recur for remaining coefficients (k - 1) + + int exclude = count(coeff, k - 1, rhs); + + // return total ways by including or excluding current coefficient + return include + exclude; +} + +int main() +{ + // k coefficients of given equation + int coeff[] = { 1, 2, 3 }; + int k = sizeof(coeff) / sizeof(coeff[0]); + + int rhs = 4; + + cout << "Total number of solutions are " << count(coeff, k - 1, rhs); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Dynamic Programming/word_break_problem.cpp b/Data Structures/Dynamic Programming/word_break_problem.cpp new file mode 100644 index 0000000..a7c217f --- /dev/null +++ b/Data Structures/Dynamic Programming/word_break_problem.cpp @@ -0,0 +1,66 @@ +#include +#include +#include +#include +using namespace std; + +// Function to determine if string can be segmented into a space-separated +// sequence of one or more dictionary words +bool wordBreak(vector const &dict, string str, vector &lookup) +{ + // n stores length of current substring + int n = str.size(); + + // return true if we have reached the end of the string + if (n == 0) + return true; + + // if sub-problem is seen for the first time + if (lookup[n] == -1) + { + // mark sub-problem as seen (0 initially assuming string + // can't be segmented) + lookup[n] = 0; + + for (int i = 1; i <= n; i++) + { + // consider all prefixes of current string + string prefix = str.substr(0, i); + + // if prefix is found in dictionary, then recur for suffix + if (find(dict.begin(), dict.end(), prefix) != dict.end() && + wordBreak(dict, str.substr(i), lookup)) + { + // return true if the string can be segmented + return lookup[n] = 1; + } + } + } + + // return solution to current sub-problem + return lookup[n]; +} + +// Word Break Problem +int main() +{ + // vector of strings to represent dictionary + // we can also use trie or std::set to store dictionary + vector dict = { "this", "th", "is", "famous", "Word", "break", + "b", "r", "e", "a", "k", "br", "bre", "brea", "ak", "problem" + }; + + // input string + string str = "Wordbreakproblem"; + + // look-up array to store solutions to sub-problems + // lookup[i] stores if substring str[n-i..n) can be segmented or not + vector lookup(str.length() + 1, -1); + + if (wordBreak(dict, str, lookup)) + cout << "String can be segmented"; + else + cout << "String can't be segmented"; + + return 0; +} \ No newline at end of file From 90e65b411df6bbda1057f3abda7dc4fd732c8364 Mon Sep 17 00:00:00 2001 From: Sagar Barapatre Date: Tue, 19 Jan 2021 22:30:25 +0530 Subject: [PATCH 2/2] Added Tree Folder --- Data Structures/Tree/LCA.cpp | 69 ++++++++ Data Structures/Tree/README.md | 29 ++++ Data Structures/Tree/bottom_view.cpp | 73 +++++++++ ...check_if_given_tree_is_height_balanced.cpp | 57 +++++++ ..._given_tree_is_subtree_of_another_tree.cpp | 76 +++++++++ ...check_if_given_tree_is_sum_tree_or_not.cpp | 62 ++++++++ .../Tree/check_if_two_trees_are_identical.cpp | 54 +++++++ .../check_whether_given_tree_is_complete.cpp | 68 ++++++++ .../convert_binary_tree_to_its_mirror.cpp | 63 ++++++++ .../convert_binary_tree_to_its_sum_tree.cpp | 57 +++++++ Data Structures/Tree/diagonal_sum.cpp | 69 ++++++++ Data Structures/Tree/diagonal_traversal.cpp | 65 ++++++++ Data Structures/Tree/diameter_of_tree.cpp | 56 +++++++ .../Tree/dist_between_two_nodes.cpp | 9 ++ Data Structures/Tree/height_of_tree.cpp | 40 +++++ Data Structures/Tree/left_view_of_BT.cpp | 150 ++++++++++++++++++ .../Tree/leftmost_rightmost_node_in_tree.cpp | 62 ++++++++ .../Tree/level_order_traversal.cpp | 56 +++++++ .../Tree/maximum_sum_root_to_leaf_path.cpp | 70 ++++++++ .../Tree/maximum_width_of_binary_tree.cpp | 68 ++++++++ .../Tree/print_cousins_of_node.cpp | 93 +++++++++++ .../Tree/reverse_level_order_traversal.cpp | 62 ++++++++ Data Structures/Tree/right_view_of_BT.cpp | 68 ++++++++ Data Structures/Tree/top_view.cpp | 70 ++++++++ Data Structures/Tree/tree_implementation.cpp | 29 ++++ Data Structures/Tree/tree_traversal.cpp | 88 ++++++++++ Data Structures/Tree/vertical_sum.cpp | 67 ++++++++ Data Structures/Tree/vertical_traversal.cpp | 61 +++++++ 28 files changed, 1791 insertions(+) create mode 100644 Data Structures/Tree/LCA.cpp create mode 100644 Data Structures/Tree/README.md create mode 100644 Data Structures/Tree/bottom_view.cpp create mode 100644 Data Structures/Tree/check_if_given_tree_is_height_balanced.cpp create mode 100644 Data Structures/Tree/check_if_given_tree_is_subtree_of_another_tree.cpp create mode 100644 Data Structures/Tree/check_if_given_tree_is_sum_tree_or_not.cpp create mode 100644 Data Structures/Tree/check_if_two_trees_are_identical.cpp create mode 100644 Data Structures/Tree/check_whether_given_tree_is_complete.cpp create mode 100644 Data Structures/Tree/convert_binary_tree_to_its_mirror.cpp create mode 100644 Data Structures/Tree/convert_binary_tree_to_its_sum_tree.cpp create mode 100644 Data Structures/Tree/diagonal_sum.cpp create mode 100644 Data Structures/Tree/diagonal_traversal.cpp create mode 100644 Data Structures/Tree/diameter_of_tree.cpp create mode 100644 Data Structures/Tree/dist_between_two_nodes.cpp create mode 100644 Data Structures/Tree/height_of_tree.cpp create mode 100644 Data Structures/Tree/left_view_of_BT.cpp create mode 100644 Data Structures/Tree/leftmost_rightmost_node_in_tree.cpp create mode 100644 Data Structures/Tree/level_order_traversal.cpp create mode 100644 Data Structures/Tree/maximum_sum_root_to_leaf_path.cpp create mode 100644 Data Structures/Tree/maximum_width_of_binary_tree.cpp create mode 100644 Data Structures/Tree/print_cousins_of_node.cpp create mode 100644 Data Structures/Tree/reverse_level_order_traversal.cpp create mode 100644 Data Structures/Tree/right_view_of_BT.cpp create mode 100644 Data Structures/Tree/top_view.cpp create mode 100644 Data Structures/Tree/tree_implementation.cpp create mode 100644 Data Structures/Tree/tree_traversal.cpp create mode 100644 Data Structures/Tree/vertical_sum.cpp create mode 100644 Data Structures/Tree/vertical_traversal.cpp diff --git a/Data Structures/Tree/LCA.cpp b/Data Structures/Tree/LCA.cpp new file mode 100644 index 0000000..450a805 --- /dev/null +++ b/Data Structures/Tree/LCA.cpp @@ -0,0 +1,69 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +bool findPath(Node* root, vector &path, int k) +{ + if (root == NULL) + return false; + + path.push_back(root->data); + + if (root->data == k) + return true; + + if ((root->left && findPath(root->left, path, k)) || ((root->right) && findPath(root->right, path, k))) + return true; + + path.pop_back(); + return false; + +} + + +int LCA(Node* root, int n1, int n2) +{ + + vector path1; + vector path2; + if (!findPath(root, path1, n1) || !findPath(root, path2, n2)) + return -1; + + int i; + for (i = 0 ; i < path1.size() && i < path2.size() ; i++) + { + if (path1[i] != path2[i]) + break; + } + return path1[i - 1]; +} + +int main() +{ + Node * root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->right->left = new Node(6); + root->right->right = new Node(7); + + cout << LCA(root, 4, 5) << endl; + + return 0; +} + diff --git a/Data Structures/Tree/README.md b/Data Structures/Tree/README.md new file mode 100644 index 0000000..5215bfd --- /dev/null +++ b/Data Structures/Tree/README.md @@ -0,0 +1,29 @@ +### Points to Remember + +- A nice way to understand a tree is with a recursive explanation. +- Tree and Graph questions may have ambiguous details in interviews, you may end up making incorrect assumptions. Seek clarification from your interviewer when required. + +##### Terms +- _Descendant_: All the nodes that can be reached by following a path of child nodes from a particular node are descendants of that node. +- _Ancestor_: An ancestor of a node is any other node that can reach it by following a series of children. +- _Height_: The number of edges in a path from the farthest leaf node to the root node. +- _Diameter_: The number of nodes on the longest path between two leaves in the tree. + +##### Types of Binary Trees +- A _Balanced Binary Tree_ does not mean the left and right subtrees are exactly the same size (i.e. not a _Perfectly Balanced Tree_). It means it is balanced to ensure **O(log n)** time for _insert_ and _find_. +- In a _Height Balanced Binary Tree_, the difference between the heights of the left and right subtrees in not more than one. +- Two common types of balanced trees are _AVL Trees_ and _Red Black Trees_. +- _Complete Binary Tree_: A binary tree in which every level of the tree is fully filled, except possibly the last level, which is filled left to right. +- _Full Binary Tree_: Every node has either zero or two children. No nodes have only one child. +- _Perfect Binary Tree_: A tree which is both _full_ and _complete_. All leaf nodes will be at the same level. + +##### Binary Tree Traversal +- In-Order Traversal + - Left - Node - Right + - Inorder traversal visits nodes in ascending order in a _Binary Search Tree_. + - Pre-Order Traversal + - Node - Left - Right + - Root is always the first node to be visited. + - Post-Order Traversal + - Left - Right - Node + - Root is always the last node to be visited. diff --git a/Data Structures/Tree/bottom_view.cpp b/Data Structures/Tree/bottom_view.cpp new file mode 100644 index 0000000..944e61f --- /dev/null +++ b/Data Structures/Tree/bottom_view.cpp @@ -0,0 +1,73 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + int hd; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + hd = INT_MAX; + left = right = NULL; + } +}; + +void bottomView(Node* root) +{ + if (root == nullptr) + return ; + int hd = 0; + map mp; + queue q; + root->hd = hd; + q.push(root); + + while (!q.empty()) + { + Node* temp = q.front(); + q.pop(); + + hd = temp->hd; + mp[hd] = temp->data; + + + if (temp->left) + { + temp->left->hd = hd - 1; + q.push(temp->left); + } + + if (temp->right) + { + temp->right->hd = hd + 1; + q.push(temp->right); + } + + + } + for (auto i = mp.begin() ; i != mp.end() ; i++) + { + cout << i->second << " "; + } + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + bottomView(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/check_if_given_tree_is_height_balanced.cpp b/Data Structures/Tree/check_if_given_tree_is_height_balanced.cpp new file mode 100644 index 0000000..d2e9a12 --- /dev/null +++ b/Data Structures/Tree/check_if_given_tree_is_height_balanced.cpp @@ -0,0 +1,57 @@ + +#include +using namespace std; + +/* A binary tree node has data, +pointer to left child and +a pointer to right child */ +class node { +public: + int data; + node* left; + node* right; +}; + +bool isBalanced(Node* root) +{ + if (root == nullptr) + return true; + int lh, rh; + + lh = height(root->left); + rh = height(root->right); + + if (abs(lh - rh) <= 1 && isBalanced(root->left) && isBalanced(root->rght)) + return true; + + return false; +} + +int height(node* node) +{ + /* base case tree is empty */ + if (node == NULL) + return 0; + + /* If tree is not empty then + height = 1 + max of left + height and right heights */ + return 1 + max(height(node->left), + height(node->right)); +} + +int main() +{ + node* root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->left->left->left = new Node(8); + + if (isBalanced(root)) + cout << "Tree is balanced"; + else + cout << "Tree is not balanced"; + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/check_if_given_tree_is_subtree_of_another_tree.cpp b/Data Structures/Tree/check_if_given_tree_is_subtree_of_another_tree.cpp new file mode 100644 index 0000000..e36ad64 --- /dev/null +++ b/Data Structures/Tree/check_if_given_tree_is_subtree_of_another_tree.cpp @@ -0,0 +1,76 @@ +#include +using namespace std; +string s; +string s2; + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void inorder(Node* root) +{ + + s.push_back(root->data); + inorder(root->left); + inorder(root->right); +} + +void Inorder(Node* root) +{ + + s2.push_back(root->data); + inorder(root->left); + inorder(root->right); +} + +int main() +{ + Node* root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->right->left = new Node(6); + root->right->right = new Node(7); + + Node* temp = new Node(3); + temp->left = new Node(6); + temp->right = new Node(7); + + inorder(temp); + Inorder(root); + int l1 = s.length(); + + int l2 = s2.length(); + bool flag = false; + for (int i = 0 ; i < s2.length() ; i++) + { + if ((i + l1) < s2.length()) + { + if (s == s2.substr(i, i + l1)) + { + flag = true; + break; + } + } + + + } + if (flag == true) + cout << "YES\n"; + else + cout << "NO\n"; + + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/check_if_given_tree_is_sum_tree_or_not.cpp b/Data Structures/Tree/check_if_given_tree_is_sum_tree_or_not.cpp new file mode 100644 index 0000000..3b28a37 --- /dev/null +++ b/Data Structures/Tree/check_if_given_tree_is_sum_tree_or_not.cpp @@ -0,0 +1,62 @@ +#include +using namespace std; + +// Data structure to store a Binary Tree node +struct Node +{ + int key; + Node *left, *right; + + Node(int key) + { + this->key = key; + this->left = this->right = nullptr; + } +}; + +// Recursive function to check if given binary tree is a sum tree or not +int isSumTree(Node *root) +{ + // base case: empty tree + if (root == nullptr) + return 0; + + // special case: leaf node + if (root->left == nullptr && root->right == nullptr) + return root->key; + + // if root's value is equal to sum of all elements present in its + // left and right subtree + if (root->key == isSumTree(root->left) + isSumTree(root->right)) + return 2 * root->key; + + return INT_MIN; +} + +int main() +{ + Node* root = nullptr; + /* Construct below tree + 44 + / \ + / \ + 9 13 + / \ / \ + 4 5 6 7 + */ + + root = new Node(44); + root->left = new Node(9); + root->right = new Node(13); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->right->left = new Node(6); + root->right->right = new Node(7); + + if (isSumTree(root) != INT_MIN) + cout << "Yes"; + else + cout << "No"; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/check_if_two_trees_are_identical.cpp b/Data Structures/Tree/check_if_two_trees_are_identical.cpp new file mode 100644 index 0000000..9351d30 --- /dev/null +++ b/Data Structures/Tree/check_if_two_trees_are_identical.cpp @@ -0,0 +1,54 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +bool isIdentical(Node* x, Node* y) +{ + if (x == nullptr && y == nullptr) + return true; + if (x == nullptr) + return false; + if (y == nullptr) + return false; + + return (x && y) && (x->data == y->data) && isIdentical(x->left, y->left) && isIdentical(x->right, y->right); +} + +int main() +{ + Node* root1 = new Node(1); + + root1->left = new Node(2); + root1->left->left = new Node(4); + root1->right = new Node(3); + root1->left->right = new Node(5); + + Node* root2 = new Node(1); + + root2->left = new Node(2); + root2->left->left = new Node(4); + root2->right = new Node(3); + root2->left->right = new Node(5); + + if (isIdentical(root1, root2)) + cout << "YES\n"; + else + cout << "NO\n"; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/check_whether_given_tree_is_complete.cpp b/Data Structures/Tree/check_whether_given_tree_is_complete.cpp new file mode 100644 index 0000000..a9667d3 --- /dev/null +++ b/Data Structures/Tree/check_whether_given_tree_is_complete.cpp @@ -0,0 +1,68 @@ +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +bool isComplete(Node* root) +{ + queue q; + q.push(root); + + bool flag = false; + + while (q.empty()) + { + Node* temp = q.front(); + q.pop(); + + if (temp->left) + { + if (flag == true) + return false; + else + flag = true; + } + if (temp->right) + { + if (flag == true) + return false; + else + flag = true; + } + + } + return true; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + + if (isComplete(root) == true) + cout << "YES\n"; + else + cout << "NO\n"; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/convert_binary_tree_to_its_mirror.cpp b/Data Structures/Tree/convert_binary_tree_to_its_mirror.cpp new file mode 100644 index 0000000..afaed5c --- /dev/null +++ b/Data Structures/Tree/convert_binary_tree_to_its_mirror.cpp @@ -0,0 +1,63 @@ +#include +using namespace std; + +// Data structure to store a Binary Tree node +struct Node +{ + int data; + Node *left, *right; + + Node(int data) + { + this->data = data; + this->left = this->right = nullptr; + } +}; + +// Function to perform preorder traversal of the binary tree +void preorder(Node* root) +{ + if (root == nullptr) + return; + + cout << root->data << " "; + preorder(root->left); + preorder(root->right); +} + + +void convertToMirror(Node* root) +{ + if (root == nullptr) + return ; + convertToMirror(root->left); + convertToMirror(root->right); + + swap(root->left, root->right); +} + + +int main() +{ + Node* root = nullptr; + /* Construct below tree + 1 + / \ + / \ + 2 3 + / \ / \ + 4 5 6 7 */ + + root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->right->left = new Node(6); + root->right->right = new Node(7); + + convertToMirror(root); + preorder(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/convert_binary_tree_to_its_sum_tree.cpp b/Data Structures/Tree/convert_binary_tree_to_its_sum_tree.cpp new file mode 100644 index 0000000..bed329c --- /dev/null +++ b/Data Structures/Tree/convert_binary_tree_to_its_sum_tree.cpp @@ -0,0 +1,57 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void preOrder(Node* root) +{ + if (root == nullptr) + return ; + cout << root->data << " "; + preOrder(root->left); + preOrder(root->right); +} + +int sumTree(Node* root) +{ + if (root == NULL) + return 0; + + int left = sumTree(root->left); + int right = sumTree(root->right); + + int old = root->data; + + root->data = left + right; + + return root->data + old; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + sumTree(root); + preOrder(root); + cout << endl; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/diagonal_sum.cpp b/Data Structures/Tree/diagonal_sum.cpp new file mode 100644 index 0000000..6d1ca06 --- /dev/null +++ b/Data Structures/Tree/diagonal_sum.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +void getLevel(Node* root, int hd, map > &mp) +{ + if (root == nullptr) + return ; + mp[hd].push_back(root->data); + getLevel(root->left, hd + 1, mp); + getLevel(root->right, hd , mp); +} + +void printLevel(Node* root) +{ + int ans = 0; + map > mp; + map >::iterator itr; + + int hd = 0; + getLevel(root, hd, mp); + + for (auto itr = mp.begin() ; itr != mp.end() ; itr++) + { + ans = 0; + for (int i = 0 ; i < itr->second.size() ; i++) + { + ans += itr->second[i]; + } + cout << itr->first << " : " << ans << endl; + } + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(9); + root->left->right = new Node(6); + root->right->left = new Node(4); + root->right->right = new Node(5); + root->right->left->right = new Node(7); + root->right->left->left = new Node(12); + root->left->right->left = new Node(11); + root->left->left->right = new Node(10); + + printLevel(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/diagonal_traversal.cpp b/Data Structures/Tree/diagonal_traversal.cpp new file mode 100644 index 0000000..4cb6cff --- /dev/null +++ b/Data Structures/Tree/diagonal_traversal.cpp @@ -0,0 +1,65 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +void getLevel(Node* root, int hd, map > &mp) +{ + if (root == nullptr) + return ; + mp[hd].push_back(root->data); + getLevel(root->left, hd + 1, mp); + getLevel(root->right, hd, mp); +} + +void printLevel(Node* root) +{ + map > mp; + map >::iterator itr; + + int hd = 0; + getLevel(root, hd, mp); + + for (auto itr = mp.begin() ; itr != mp.end() ; itr++) + { + for (int i = 0 ; i < itr->second.size() ; i++) + { + cout << itr->second[i] << " "; + } + cout << endl; + } + +} + +int main() +{ + Node* root = new Node(8); + root->left = new Node(3); + root->right = new Node(10); + root->left->left = new Node(1); + root->left->right = new Node(6); + root->right->right = new Node(14); + root->right->right->left = new Node(13); + root->left->right->left = new Node(4); + root->left->right->right = new Node(7); + + printLevel(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/diameter_of_tree.cpp b/Data Structures/Tree/diameter_of_tree.cpp new file mode 100644 index 0000000..8c5bd94 --- /dev/null +++ b/Data Structures/Tree/diameter_of_tree.cpp @@ -0,0 +1,56 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +int height(Node* root, int &ans) +{ + if (root == nullptr) + return 0; + + int left = height(root->left, ans); + int right = height(root->right, ans); + + ans = max(ans, 1 + left + right); + + return 1 + max(left, right); +} + +int diameter(Node* root) +{ + int ans = INT_MIN; + + if (root == nullptr) + return 0; + + int height_tree = height(root, ans); + return ans; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + cout << diameter(root) << endl; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/dist_between_two_nodes.cpp b/Data Structures/Tree/dist_between_two_nodes.cpp new file mode 100644 index 0000000..282cd6e --- /dev/null +++ b/Data Structures/Tree/dist_between_two_nodes.cpp @@ -0,0 +1,9 @@ +//Idea is simple +/* +the distance between two nodes is equal to +d = dist(root to node1) + dist(root to node2) - 2 * LCA(node1, node2); + + + + + */ \ No newline at end of file diff --git a/Data Structures/Tree/height_of_tree.cpp b/Data Structures/Tree/height_of_tree.cpp new file mode 100644 index 0000000..1643e54 --- /dev/null +++ b/Data Structures/Tree/height_of_tree.cpp @@ -0,0 +1,40 @@ +// C++ program to find height of tree +#include +using namespace std; + +struct Node +{ + int data; + struct Node* left; + struct Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +int height(Node* root) +{ + if (root == NULL) + return 0; + + return 1 + max(height(root->right), height(root->left)); +} + + +// Driver code +int main() +{ + struct Node *root = new Node(1); + + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + + cout << "Height of tree is " << height(root) << endl; + return 0; +} + diff --git a/Data Structures/Tree/left_view_of_BT.cpp b/Data Structures/Tree/left_view_of_BT.cpp new file mode 100644 index 0000000..f7cb06e --- /dev/null +++ b/Data Structures/Tree/left_view_of_BT.cpp @@ -0,0 +1,150 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void leftView(Node* root) +{ + + if (root == nullptr) + return; + + queue q; + q.push(root); + // cout << root->data << " "; + Node* temp = nullptr; + + while (!q.empty()) + { + int size = q.size(); + int i = 0; + + while (i++ < size) + { + temp = q.front(); + q.pop(); + + if ( i == 1) + cout << temp->data << " "; + if (temp->right) + q.push(temp->left); + if (temp->left) + q.push(temp->right); + + /* + If we want to print the right view, + then we enqueue first temp->right, then temp->left + ***IMPORTANT*** + */ + } + } +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + leftView(root); + + return 0; +} + + + + +// #include +// #include +// using namespace std; + +// // Data structure to store a Binary Tree node +// struct Node +// { +// int key; +// Node *left, *right; + +// Node(int key) +// { +// this->key = key; +// this->left = this->right = nullptr; +// } +// }; + +// // Iterative function to print left view of given binary tree +// void leftView(Node* root) +// { +// // return if tree is empty +// if (root == nullptr) +// return; + +// // create an empty queue and enqueue root node +// list queue; +// queue.push_back(root); + +// // pointer to store current node +// Node* curr = nullptr; + +// // run till queue is not empty +// while (!queue.empty()) +// { +// // calculate number of nodes in current level +// int size = queue.size(); +// int i = 0; + +// // process every node of current level and enqueue their +// // non-empty left and right child to queue +// while (i++ < size) +// { +// curr = queue.front(); +// queue.pop_front(); + +// // if this is first node of current level, print it +// if (i == 1) +// cout << curr->key << " "; + +// if (curr->left) +// queue.push_back(curr->left); + +// if (curr->right) +// queue.push_back(curr->right); +// } +// } +// } + +// int main() +// { +// Node* root = nullptr; + +// root = new Node(1); +// root->left = new Node(2); +// root->right = new Node(3); +// root->left->right = new Node(5); +// root->left->left = new Node(4); +// //root->right->left = new Node(5); +// //root->right->right = new Node(6); +// //root->right->left->left = new Node(7); +// //root->right->left->right = new Node(8); + +// leftView(root); + +// return 0; +// } \ No newline at end of file diff --git a/Data Structures/Tree/leftmost_rightmost_node_in_tree.cpp b/Data Structures/Tree/leftmost_rightmost_node_in_tree.cpp new file mode 100644 index 0000000..b737121 --- /dev/null +++ b/Data Structures/Tree/leftmost_rightmost_node_in_tree.cpp @@ -0,0 +1,62 @@ +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void LOT(Node* root) +{ + queue q; + q.push(root); + + Node* temp = nullptr; + + + while (!q.empty()) + { + int n = q.size(); + for (int i = 0 ; i < n ; i++) + { + temp = q.front(); + q.pop(); + + if (i == 0 || i == n - 1) + cout << temp->data << " "; + + if (temp->left) + q.push(temp->left); + if (temp->right) + q.push(temp->right); + } + + } + cout << endl; +} + +int main() +{ + Node *root = new Node(15); + root->left = new Node(10); + root->right = new Node(20); + root->left->left = new Node(8); + root->left->right = new Node(12); + root->right->left = new Node(16); + root->right->right = new Node(25); + + LOT(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/level_order_traversal.cpp b/Data Structures/Tree/level_order_traversal.cpp new file mode 100644 index 0000000..ca1023d --- /dev/null +++ b/Data Structures/Tree/level_order_traversal.cpp @@ -0,0 +1,56 @@ +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void LOT(Node* root) +{ + queue q; + q.push(root); + + Node* temp = nullptr; + + + while (q.size()) + { + + temp = q.front(); + q.pop(); + + cout << temp->data << " "; + + if (temp->left) + q.push(temp->left); + if (temp->right) + q.push(temp->right); + } + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + LOT(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/maximum_sum_root_to_leaf_path.cpp b/Data Structures/Tree/maximum_sum_root_to_leaf_path.cpp new file mode 100644 index 0000000..4e8a37f --- /dev/null +++ b/Data Structures/Tree/maximum_sum_root_to_leaf_path.cpp @@ -0,0 +1,70 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +bool printPath(Node* root, int sum) +{ + if (sum == 0) + return true; + if (root == nullptr) + return false; + + bool left = printPath(root->left, sum - root->data); + bool right = printPath(root->right, sum - root->data); + + if (left || right) + cout << root->data << " "; + return left || right; + +} + +int getSum(Node* root) +{ + if (root == nullptr) + return 0; + int left = getSum(root->left); + int right = getSum(root->right); + + return (left > right ? left : right) + root->data; +} + +void final(Node* root) +{ + int ans = getSum(root); + cout << "The maximum sum is : " << ans << endl; + cout << "The maximum sum path is : "; + printPath(root, ans); +} + +int main() +{ + Node* root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(8); + root->left->right = new Node(4); + root->right->left = new Node(5); + root->right->right = new Node(6); + root->left->right->left = new Node(10); + root->right->left->left = new Node(7); + root->right->left->right = new Node(9); + root->right->right->right = new Node(5); + + final(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/maximum_width_of_binary_tree.cpp b/Data Structures/Tree/maximum_width_of_binary_tree.cpp new file mode 100644 index 0000000..35f9820 --- /dev/null +++ b/Data Structures/Tree/maximum_width_of_binary_tree.cpp @@ -0,0 +1,68 @@ +#include +#include +using namespace std; + +// Data structure to store a Binary Tree node +struct Node +{ + int key; + Node *left, *right; + + Node(int key) + { + this->key = key; + this->left = this->right = nullptr; + } +}; + +// Traverse the tree in pre-order fashion and store count of nodes +// in each level +void preorder(Node *root, int level, auto &map) +{ + // base case: empty tree + if (root == nullptr) + return; + + // increment count of nodes in current level + map[level]++; + + // recur for left and right subtree by increasing level by 1 + preorder(root->left, level + 1, map); + preorder(root->right, level + 1, map); +} + +// Recursive function to find maximum width of the tree +void maxWidth(Node *root) +{ + // create an empty map to store count of nodes in each levels + unordered_map map; + + // traverse the tree and fill map + preorder(root, 1, map); + + // stores maximum width + int res = 0; + + // iterate through the map and update maximum width + for (auto it : map) + res = max(res, it.second); + + cout << "Maximum width is " << res; +} + +int main() +{ + Node* root = nullptr; + + root = new Node(15); + root->left = new Node(10); + root->right = new Node(20); + root->left->left = new Node(8); + root->left->right = new Node(12); + root->right->left = new Node(16); + root->right->right = new Node(25); + + maxWidth(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/print_cousins_of_node.cpp b/Data Structures/Tree/print_cousins_of_node.cpp new file mode 100644 index 0000000..1362f76 --- /dev/null +++ b/Data Structures/Tree/print_cousins_of_node.cpp @@ -0,0 +1,93 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +int getLevel(Node *root, Node *node, int level) +{ + + // base cases + if (root == NULL) + return 0; + if (root == node) + return level; + + // If node is present in left subtree + int downlevel = getLevel(root->left, + node, level + 1); + if (downlevel != 0) + return downlevel; + + // If node is not present in left subtree + return getLevel(root->right, node, level + 1); +} + +/* Print nodes at a given level such that +sibling of node is not printed if it exists */ +void printGivenLevel(Node* root, Node *node, int level) +{ + // Base cases + if (root == NULL || level < 2) + return; + + // If current node is parent of a node + // with given level + if (level == 2) + { + if (root->left == node || root->right == node) + return; + if (root->left) + cout << root->left->data << " "; + if (root->right) + cout << root->right->data; + } + + // Recur for left and right subtrees + else if (level > 2) + { + printGivenLevel(root->left, node, level - 1); + printGivenLevel(root->right, node, level - 1); + } +} + +// This function prints cousins of a given node +void printCousins(Node *root, Node *node) +{ + // Get level of given node + int level = getLevel(root, node, 1); + + // Print nodes of given level. + printGivenLevel(root, node, level); +} + +int main() +{ + Node *root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->left->right->right = new Node(15); + root->right->left = new Node(6); + root->right->right = new Node(7); + root->right->left->right = new Node(8); + + printCousins(root, root->left->right); + cout << endl; + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/reverse_level_order_traversal.cpp b/Data Structures/Tree/reverse_level_order_traversal.cpp new file mode 100644 index 0000000..be70d94 --- /dev/null +++ b/Data Structures/Tree/reverse_level_order_traversal.cpp @@ -0,0 +1,62 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void RLOT(Node* root) +{ + queue q; + q.push(root); + stack s; + Node* temp = nullptr; + + while (q.size()) + { + temp = q.front(); + q.pop(); + + + s.push(temp->data); + + if (temp->left) + q.push(temp->left); + if (temp->right) + q.push(temp->right); + } + + while (!s.empty()) + { + cout << s.top() << " "; + s.pop(); + } + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + RLOT(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/right_view_of_BT.cpp b/Data Structures/Tree/right_view_of_BT.cpp new file mode 100644 index 0000000..b3a1ee5 --- /dev/null +++ b/Data Structures/Tree/right_view_of_BT.cpp @@ -0,0 +1,68 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +void leftView(Node* root) +{ + + if (root == nullptr) + return; + + queue q; + q.push(root); + // cout << root->data << " "; + Node* temp = nullptr; + + while (!q.empty()) + { + int size = q.size(); + int i = 0; + + while (i++ < size) + { + temp = q.front(); + q.pop(); + + if ( i == 1) + cout << temp->data << " "; + + if (temp->left) + q.push(temp->right); + + + if (temp->right) + q.push(temp->left); + + } + } +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + leftView(root); + + return 0; +} diff --git a/Data Structures/Tree/top_view.cpp b/Data Structures/Tree/top_view.cpp new file mode 100644 index 0000000..e77f86a --- /dev/null +++ b/Data Structures/Tree/top_view.cpp @@ -0,0 +1,70 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + int hd; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + hd = INT_MAX; + left = right = NULL; + } +}; + +void topView(Node* root) +{ + if (root == nullptr) + return ; + int hd = 0; + map mp; + queue q; + q.push(root); + root->hd = hd; + + while (!q.empty()) + { + hd = root->hd; + + if (mp.count(hd) == 0) + mp[hd] = root->data; + + if (root->left) + { + root->left->hd = hd - 1; + q.push(root->left); + } + if (root->right) + { + root->right->hd = hd + 1; + q.push(root->right); + } + + q.pop(); + root = q.front(); + } + for (auto i = mp.begin() ; i != mp.end() ; i++) + cout << i->second << " "; + + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + topView(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/tree_implementation.cpp b/Data Structures/Tree/tree_implementation.cpp new file mode 100644 index 0000000..21fcf0b --- /dev/null +++ b/Data Structures/Tree/tree_implementation.cpp @@ -0,0 +1,29 @@ +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/tree_traversal.cpp b/Data Structures/Tree/tree_traversal.cpp new file mode 100644 index 0000000..c4be0a1 --- /dev/null +++ b/Data Structures/Tree/tree_traversal.cpp @@ -0,0 +1,88 @@ +// C program for different tree traversals +#include +using namespace std; + +/* A binary tree node has data, pointer to left child +and a pointer to right child */ +class Node +{ +public : + int data; + Node* left , *right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + +/* Given a binary tree, print its nodes according to the +"bottom-up" postorder traversal. */ +void printPostorder(Node* node) +{ + if (node == NULL) + return; + + // first recur on left subtree + printPostorder(node->left); + + // then recur on right subtree + printPostorder(node->right); + + // now deal with the node + cout << node->data << " "; +} + +/* Given a binary tree, print its nodes in inorder*/ +void printInorder(Node* node) +{ + if (node == NULL) + return; + + /* first recur on left child */ + printInorder(node->left); + + /* then print the data of node */ + cout << node->data << " "; + + /* now recur on right child */ + printInorder(node->right); +} + +/* Given a binary tree, print its nodes in preorder*/ +void printPreorder(Node* node) +{ + if (node == NULL) + return; + + /* first print data of node */ + cout << node->data << " "; + + /* then recur on left sutree */ + printPreorder(node->left); + + /* now recur on right subtree */ + printPreorder(node->right); +} + +/* Driver program to test above functions*/ +int main() +{ + Node *root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->right = new Node(4); + root->right->left = new Node(5); + + // cout << "\nPreorder traversal of binary tree is \n"; + // printPreorder(root); + + // cout << "\nPostorder traversal of binary tree is \n"; + // printPostorder(root); + + cout << "\nInorder traversal of binary tree is \n"; + printInorder(root); + + return 0; +} diff --git a/Data Structures/Tree/vertical_sum.cpp b/Data Structures/Tree/vertical_sum.cpp new file mode 100644 index 0000000..b1d917c --- /dev/null +++ b/Data Structures/Tree/vertical_sum.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +void getLevel(Node* root, int hd, map > &mp) +{ + if (root == nullptr) + return ; + mp[hd].push_back(root->data); + getLevel(root->left, hd - 1, mp); + getLevel(root->right, hd + 1, mp); +} + +void printLevel(Node* root) +{ + int ans = 0; + map > mp; + map >::iterator itr; + + int hd = 0; + getLevel(root, hd, mp); + + for (auto itr = mp.begin() ; itr != mp.end() ; itr++) + { + ans = 0; + for (int i = 0 ; i < itr->second.size() ; i++) + { + ans += itr->second[i]; + } + cout << itr->first << " : " << ans << endl; + } + cout << endl; +} + +int main() +{ + Node *root = new Node(1); + root->left = new Node(2); + root->right = new Node(3); + root->left->left = new Node(4); + root->left->right = new Node(5); + root->right->left = new Node(6); + root->right->right = new Node(7); + root->right->left->right = new Node(8); + root->right->right->right = new Node(9); + + printLevel(root); + + return 0; +} \ No newline at end of file diff --git a/Data Structures/Tree/vertical_traversal.cpp b/Data Structures/Tree/vertical_traversal.cpp new file mode 100644 index 0000000..68010e3 --- /dev/null +++ b/Data Structures/Tree/vertical_traversal.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +using namespace std; + + +class Node +{ +public : + int data; + Node* left; + Node* right; + + Node(int data) + { + this->data = data; + left = right = NULL; + } +}; + + +void getLevel(Node* root, int hd, map > &mp) +{ + if (root == nullptr) + return ; + mp[hd].push_back(root->data); + getLevel(root->left, hd - 1, mp); + getLevel(root->right, hd + 1, mp); +} + +void printLevel(Node* root) +{ + map > mp; + map >::iterator itr; + + int hd = 0; + getLevel(root, hd, mp); + + for (auto itr = mp.begin() ; itr != mp.end() ; itr++) + { + for (int i = 0 ; i < itr->second.size() ; i++) + { + cout << itr->second[i] << " "; + } + } + cout << endl; +} + +int main() +{ + Node* root = new Node(1); + + root->left = new Node(2); + root->left->left = new Node(4); + root->right = new Node(3); + root->left->right = new Node(5); + + printLevel(root); + + return 0; +} \ No newline at end of file