From 23d7e179faacba3c6d59bfe10b5c8daae2af1116 Mon Sep 17 00:00:00 2001 From: ayifuture0920 <50540669+ayifuture0920@users.noreply.github.com> Date: Fri, 29 Apr 2022 17:50:25 +0800 Subject: [PATCH] Add files via upload --- algorithm/acwing/code/ACWing.iml | 11 +++ .../ACWing/a_BinaryAlgorithm/T789.class | Bin 0 -> 2324 bytes .../ACWing/a_BinaryAlgorithm/T790.class | Bin 0 -> 1386 bytes .../ACWing/a_BinaryAlgorithm/Template.class | Bin 0 -> 947 bytes .../ACWing/b_MergeAlgorithm/T788.class | Bin 0 -> 1848 bytes .../production/ACWing/c_PrefixSum/T795.class | Bin 0 -> 996 bytes .../production/ACWing/c_PrefixSum/T796.class | Bin 0 -> 1199 bytes .../ACWing/d_DifferenceMethod/T797.class | Bin 0 -> 1583 bytes .../code/src/a_BinaryAlgorithm/T789.java | 50 ++++++++++ .../code/src/a_BinaryAlgorithm/T790.java | 32 ++++++ .../code/src/a_BinaryAlgorithm/Template.java | 43 +++++++++ .../code/src/b_MergeAlgorithm/T788.java | 49 ++++++++++ .../acwing/code/src/c_PrefixSum/T795.java | 27 ++++++ .../acwing/code/src/c_PrefixSum/T796.java | 31 ++++++ .../code/src/d_DifferenceMethod/T797.java | 29 ++++++ .../1\345\211\215\347\274\200\345\222\214.md" | 91 ++++++++++++++++++ .../notes/2\345\267\256\345\210\206.md" | 80 +++++++++++++++ algorithm/leetcode/Java LeetCode.iml | 11 +++ .../Java LeetCode/practice/Hanoi.class | Bin 0 -> 1505 bytes .../Java LeetCode/practice/N_1.class | Bin 0 -> 999 bytes .../Java LeetCode/practice/N_14.class | Bin 0 -> 818 bytes .../Java LeetCode/practice/N_15.class | Bin 0 -> 1437 bytes .../Java LeetCode/practice/N_18.class | Bin 0 -> 1733 bytes .../Java LeetCode/practice/N_20.class | Bin 0 -> 1163 bytes .../Java LeetCode/practice/N_3.class | Bin 0 -> 1127 bytes .../Java LeetCode/practice/N_33.class | Bin 0 -> 1694 bytes .../Java LeetCode/practice/N_35.class | Bin 0 -> 568 bytes .../Java LeetCode/practice/easy/N_1122.class | Bin 0 -> 2466 bytes .../Java LeetCode/practice/easy/N_819.class | Bin 0 -> 2315 bytes algorithm/leetcode/src/practice/N_1.java | 17 ++++ algorithm/leetcode/src/practice/N_14.java | 17 ++++ algorithm/leetcode/src/practice/N_15.java | 36 +++++++ algorithm/leetcode/src/practice/N_18.java | 44 +++++++++ algorithm/leetcode/src/practice/N_20.java | 25 +++++ algorithm/leetcode/src/practice/N_3.java | 25 +++++ algorithm/leetcode/src/practice/N_33.java | 50 ++++++++++ algorithm/leetcode/src/practice/N_35.java | 15 +++ .../leetcode/src/practice/easy/N_1122.java | 86 +++++++++++++++++ .../leetcode/src/practice/easy/N_819.java | 41 ++++++++ 39 files changed, 810 insertions(+) create mode 100644 algorithm/acwing/code/ACWing.iml create mode 100644 algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T789.class create mode 100644 algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T790.class create mode 100644 algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/Template.class create mode 100644 algorithm/acwing/code/out/production/ACWing/b_MergeAlgorithm/T788.class create mode 100644 algorithm/acwing/code/out/production/ACWing/c_PrefixSum/T795.class create mode 100644 algorithm/acwing/code/out/production/ACWing/c_PrefixSum/T796.class create mode 100644 algorithm/acwing/code/out/production/ACWing/d_DifferenceMethod/T797.class create mode 100644 algorithm/acwing/code/src/a_BinaryAlgorithm/T789.java create mode 100644 algorithm/acwing/code/src/a_BinaryAlgorithm/T790.java create mode 100644 algorithm/acwing/code/src/a_BinaryAlgorithm/Template.java create mode 100644 algorithm/acwing/code/src/b_MergeAlgorithm/T788.java create mode 100644 algorithm/acwing/code/src/c_PrefixSum/T795.java create mode 100644 algorithm/acwing/code/src/c_PrefixSum/T796.java create mode 100644 algorithm/acwing/code/src/d_DifferenceMethod/T797.java create mode 100644 "algorithm/acwing/notes/1\345\211\215\347\274\200\345\222\214.md" create mode 100644 "algorithm/acwing/notes/2\345\267\256\345\210\206.md" create mode 100644 algorithm/leetcode/Java LeetCode.iml create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/Hanoi.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_1.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_14.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_15.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_18.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_20.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_3.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_33.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/N_35.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/easy/N_1122.class create mode 100644 algorithm/leetcode/out/production/Java LeetCode/practice/easy/N_819.class create mode 100644 algorithm/leetcode/src/practice/N_1.java create mode 100644 algorithm/leetcode/src/practice/N_14.java create mode 100644 algorithm/leetcode/src/practice/N_15.java create mode 100644 algorithm/leetcode/src/practice/N_18.java create mode 100644 algorithm/leetcode/src/practice/N_20.java create mode 100644 algorithm/leetcode/src/practice/N_3.java create mode 100644 algorithm/leetcode/src/practice/N_33.java create mode 100644 algorithm/leetcode/src/practice/N_35.java create mode 100644 algorithm/leetcode/src/practice/easy/N_1122.java create mode 100644 algorithm/leetcode/src/practice/easy/N_819.java diff --git a/algorithm/acwing/code/ACWing.iml b/algorithm/acwing/code/ACWing.iml new file mode 100644 index 0000000..9465dd8 --- /dev/null +++ b/algorithm/acwing/code/ACWing.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T789.class b/algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T789.class new file mode 100644 index 0000000000000000000000000000000000000000..a3eae4786e0e35ca31d624eb0885963f67dda1d0 GIT binary patch literal 2324 zcmaJ?ZBr9h6n<{9VUu-z0TKj3r4&n`LaJ?j15$-bje=T(sHMIv$qFl*-MG84()Z5v zNAz2#_5+`bGvH{aKcIi2(~s>>aBS&wcca81(+_+1+;h%7=Q+dNTza-Ee z*=vDi=ZYo6aYB=D1Vn+)eSwxS%dvvIKs-A*C!kEaWm91HwB?u=Yn27ln>7|}YTBmV zl3~voo+bBnr4lSzzC>Z%p0FIlTRCGdx}Fs*RdTb(Pn;wQrD9mj){&i$kl2Q^m@5XJ z$rv6Iu78Vj$XO!L${7QFc_*=#e$9!$|_79cd@AB7>=u0(qZAAKw|hv@9+^7 z%Q|dS1olk0Zr}%=QJpb^CAaMFZh@18tD}nh(udeOnm1RV>!qRKRBHk0G>uBscpW|h ziMS@02Li33YvTYgZu52#ROlS`=+eSHvlOr+TdG&=3aF0xFeo^*b8Og_BoUP5%m}2j zgWFsETIi_#q{Oe<7DEhVw;vd6ItWoQAwDKI7fso~s^R%&h$Yi35YaW1Rb24{lk~^k z8Z&32#JoP2IgxcDIki#Iud7*fRXW)m=cb9~G<=4KoKw*&u(x6?o0G0nGJ;cN|c-@^Vw^ zk{6%vl)U!gn>Ro75cKYYz?5F-R{S z78=tfsJpd>*gE2mp}Z6lYfygGX4cTM4z(@0j?~5YF(pI0@(Ag}8D%)59DM@q()Ws3 z-Tb?5OFTj*iZFJ#`w4c0#=j)0c!=sKu>gCBp_PA^c9xu`KEon9aEkBK)LdZUS4hD% z$~Q@YtRT;N2B;q*0Sc`<@HQoZN%}=P)_}tprf(;IbR&!?c{qi4sEgwW^#`DAGDt$j zQK)#AFVglLoiBK8o-_7)^ide|eWK&{lagfU1mj4CzKoBvbfui{+5ZT=J^Sw@>|@GM zMj7e;38{>dUqv#bD0jwJH~$>!8R`BJyVjt$?OeyMRZLLqd5YZtw~cZ77)RNP^s|gK z9z`nWS2zEV=hm@ji@z!I23DTrPhcm9Ak8u8BhCTVIz*<%D4k<}&$Gjqskus?Bri5u zxKCCB^6~}Qc*$v+Jvb3^dh3m9{bI}_ dv(h*#laoD8MA9ON=WABd#VWx}0w43a@*h6Y2fP3P literal 0 HcmV?d00001 diff --git a/algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T790.class b/algorithm/acwing/code/out/production/ACWing/a_BinaryAlgorithm/T790.class new file mode 100644 index 0000000000000000000000000000000000000000..77bb716a94342fcdf09aced7be4dad69bd750858 GIT binary patch literal 1386 zcmZvbU31$+6o%imWUVa}JKqQhAEh)=3dAWN32sX0M^a+yG;Q3;Oow4QYgcvD+EPZ5 z3;7QWw`GQb+g#I&HUk4cfLs0nKZ9W~?@DIkbRyZ(?%8wRbI!A?KmPsYcL2-Swo$@+ z67LtWfQpSA7WLzTjd6Tn<3oI8t*#$@_t)aL7p=>T(3f`oxPT>zWgDNMYQw`t8*^BZ zxFld*3c?^+6)?Q{9Rc%Nbl(>!*Mrc%+3Pm__>O9JXc@0ZE!EjkaiHe|qnYdm`vPuV z-MbouDn7W~<@6maB^^)a$As6qxqDtUpwbRi&fCcBPTTLD*hN^QpK^g^5#^ z1q36-nn0n|Yx>(!lu*xG(_x~+f6Su0!F_?eYVO~o??@w2tw)<`FD*~vQ;AiH&jjp7 z)QemG^+0!0)TJ%xY8*^pQeZ5ttd|6xN~5L1(2pf9JGg?Y+TogmHLN>$3uh#*JNO(M z4r=&9eI;8PiH>ej-&-awcBu6OE!W@?B2H_2MmOShY+f#6HWt!=7g zm%K?j+XSu}QI9)voN1_ola>81Dj%y(&)*`mDQ@G?fyf*fWIc%DuA*vnQ0MS@89pNe z0K+1KQzanxG|G;qaEi+O4$km%DWxBW0fNOOpHrMy_!fNU&p(IwnS&gr`Lt4F5ifJ> zWDaog3TH*Uiq~k-!CNqR0~5a@clRlb=P;ikzcF_N>sYFky1c~f4r>@mC8wE&VVJ?| ze3y{N8+enVwmx#1xcG{xY_5j0N03#^waVZB2*b zZX-po#9DzdqR>@OV3f?JdAsajhA8F;;sQ~ub5>&?b@tF@7aG|HB>gSC&3TTo2F`M1 z(%;2992In5Y0sc#XW%!3?SY?#U7Vwzg;{zwAp1;gY1A5KpS(zbko&xb02oe5voW#W9(9_k`Reya|t@-}v>o)-R;lvTeN*t?Liz9+N z7S=6n2*iqB+Y3tqrjy$fh&<`kmB3WRYpdtIR!s%FvgXq>Tj{vc-;;r-&qHSo4Q?xlcu zqvgl01m^#(dD6Y8Ywm7Sce3g=+A{0~#LE=7AB;+t_cVGEF<2I|No-;( zi4<-K*#94k!1VQo1!k^X<#wnVibU42^m}UOfYWfwxseu!5e2OAIiq}IaOZo%;&+0l zJa@r8diM*&XBq}3`Hc;nCgQY{=K)C20&hvpD4kpyCL57YJeebziIGeLQ<&!c4A;4q z_RR8hlgq#@=FMTAT3YiRJtp^cJN*$Wc6vYZ_F?7}#wpAXn8+0SuriVTLjUZieO1&Z zFennGOacqAv4~|Xv1@w(vP#JW%Pr7vXmQ>xa@UrQ6-d)ga5lfOB!0ovQ^;I0y&p1V zHPf1Ax<*wPP}Ph5vmawr8>Gr|Xqyz=;-BTPX6}+IHA0oWq{@y_rO&AZZWGkN@?R4V Bsc!%P literal 0 HcmV?d00001 diff --git a/algorithm/acwing/code/out/production/ACWing/b_MergeAlgorithm/T788.class b/algorithm/acwing/code/out/production/ACWing/b_MergeAlgorithm/T788.class new file mode 100644 index 0000000000000000000000000000000000000000..05b11985351da4f1e5a459352bad3ee108d90f80 GIT binary patch literal 1848 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 Dh~MKQ literal 0 HcmV?d00001 diff --git a/algorithm/acwing/code/out/production/ACWing/d_DifferenceMethod/T797.class b/algorithm/acwing/code/out/production/ACWing/d_DifferenceMethod/T797.class new file mode 100644 index 0000000000000000000000000000000000000000..541e1c16b5b6270027f432490f87099e8f43ffe0 GIT binary patch literal 1583 zcmaJ=O>Y}j6g|%#``NBb+JtGEkd{D`)~Q>Y0!?V$23nW22B!u&N(7}MFXL%4&3MKd zk1Mi5LLjkX#R3Tlp|Z$^1??h{3gQQpH9LL?s!+pu9#?UdfaUjf-?``Bd+wXZPapjb zU`d!gl(p8Z)^@kq-4 zQjxgd;eMCs12*CrQ3mf~j-dqg8E&d|yXvr#rL@CTEEA)d6iFrQQs_(CNS_0XMZhP5P z?Y7OlzUzvLwOC?ZcjvxrM-#tS)OxT*l5}N!26$N)Ur~)B0Y+-a^1QU+9ipb z0+V~{+b=hPJw1xF$|-Lp)Rj$9}@Zh+!u6eQhLR zCiS79C!7{xE#Z;?ey*do_SoFdw!WJ|~suXndG zNiUO;Exb&;$@pKR(8Ez!a*fje0Di_x= k) r = mid; + else l = mid + 1; + } + if(arr[l] != k) System.out.println("-1 -1"); + else { + System.out.println(l + " "); + l = 0; + r = n - 1; + while (l < r){ + int mid = (l + r + 1) / 2; + if(arr[mid] <= k) l = mid; + else r = mid - 1; + } + System.out.println(l); + } + } +} diff --git a/algorithm/acwing/code/src/a_BinaryAlgorithm/T790.java b/algorithm/acwing/code/src/a_BinaryAlgorithm/T790.java new file mode 100644 index 0000000..860a902 --- /dev/null +++ b/algorithm/acwing/code/src/a_BinaryAlgorithm/T790.java @@ -0,0 +1,32 @@ +package a_BinaryAlgorithm; + +import java.util.Scanner; + +/** + * @problem 790数的三次方根 + * @idea 二分法 + */ +public class T790 { + public static void main(String[] args) { + double n = new Scanner(System.in).nextDouble(); + cubeRoot(n); + } + + private static void cubeRoot(double n) { + double l, r; + double abs_n = Math.abs(n); + if(abs_n <= 1){ + l = abs_n; + r = 1; + }else { + l = 1; + r = abs_n; + } + while (r - l > 1e-8){ + double mid = (l + r) / 2; + if(mid * mid * mid <= abs_n) l = mid; + else r = mid; + } + System.out.println(String.format("%.6f", n >= 0 ? l : -l)); + } +} diff --git a/algorithm/acwing/code/src/a_BinaryAlgorithm/Template.java b/algorithm/acwing/code/src/a_BinaryAlgorithm/Template.java new file mode 100644 index 0000000..c0feddf --- /dev/null +++ b/algorithm/acwing/code/src/a_BinaryAlgorithm/Template.java @@ -0,0 +1,43 @@ +package a_BinaryAlgorithm; + +public class Template { + /** + * 检查x是够满足某种性质 + * @param x + * @return + */ + public static boolean check(E x){ + /*...*/ + return true; + } + + /** + * 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用。用于确定最左端的位置 + * @param l + * @param r + * @return + */ + public static int bSearchLeft(int l, int r){ + while (l < r){ + int mid = l + r >> 1; + if(check(mid)) r = mid; + else l = mid + 1; + } + return l; + } + + /** + * 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用。用于确定最右端的位置 + * @param l + * @param r + * @return + */ + public static int bSearchRight(int l, int r){ + while (l < r){ + int mid = l + r + 1 >> 1; + if(check(mid)) l = mid; + else r = mid - 1; + } + return l; + } +} diff --git a/algorithm/acwing/code/src/b_MergeAlgorithm/T788.java b/algorithm/acwing/code/src/b_MergeAlgorithm/T788.java new file mode 100644 index 0000000..ab4c846 --- /dev/null +++ b/algorithm/acwing/code/src/b_MergeAlgorithm/T788.java @@ -0,0 +1,49 @@ +package b_MergeAlgorithm; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/** + * @problem 788逆序对的数量 + * @Idea 归并排序 + */ +public class T788 { + public static int n; + public static int[] arrTemp = new int[100010]; + public static long rp = 0; + public static final BufferedReader br = new BufferedReader(new InputStreamReader((System.in))); + public static void main(String[] args) throws IOException { + n = Integer.parseInt(br.readLine()); + int[] arr = new int[n]; + String[] nums = br.readLine().split(" "); + for (int i = 0; i < n; i++) { + arr[i] = Integer.parseInt(nums[i]); + } + reversePairs(arr, 0, n - 1); + System.out.println(rp); + br.close(); + } + + public static void reversePairs(int[] arr, int low, int high){ + if(low < high){ + int mid = (low + high) / 2; + reversePairs(arr, low, mid); + reversePairs(arr, mid + 1, high); + for (int i = low; i <= high; i++) { + arrTemp[i] = arr[i]; + } + int i = low, j = mid + 1; + int k = low; + while (i <= mid && j <=high){ + if (arrTemp[i] <= arrTemp[j]) arr[k++] = arrTemp[i++]; + else { + arr[k++] = arrTemp[j++]; + rp += mid - i + 1; + } + } + while (i <= mid) arr[k++] = arrTemp[i++]; + while (j <= high) arr[k++] = arrTemp[j++]; + } + } +} diff --git a/algorithm/acwing/code/src/c_PrefixSum/T795.java b/algorithm/acwing/code/src/c_PrefixSum/T795.java new file mode 100644 index 0000000..a233b16 --- /dev/null +++ b/algorithm/acwing/code/src/c_PrefixSum/T795.java @@ -0,0 +1,27 @@ +package c_PrefixSum; + +import java.util.Scanner; + +/** + * @problem 795.一维前缀和 + * @idea 前缀和算法 + */ +public class T795 { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int n = sc.nextInt(); + int m = sc.nextInt(); + int[] num = new int[n]; + int[] s = new int[n + 1]; + for (int i = 0; i < n; i++) { + num[i] = sc.nextInt(); + s[i + 1] = s[i] + num[i]; + } + while (m > 0){ + int l = sc.nextInt(); + int r = sc.nextInt(); + System.out.println(s[r] - s[l - 1]); + --m; + } + } +} diff --git a/algorithm/acwing/code/src/c_PrefixSum/T796.java b/algorithm/acwing/code/src/c_PrefixSum/T796.java new file mode 100644 index 0000000..91c978d --- /dev/null +++ b/algorithm/acwing/code/src/c_PrefixSum/T796.java @@ -0,0 +1,31 @@ +package c_PrefixSum; + +import java.util.Scanner; +/** + * @problem 796.二维前缀和 + * @idea 前缀和算法 + */ +public class T796 { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int n = sc.nextInt(); + int m = sc.nextInt(); + int q = sc.nextInt(); + int[][] num = new int[n + 1][m + 1]; + int[][] s = new int[n + 1][m + 1]; + for (int i = 1; i <= n; i++) { + for (int j = 1; j <= m; j++) { + num[i][j] = sc.nextInt(); + s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + num[i][j]; + } + } + while (q > 0){ + int x1 = sc.nextInt(); + int y1 = sc.nextInt(); + int x2 = sc.nextInt(); + int y2 = sc.nextInt(); + System.out.println(s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1]); + --q; + } + } +} diff --git a/algorithm/acwing/code/src/d_DifferenceMethod/T797.java b/algorithm/acwing/code/src/d_DifferenceMethod/T797.java new file mode 100644 index 0000000..ad4b913 --- /dev/null +++ b/algorithm/acwing/code/src/d_DifferenceMethod/T797.java @@ -0,0 +1,29 @@ +package d_DifferenceMethod; + +import java.util.Scanner; + +public class T797 { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int n = sc.nextInt(); + int m = sc.nextInt(); + int[] a = new int[n + 1]; + int[] b = new int[n + 1]; + for (int i = 1; i <= n; ++i){ + a[i] = sc.nextInt(); + b[i] = a[i] - a[i - 1]; + } + while (m > 0){ + int l = sc.nextInt(); + int r = sc.nextInt(); + int c = sc.nextInt(); + b[l] += c; + if(r < n) b[r + 1] -= c; + --m; + } + for (int i = 1; i <= n; i++) { + a[i] = a[i - 1] + b[i]; + System.out.print(a[i] + " "); + } + } +} diff --git "a/algorithm/acwing/notes/1\345\211\215\347\274\200\345\222\214.md" "b/algorithm/acwing/notes/1\345\211\215\347\274\200\345\222\214.md" new file mode 100644 index 0000000..39d39ec --- /dev/null +++ "b/algorithm/acwing/notes/1\345\211\215\347\274\200\345\222\214.md" @@ -0,0 +1,91 @@ +## 前缀和 + +--- + +### 一维前缀和 + +#### 一维前缀和是什么 +原数组: a[1], a[2], a[3], a[4], a[5], …, a[n] + +前缀和 S[i]为数组的前 i 项和 + +前缀和: S[i] = a[1] + a[2] + a[3] + … + a[i] + +**注意：前缀和的下标从1开始，s[0]=0;** + +> s[0] = 0 +> s[1] = s[0] + a[1] +> +> s[2] = s[1] + a[2] +> +> ...... +> +> s[i] = s[i - 1] + a[i] + +**前缀和的作用** +快速求出元素组中某段区间的和 + +**一维数组求解前缀和(Si)** + +1. for循环求出 每个S[i] (将 S[0] 定义为 0, 避免下标的转换) +2. 求 [l, r]中的和, 即为 **==S[r] - S[l-1]==** +```java +public class Main { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int n = sc.nextInt(); + int m = sc.nextInt(); + int[] num = new int[n]; + int[] s = new int[n + 1]; + s[0] = 0; + for (int i = 0; i < n; i++) { + num[i] = sc.nextInt(); + s[i + 1] = s[i] + num[i]; + } + while (m > 0){ + int l = sc.nextInt(); + int r = sc.nextInt(); + System.out.println(s[r] - s[l - 1]); + --m; + } + } +} +``` + +### 二维前缀和 + +#### 二位前缀和是什么 + +在一维前缀和的基础上，将一维数组改为了矩阵 + +前缀和`S[i][j]`表示二维数组的前 i 行、前 j 列的和 + +![](https://img-blog.csdnimg.cn/20201217174700577.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ==,size_16,color_FFFFFF,t_70) + +紫色面积是指(1,1)左上角到(i, j-1)右下角的矩形面积, 绿色面积是指(1,1)左上角到(i-1, j )右下角的矩形面积。 + +*每一个颜色的矩形面积都代表了它所包围元素的和。* + +从图中我们很容易看出，整个外围蓝色矩形面积s[i][j] = 绿色面积`s[i-1][j]` + 紫色面积`s[i][j-1]` - 重复加的红色的面积`s[i-1][j-1]`+小方块的面积`a[i][j]`; + +**注意：前缀和的下标从i=1, j=1开始，`s[0][i]=0、s[j][0]=0`;** + + + +#### 公式 + +==**`s[i][j] = s[i - 1][j] + s[i][j - 1] + a[i][j] - s[i - 1][j - 1]`**== + +以`(x1, y1)`为左上角，`(x2, y2)`为右下角的矩阵的和为：**==`s[x2][y2] - s[x1 -1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]`==** + +![](https://img-blog.csdnimg.cn/20201217174751639.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ==,size_16,color_FFFFFF,t_70) + + + +--- + +**相关题目:** + +***AcWing 795 https://www.acwing.com/activity/content/problem/content/829/*** + +***AcWing 796 https://www.acwing.com/activity/content/problem/content/830/*** diff --git "a/algorithm/acwing/notes/2\345\267\256\345\210\206.md" "b/algorithm/acwing/notes/2\345\267\256\345\210\206.md" new file mode 100644 index 0000000..b9508b4 --- /dev/null +++ "b/algorithm/acwing/notes/2\345\267\256\345\210\206.md" @@ -0,0 +1,80 @@ +## 差分 + +--- + +类似于数学中的求导和积分，**差分可以看成前缀和的逆运算**。 + + + +### 1. 什么是差分？ + +**差分数组**：首先给定一个原数组a ：`a[1], a[2], a[3]...... a[n]`； 然后我们构造一个数组b ： `b[1] ,b[2] , b[3]...... b[i]`; + +使得 `a[i] = b[1] + b[2 ]+ b[3] +...... + b[i]`。 + +​ 也就是说，a数组是b数组的前缀和数组，反过来我们把b数组叫做a数组的差分数组。换句话说，每一个`a[i]`都是b数组中从头开始的一段区间和。 + + + +### 2. 如何构造差分数组？ + +最直接的方法如下： + +`a[0]= 0;` + +`b[1] = a[1] - a[0];` + +`b[2] = a[2] - a[1];` + +`b[3] =a [3] - a[2];` + +`........` + +`b[n] = a[n] - a[n-1];` + +**图示：** + +![](https://img-blog.csdnimg.cn/20201217174809672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ==,size_16,color_FFFFFF,t_70) + +我们只要有b数组，通过前缀和运算，就可以在O(n) 的时间内得到a数组 。 + + + +### 3. 差分数组的作用 + +**话说有这么一个问题：** + +​ 给定区间`[l ,r ]`，我们把a数组中的`[ l, r]`区间中的每一个数都加上 c ，即 `a[l] + c , a[l+1] + c , a[l+2] + c ...... a[r] + c`。暴力做法是for循环 l 到 r 区间，时间复杂度O(n)，如果我们需要对原数组执行m次这样的操作，时间复杂度就会变成O(n*m)。 + + + +**有没有更高效的做法吗? 考虑差分做法。** + +​ 始终要记得，a 数组是 b 数组的前缀和数组，比如对 b 数组的`b[i]`的修改，会影响到 a 数组中从`a[i]`及往后的每一个数。 + +​ 首先让差分b数组中的 ==`b[l] + c`== ,a 数组变成 `a[l] + c, a[l+1] + c, ...... a[n] + c`; + +​ 然后我们打个补丁，==`b[r+1] - c`==, a数组变成 `a[r+1] - c, a[r+2] - c, ......a[n] - c` + + + +==**为啥还要打个补丁？**== + +我们画个图理解一下这个公式的由来: + +![在这里插入图片描述](https://img-blog.csdnimg.cn/20201215163431253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ==,size_16,color_FFFFFF,t_70) + +`b[l] + c`，效果使得 a 数组中 `a[l]`及以后的数都加上了 c (红色部分)，但我们只要求l到r区间加上 c , 因此还需要执行 `b[r+1] - c`,让 a数组中`a[r+1]`及往后的区间再减去 c (绿色部分)，这样对于`a[r]` 以后区间的数相当于没有发生改变。 + + + +### 4. 一维差分结论 + +​ 给 a 数组中的`[ l, r]`区间中的每一个数都加上 c，只需对差分数组b做 `b[l] + = c`, `b[r+1] -= c`。时间复杂度为O(1), 大大提高了效率。 + +------ + +**相关题目：** + +***ACWing797 https://www.acwing.com/problem/content/799/*** + diff --git a/algorithm/leetcode/Java LeetCode.iml b/algorithm/leetcode/Java LeetCode.iml new file mode 100644 index 0000000..be85132 --- /dev/null +++ b/algorithm/leetcode/Java LeetCode.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/Hanoi.class b/algorithm/leetcode/out/production/Java LeetCode/practice/Hanoi.class new file mode 100644 index 0000000000000000000000000000000000000000..592150d7f578e7c25af31c7563be172de99604cc GIT binary patch literal 1505 zcmaJ=ZEqVz5PsHg=Ugv|o8YuKFHPIDby8A8DHO0BXpW|JaoU2TBE%Oqms4`h`OZ48 zEAmhHSg9ZQOpsa>Bz^!t3i0gS6+6W0Nw+&QyEF65GqZpHbMhB}yVx-?iR%V#OrVNY z6B(@O<)#S>A86b91f^RuynNfl$G9^Cflm$GHSn20uCLslfM^L68eZV34S{TR^%+m> zaL*N(ZhL|Ic+lN-qaC^H(=yWz9qB)lk*D?4m{SK{U!c_PMbc58~47}7v_ey!ukAaElCpIi6>b$y{> zp@|I(3s|)9CBCvSg=rSK8HTE_BH7z^)j_z|pDy5D5t|lld~M*qg)KZN;-S{b>(psV z=s)D)$?kL4QKw9uBesNvWi)H$gflO!wSwM2kv3O$N$SPw*aJ2VbwH`FWT4ofa<#R3wu5Y3Tn!P9 z1SX1}PUGtmQmFs$dtR)sZ!qH=+d3w&fwt!FsldvRE-!cy9=hrDBq+ByZees};5$xm zI}8s89A~SgTWR~U-**Z9mr)35jHGoOh&|u!uOyE3v-OQwPC4!z_1rPnM~67+ZGE)1 zG=wdEzvC&lZlEJ@?M!{+un8=^`yMXynNRYSv!8lSDdi}0%(?2M@t&5}L;2MWh9j!`_J z6JEm{hM%D$Vnh=RX5u=|#i{0!aCjdTo=`1LPrsw6p=9GqE36evQYIx!tm-DMcc?X3t*(A8Nyf8F z)WEmDOi5GLB)OMjz|9zD7FTE`BjqKQcJ)7sHE{jqvuR>J52^{p1;SXNmccbV;coKs VHonDU)?TAN#gh+d`zT&N`4{B_NV5O{ literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_1.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_1.class new file mode 100644 index 0000000000000000000000000000000000000000..f0a9796a9303371eb4152b063fee5a4cdffb25a2 GIT binary patch literal 999 zcmZuvTTc@~7(KJQ?ZS4;O^Y`KLBtk>iXvzrycmg%wSB0m0*Pk2tgu+NP1(ip?w|10 z7hmy3yb$8E|HfAnFK4z8O6YEOX1_Dv`Mz^z=I7sUhXCdP zhNt2q&726Mafn{r2H!@#R%pUOJR^q=mzTR-kQcRF>U8CIpgp3V7zyY4pT+dzvfnJfj; zdBgIN0~5CdtWqs(IPQ|CYoM6PoA`3dG6VctcGs!HT|b^nKnKI5>Cwzq~~uxad!n$ z>6WBs)%nZ{Pc+)wv39Fx3AFC{L0Pqq?gEcTuZNU(zYYH^y;bLt1PnvnM)hdmMj*+t zi&2)d;2ay@hximNcXNzKU>rUCx0?y*MIR%9b2!gYk$>?9$2eEMLtEa5UeITalreGm z0maFIiIg$5_65dQ#5BCeXzajR)?4AYh959LqocS?R&j4qF-S-m5vx5jsa#WuTA7CkwGF!=zowfF(e-Rj;PlNY8d_xi|p4} literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_14.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_14.class new file mode 100644 index 0000000000000000000000000000000000000000..e64d71230b8aa5105cdc81e19d0f71e209367995 GIT binary patch literal 818 zcmZuu&2AD=7(JJnVHg~0g;H%TYHPJn6k;_PQ$-C)6$8}-Qx`6Dn2s!Aq;%Cz5XXw$dqtvl-inZECJoMBk=2Ls=G5jgMMj{+TfN+oOPi>j|VYRXFlduJ zmAMP<+Ui$`FH!gmZ9D=MnDot~1f(#<6Wss#fiEHy{N417bg#tDxEQ6 z6;-KdS#3ex{)7_2thSaLL*cHzjl4Y=yNdXH_$#aCzCo?1yBbeFS*>K%F|>WQRv_t= zBCGMzIBDplkl?fpED>2|>>f!zWaJ64CZm#emAUh{jdMstlO&G?NH2pKN=V@uvW&)9 n@f5T46n1^YKTTm5SThGLdB|v7m*1S=0*v_smI^kP!@T$hoY$GB literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_15.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_15.class new file mode 100644 index 0000000000000000000000000000000000000000..c77edaafc906904e1cda3e3abb3ae5c57f506c2f GIT binary patch literal 1437 zcma)6O>Y}j6g_V|GtYMHex#XcLz~hMLY>;!ZJ|z!LlCM2ij=fSu3DKO$i$vH(@e%; zJg(F&%0FPiimFPHA|V!KmC%Z;5J>D;u|e!x35gX#RfRckoXAPZqGNg9yZ4@Z?tSMz z%`g8x+5|9;cheZan8evMG>oN@M?vC^Gz=7#QBv-612~QI5*H-i6fh^ez>6jY61lM( z0{WF!!xh*+?FH`D&eFUaUU%kwdIqOkb;rNqgr2guoO-n2wH10fbn1~;cS~14J%6zx zkc<{W*R6Jz1cq|6Q)AP&ojXpc6M24V+G|HdB-$z{rr1H`giSYMZQs4c#R$FT0$1VD z6?B$ZK$|5l;RM_s_&=2h1nk}I-Cf>par_1R#NM{=1kKV^5V=h^tW5GJkgY~eeR0NF zjt?vGmc%iERMl$+PSgphNo9|ty*z)q+UkUL_kB;vn^M9Rl}Z_8kQF%8SM0qobnYtI zBrax9#<;-2IJ&dx3@+hv25+OH2qrRk2OMg4*I=k#KkwT7ZMROD_w@^@8rzt7R&iyD zuD4sEnv6OxFNwV4_#OA!Ey|wTp6$+FD4yxGdu*e**`DGtpjWiA$9)*i?HJ6JmhZDU zuN72Oy@bi5?8_1IJ*w!S-b~x z4L@7*9u6s!f4xz>ubkg1JDQ|puB=<8-Y6TEZW*iiB5&yg8pXMC(n^lp$8tecG=G3m zOQ@s`nAMuDQ1Q-CShd@LTu1VIq%_=I(Z!0>ko|JDURb$oWNh?_#3C( zHan@|OLE!#j=hTC$Y?{V>1<6-?T(V4-yQOfu!2VGcVcbM`vj3{(!JP8#!k_56WQk& zlsGNAJXumAE%6#nh6Jz8;82(3eYa2#@EjkC;o*U2(7NR5hqtnxvB6R9HN4J(XX0J% EKa?3XL;wH) literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_18.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_18.class new file mode 100644 index 0000000000000000000000000000000000000000..d1cf5a29a298228a9d96148e14ea0885f784d506 GIT binary patch literal 1733 zcma)7O;2NG6n;*7KYA}6hGDps&UC(EEEHNtoiYldlSxc4$e1u0gDm9I7Pw4l$>o*= z-Gb4TF>&EyGLmY-!iCI2K}Rvh#D#xAmu~$Dn#t7Xy)6Mo7Ph_bd){-N^PG?OwEgYL z_j>?_aMMN`GA0IWM3AvDh^&d64IR&^!!@OTz74&2!NiLut_zG2ui^!xf@r$$u0Xq0 zEtUi)$Gu8vqP8?!^6$8_WokOds|B}w*Y!PhZYi~3!CO)2W#26XUZIqmc=y_kVSzbU zt@)F+C4rNk9vkZ$UvyX9TrKd*xp8kLAVMpb<^q9?33T6^U!ZI)dBr=fKVPC8T~W@m z$j2kNQd?r2$TZPLun%!7)OGxqS}KCX(RA0A_fsBv3O{oEx$IWvb7PgDG+*+ENBI_< zm<-&)y*J(Euy_-B6X%%pq&Hu2gPPACjT~3&{|{hKvT23V>z?Yjr8=2aZHpt06N1wR zExhUb?wabOiJ>@d;3dJS(0VxQI9|qZ93yx|5sb$1Dqdp|M{bJkJMgXvJz+jH!DdjGNy=fdt8?n;xbH$B~Kc?f6*9X@72 zlIcS?bE{e|GdZtX8CLP4Zn3CF>lmVUa0%*5pk5J(>K)g1o^srUyWYP8c^H~cay3Gw zi4Mx~CIF|<$rF2yE|SnW`W9k}RDOAc$kYy^6PaIOW%kTE^ug`SUOtxDg%-_Qj^)IR zVqNZM94ouQMVrZPxZL&DZm2!A@#zB?Te8|h(IrI1^wzGaov8Z?^@d|Tz-a|le8udh zQeIcodE2oaI@RTBi^*N>fguq$`I|GL)N=c46)y z_8qJU-d@*aU2inG6HRU{%*CQ*tMON8X?&nu`LN#2#u^=zh0*J1!sbHN%(^XGPkvvw zxVnSeyjl(F>V2fRTD)4D7u}9-YEvA9GzVaUBM@)^KBDC_IQRhx{E27qH&G2FMaLQG z#92uqB|ZEh$l$yz;DX%4MXBJDe2B|ZM~{4sUik)H@(3OBGy20ZTjnS=@GV&r(8#n+ z-UM{=eL?mF3^IO#Bqb9c%K*+$vdLY?SxS}~!`6r@DTQ-tY$=_mHG&vpUBE>|(Jf!` z+mK*=mszJ8?xyVuZ9UYykIu*FG?`(8{I;n+SA}QVAmq&Uc0FcZ16R5mOswqyAhfE7 kWlTS%r<(d?GTz|7&LNj3Cr$rA=LgSH5n-zZeWBF9oUCN}&n}sHoTiQUt}1Vg;)vBz!DtAWDoG%2);=iPhHx%2bz>vsUxaZkqy^k}%G!-XCl zVMOHAt3yYh#QNoQSxy5Qq7ojIhbtO}Gz<%PM(wQa#0A{p$gF^pSY5OP8Yk_nHC8C@3F#*k9n>91`qChA-xoobR z(Ttf*N0Uz8&Zc9L#{#a@l7L8X*c=la3>5sIE8t5lnfat+rk)ElRR{&g&M+7u=5lAO ztiZ|o`ZjWZYpmw4JsCZcB*DguM6H`6v*m@n;s6 zt&~#-Ror9?X+YYcoopeE^hm$PNmarV5gM$mo0)<&^Gu*MoQNDNp4?nvjS+f|cB_&y zcJxUV5>Ty`oU>6*$!01!%VKw0!pCyU4dmxgpo=V#CAo8}Ih=!^->&?*KsOQK+{9Cq ztKh2k?n8VoUk5pRDj=G&#9SWC*#3{N9d9YG`NKLg>GSVghJu~$^ld_<6I!ag^Pax D5c=-m literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_3.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_3.class new file mode 100644 index 0000000000000000000000000000000000000000..88180468d02039734f19886fb3ebdb82e3e59e45 GIT binary patch literal 1127 zcmZuvO-~b16g{sqoq_34zARt1Dj?W`P!&a`w2Dm(O$sb(FlwTiPKS1|AJ|UuBQb9H z6S6chZrHd1)Wjd))_>zdJkx@u(V5JB@1FbKz31FJKYoAx4&Ww|8gxu*7{etMVGUB# ziD;O@v=8IB?3x+Z%xZ|@ii)c$t_diMcG-3k0#Z1#E+8i>IZL2BZI`XpdMRsF9~jvp zk-l`rG>Yp+)pq@3P<9G-O~9Ytsv4$an^tu7*<4IusA!e*PGM~$T`A|Snv5 z9lIFKSPmHsw9|dPbwYWv{pjMUQptkh%CM@j1T%DH9K(FRVr(_Es+d!8T|moJ>Q&Ra zZ@WF|pxRkijgBt(b=<(bKyO1{gUYf|E0B)P`P@=*TgL)oIu;Svk#NluqYv4nd9 z`sp4D^t8IPmff^WrwwX0jwD;fScubXHoh@UHd8SvX^FTTPDPRe{jH>b#j>Z{MzLB}EkQcntyb@4?AMhlgyvM+>cRHZRxqWyKp?rbr!NY*e=!_eX zPv8y@b}`Zhb@JqnEIu9m3~msy&PYa$njj1mdL+j+#AstTWqF(HJCakf7c{Y7>H7kS2mi9enu<39iZ literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_33.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_33.class new file mode 100644 index 0000000000000000000000000000000000000000..767719fd21c06cac93ec6468cc366f14c93aa166 GIT binary patch literal 1694 zcmZuxT~ixX7=F%vWXWbJpNmjFgtoSUQc^)vfi}ffs!={FAd0b;O|qq1lT9YsIC$e# zM~A=Qh0_mbxZ%cLKt~*YfPck*(5d2cHj$Po7kkco-tXsm&)L8J{o??@6=Y3xAZg%= zfe)gX#FPmY(wBBWa#B(T-a(?qd_5AZ_4N1D^>* zu6n)~qy*IX@T!1zvy^uQTIM|8U8ohaZe_*E7N}{TE9IQRs#EdgxuMj8`(9Ogmn%*# z@N#Zq;qJu5G}9Cv&ll*5XXYL_-#dwd<8LIEgNo;GOv^ID!~FGv}5AujE$^%rUI$I+fgg3h_)jJIIlk{!EPRcOg>PV67(>Fs9eiuxu7!0tM1E{20@x-Yd|=M?)ZrYIp>a7rpDN$wuubn(1TBc zXFXRaRoSXqs>!G$thafa8`C5Sbt*ai*VN2amQDqEN#p6^RSfYFcJMWWPnY0fbM4|O z!Ci3INA@6or=Z|1u8~j~LpNos?tmVg<|&F^^wEpKVh}nE>hk+g*7l*UJ%hFfeGiej zi@Pw|n|2YMA3aF*|7lKXYErlL{wJ_|G+Q6F_3`I07a!_k`|$65#Ok5eE}D}%V^2w^ z=V(bro}tx_?4nKfriQ(Zvm>CHfKIWK7QBsCoI@KfQ8UT?I^iu4;1YYxFd|1362}sn zaDh@k2G}>dX5=9Ec3OsThA8{^e>zK@Ldz_34zS`m%-|iIhsK;;jF+()vJj^f!7$@b zLph`&VqnC8!c`c!NKRj{_9*QdGhc!!9||SO+az@nTDC?GuJ!!_UES%^9-(za9qWAr zL*0g^?5L?eEuYl-ZS5(tT-WtNQXjE(=@PN^9Vs&4G0ygeTW7D-Jb`8FGHx3@YU`af{8iauGj(#ONGeE&N?NY2 aWk%p1M1**WZZTwZzkseV{ypYW@cw_JJW;X$ literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/N_35.class b/algorithm/leetcode/out/production/Java LeetCode/practice/N_35.class new file mode 100644 index 0000000000000000000000000000000000000000..0bd00832b19f24bcb070a4150bff187520499667 GIT binary patch literal 568 zcmY*VO>fgc6r8np?KVxD66)}wrV+gTQT>{v{{R&*%@p0G3Jpu1&k|jk) zz}?(B7LYH-eIrmiNHTLc9raB9R`*ge^@DM&(_@_{ww{x+7$y@teU|IENMaKnzT4h; zB2b+eoyWr{o0zHka!tlD0f>TD3c>7AOmzymmZy8Rqb42scX z6*3EE_4q5qm$L0MdL`*%fw=l_0E?)w5?Cr3yL`r(c2WiycH2pPL7-Bs(Y zK()_N4V3N8Zhn-+XDpHEc4jwMfx1|4HQS%yH)rsgvU|bHTv!7eWmGiaV}-Fn`A0Oc zNBMm$m&Q62Z{Q)T6~2cy<`ylgVYRd!;TF3N&nwi4?3141Hj%^{ck1wdV?l^t*bud! Oa4OI3{|MM|(D(}i6kq@V literal 0 HcmV?d00001 diff --git a/algorithm/leetcode/out/production/Java LeetCode/practice/easy/N_1122.class b/algorithm/leetcode/out/production/Java LeetCode/practice/easy/N_1122.class new file mode 100644 index 0000000000000000000000000000000000000000..32a0b2113c8bcbaa674e689069a4c7b5a7709e4f GIT binary patch literal 2466 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 mG0R+|OGT<63Mo!J!DgCtJw}9oPY@G0-2FJ1 hm = new HashMap(); + for (int i = 0; i < nums.length; ++i){ + if (hm.containsKey(target - nums[i])) { + return new int[]{hm.get(target - nums[i]), i}; + } + hm.put(nums[i], i); + } + return new int[0]; + } +} diff --git a/algorithm/leetcode/src/practice/N_14.java b/algorithm/leetcode/src/practice/N_14.java new file mode 100644 index 0000000..2af38cc --- /dev/null +++ b/algorithm/leetcode/src/practice/N_14.java @@ -0,0 +1,17 @@ +package practice; + +public class N_14 { + public String longestCommonPrefix(String[] strs) { + if (strs.length == 1) return strs[0]; + int strCount = strs.length; + int j = 0; + int min = strs[0].length(); + for(int i = 0; i < strCount - 1; ++i){ + j = 0; + while (strs[i].charAt(j) == strs[i + 1].charAt(j)) + ++j; + min = Math.min(min, j); + } + return strs[0].substring(0, min); + } +} diff --git a/algorithm/leetcode/src/practice/N_15.java b/algorithm/leetcode/src/practice/N_15.java new file mode 100644 index 0000000..e92e00c --- /dev/null +++ b/algorithm/leetcode/src/practice/N_15.java @@ -0,0 +1,36 @@ +package practice; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class N_15 { + public List> threeSum(int[] nums) { + List> ans = new ArrayList<>(); + if(nums == null || nums.length < 3) return ans; + int target; + int left, right; + Arrays.sort(nums); + int n = nums.length; + for (int i = 0; i < n - 2; i++) { + if (nums[i] > 0) break; + if (i > 0 && nums[i] == nums[i - 1]) continue; + target = -nums[i]; + left = i + 1; + right = n - 1; + while(left < right){ + int sum = nums[left] + nums[right]; + if( sum== target){ + ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[left], nums[right]))); + ++left; + --right; + while (left < right && nums[left] == nums[left - 1]) ++left; + while (left < right && nums[right] == nums[right - 1]) --right; + }else if(sum < target) ++left; + else --right; + + } + } + return ans; + } +} diff --git a/algorithm/leetcode/src/practice/N_18.java b/algorithm/leetcode/src/practice/N_18.java new file mode 100644 index 0000000..90893b9 --- /dev/null +++ b/algorithm/leetcode/src/practice/N_18.java @@ -0,0 +1,44 @@ +package practice; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class N_18 { + public List> fourSum(int[] nums, int target){ + List> ans = new ArrayList<>(); + if(nums == null || nums.length < 4) return ans; + int left,right; + int midTarget; + int sum; + int n = nums.length; + Arrays.sort(nums); + for (int i = 0; i < n - 3; i++) { + if((long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break; + if((long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue; + if(i > 0 && nums[i] == nums[i - 1]) continue; + for(int j = i + 1; j < n - 2; ++j){ + if((long)nums[i] + nums[j] + nums[i + 1] + nums[i + 2] > target) break; + if((long)nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target) continue; + if(j > i + 1 && nums[j] == nums[j - 1]) continue; + left = j + 1; + right = n - 1; + midTarget = target - nums[i] - nums[j]; + while (left < right){ + sum = nums[left] + nums[right]; + if(sum == midTarget){ + ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[left], nums[right]))); + ++left; + --right; + while (left < right && nums[left] == nums[left - 1]) ++left; + while (left < right && nums[right] == nums[right + 1]) --right; + } + else if(sum < midTarget) ++left; + else --right; + } + } + + } + return ans; + } +} diff --git a/algorithm/leetcode/src/practice/N_20.java b/algorithm/leetcode/src/practice/N_20.java new file mode 100644 index 0000000..50b75d7 --- /dev/null +++ b/algorithm/leetcode/src/practice/N_20.java @@ -0,0 +1,25 @@ +package practice; + +import java.util.Stack; + +public class N_20 { + public boolean isValid(String s) { + Stack charStack = new Stack<>(); + int len = s.length(); + for (int i = 0; i < len; ++i) { + char ch = s.charAt(i); + if(ch == '(' || ch == '[' || ch == '{' ) + charStack.push(ch); + else { + if (charStack.empty() + || ch == ')' && charStack.peek() != '(' + || ch == ']' && charStack.peek() != '[' + || ch == '}' && charStack.peek() != '{') + return false; + else charStack.pop(); + } + } + if(charStack.empty()) return true; + else return false; + } +} diff --git a/algorithm/leetcode/src/practice/N_3.java b/algorithm/leetcode/src/practice/N_3.java new file mode 100644 index 0000000..5f30ec7 --- /dev/null +++ b/algorithm/leetcode/src/practice/N_3.java @@ -0,0 +1,25 @@ +package practice; + + +import java.util.HashSet; +import java.util.Set; + +public class N_3 { + public int lengthOfLongestSubstring(String s) { + if(s.length() == 0) return 0; + int len = s.length(); + int maxSize = 0; + int tail = 0; + Set hs = new HashSet(); + for (int i = 0; i < len; ++i) { + if(i != 0) + hs.remove(s.charAt(i - 1)); + while (tail < len && !hs.contains(s.charAt(tail))){ + hs.add(s.charAt(tail)); + ++tail; + } + maxSize = Math.max(maxSize, tail - i); + } + return maxSize; + } +} diff --git a/algorithm/leetcode/src/practice/N_33.java b/algorithm/leetcode/src/practice/N_33.java new file mode 100644 index 0000000..b008870 --- /dev/null +++ b/algorithm/leetcode/src/practice/N_33.java @@ -0,0 +1,50 @@ +package practice; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.util.Scanner; + +/** + * @problem 33. 搜索旋转排序数组 + * @idea 二分法 + */ +public class N_33 { + public static void main(String[] args) throws Exception{ + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + String[] s = br.readLine().split(","); + int n = s.length; + int[] nums = new int[n]; + for (int i = 0; i < n; i++) { + nums[i] = Integer.parseInt(s[i]); + } + int target = new Scanner(System.in).nextInt(); + br.close(); + int index = search(nums, target); + System.out.println(index); + } + + /** + * O(logn) + O(1) + * @param nums + * @param target + * @return + */ + private static int search(int[] nums, int target) { + int len = nums.length; + if (len == 0) return 0; + if (len == 1) return nums[0] == target ? 0 : -1; + int l = 0, r = len - 1; + while (l <= r){ + int mid = (l + r) / 2; + if(nums[mid] == target) return mid; + if(nums[mid] >= nums[0]) + if(target >= nums[0] && target < nums[mid]) r = mid - 1; + else l = mid + 1; + else + if(target > nums[mid] && target <= nums[len - 1]) l = mid + 1; + else r = mid - 1; + } + return -1; + } + +} diff --git a/algorithm/leetcode/src/practice/N_35.java b/algorithm/leetcode/src/practice/N_35.java new file mode 100644 index 0000000..d0833bf --- /dev/null +++ b/algorithm/leetcode/src/practice/N_35.java @@ -0,0 +1,15 @@ +package practice; + +public class N_35 { + public int searchInsert(int[] nums, int target) { + int left = 0, right = nums.length - 1; + int mid; + while (left < right){ + mid = (left + right) / 2; + if(target < nums[mid]) right = mid - 1; + else if(target > nums[mid]) left = mid + 1; + else return mid; + } + return target <= nums[left] ? left : left + 1; + } +} diff --git a/algorithm/leetcode/src/practice/easy/N_1122.java b/algorithm/leetcode/src/practice/easy/N_1122.java new file mode 100644 index 0000000..dbec1c7 --- /dev/null +++ b/algorithm/leetcode/src/practice/easy/N_1122.java @@ -0,0 +1,86 @@ +package practice.easy; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.HashMap; +import java.util.TreeSet; + +/** + * @problem 1122. 数组的相对排序 + * @idea 由于数组元素范围较小且元素个数较小，采用计数排序 + */ +public class N_1122 { +// public static int[] relativeSortArray(int[] arr1, int[] arr2) { +// HashMap hs = new HashMap<>(); +// for (int num : arr1) { +// int count = hs.getOrDefault(num, 0) + 1; +// hs.put(num, count); +// } +// int i = 0; +// for (int num : arr2) { +// int size = hs.get(num); +// while (size > 0){ +// arr1[i] = num; +// ++i; +// --size; +// } +// hs.remove(num); +// } +// TreeSet set = new TreeSet(hs.keySet()); +// for (Integer num : set) { +// int size = hs.get(num); +// while (size > 0){ +// arr1[i] = num; +// ++i; +// --size; +// } +// hs.remove(num); +// } +// return arr1; +// } + public static int[] relativeSortArray(int[] arr1, int[] arr2) { + int[] arr = new int[1010]; + for (int num : arr1) { + arr[num]++; + } + int i = 0; + for (int num : arr2) { + int size = arr[num]; + while (size > 0){ + arr1[i++] = num; + --size; + } + arr[num] = 0; + } + int len = arr.length; + for (int k = 0; k < len; ++k) { + while (arr[k] > 0){ + arr1[i++] = k; + --arr[k]; + } + } + return arr1; + } + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + String l1 = br.readLine(); + String l2 = br.readLine(); + String[] l1_str = l1.split(","); + String[] l2_str = l2.split(","); + int len_1 = l1_str.length; + int len_2 = l2_str.length; + int[] arr1 = new int[len_1]; + int[] arr2 = new int[len_2]; + for (int i = 0; i < len_1; ++i){ + arr1[i] = Integer.parseInt(l1_str[i]); + } + for (int i = 0; i < len_2; ++i){ + arr2[i] = Integer.parseInt(l2_str[i]); + } + arr1 = relativeSortArray(arr1, arr2); + for (int i : arr1) { + System.out.print(i + " "); + } + } +} diff --git a/algorithm/leetcode/src/practice/easy/N_819.java b/algorithm/leetcode/src/practice/easy/N_819.java new file mode 100644 index 0000000..ab2b43b --- /dev/null +++ b/algorithm/leetcode/src/practice/easy/N_819.java @@ -0,0 +1,41 @@ +package practice.easy; + +import java.util.HashMap; +import java.util.HashSet; + +/** + * @problem 819. 最常见的单词 + * @idea 字符串的基础操作：StringBuilder Character HashSet HashMap + */ +public class N_819 { + public String mostCommonWord(String paragraph, String[] banned) { + HashSet bannedSet = new HashSet<>(); + for (String str : banned) { + bannedSet.add(str.toLowerCase()); + } + HashMap frequency = new HashMap<>(); + StringBuilder sb = new StringBuilder(); + int len = paragraph.length(); + int maxFrequency = 0; + + //for(i <= len)而不是for(i < len)的目的是：当最后一个单词以字母结尾时，将单词读入到StringBuilder，否则最后一个单词会丢失 + for (int i = 0; i <= len; i++) { + if(i < len && Character.isLetter(paragraph.charAt(i))) + sb.append(paragraph.charAt(i)); + else if(sb.length() != 0){ + String word = sb.toString().toLowerCase(); + if(bannedSet.size() == 0 || !bannedSet.contains(word)){ + int count = frequency.getOrDefault(word, 0) + 1; + frequency.put(word, count); + maxFrequency = Math.max(maxFrequency, count); + } + sb.setLength(0); + } + } + for (String s : frequency.keySet()) { + if(frequency.get(s).equals(maxFrequency)) + return s; + } + return null; + } +}