diff --git a/Algorithm/search_and_sort_algorithm/Bubble_Sort/Bubble_Sort/main.cpp b/Algorithm/search_and_sort_algorithm/Bubble_Sort/Bubble_Sort/main.cpp index 62b4301..15ecd77 100644 --- a/Algorithm/search_and_sort_algorithm/Bubble_Sort/Bubble_Sort/main.cpp +++ b/Algorithm/search_and_sort_algorithm/Bubble_Sort/Bubble_Sort/main.cpp @@ -4,10 +4,11 @@ using namespace std; void Bubble_Sort(vector& vec) { - int len=vec.size(); + int len = vec.size(); bool flag = true; //第一种方法：每一轮循环，最大元素往下沉 - /*for(int i=0;i& vec) flag = true; } } - }*/ + } + */ //第二种方法：每一轮循环，小元素往上浮 for(int i=0;i& vec) { if(vec[j] > vec[j+1]) { - swap(vec[j],vec[j+1]); flag = true; } @@ -37,21 +38,25 @@ void Bubble_Sort(vector& vec) } + +/*****测试主函数******/ int main() { vector vec_in; int n,a; - cin>>n; + cin >> n; for (int i=0;i>a; + cin >> a; vec_in.push_back(a); } + Bubble_Sort(vec_in); for(int j=0;j& vec) { - int len=vec.size(); + int len = vec.size(); for(int i=1;i=1 && vec[j] < vec[j-1];j--) { swap(vec[j],vec[j-1]); } - //vec[j+1]=tmp; } } +/****测试主函数*****/ int main() { vector vec_in; int n,a; - cin>>n; + cin >> n; for (int i=0;i>a; + cin >> a; vec_in.push_back(a); } Insert_Sort(vec_in); for (auto iter=vec_in.begin();iter!=vec_in.end();iter++) { - cout<<*iter< using namespace std; + void Select_Sort(vector& vec) { - int len=vec.size(); + int len = vec.size(); for (int i=0;i vec_in; diff --git a/Algorithm/search_and_sort_algorithm/heap_sort/heap_sort/main.cpp b/Algorithm/search_and_sort_algorithm/heap_sort/heap_sort/main.cpp index f885bc4..3ec3129 100644 --- a/Algorithm/search_and_sort_algorithm/heap_sort/heap_sort/main.cpp +++ b/Algorithm/search_and_sort_algorithm/heap_sort/heap_sort/main.cpp @@ -6,38 +6,38 @@ using namespace std; //堆排序函数 void HeapSort(vector& vc,int a,int b) { - //int temp=vc[a]; - //int j=2*a+1; for(int j=a*2+1;j<=b;j=j*2+1) { //j对应左孩子，同时应该检查右孩子（j+1<=b）防止越界 - if(j+1<=b && vc[j] vec; - while(cin>>n) + while(cin >> n) { for(int i=0;i>a; + cin >> a; vec.push_back(a); } - int len=vec.size(); + int len = vec.size(); for(int i=len/2-1;i>=0;i--) { HeapSort(vec,i,len-1); @@ -53,6 +53,7 @@ int main() { cout<& vec1,vector& vec2,int a,int m,int b) { - int i=a; - int j=m+1; - int cnt=a; - for (;i<=m && j<=b;cnt++) + int i = a; + int j = m+1; + int cnt = a; + for (;i <= m && j <= b;cnt++) { - if(vec1[i]<=vec1[j]) + if(vec1[i] <= vec1[j]) { - vec2[cnt]=vec1[i++]; - //i++; + vec2[cnt] = vec1[i++]; } else{ - vec2[cnt]=vec1[j++]; + vec2[cnt] = vec1[j++]; } } - if(i<=m) + + if(i <= m) { - while (i<=m) + while (i <= m) { - vec2[cnt++]=vec1[i++]; + vec2[cnt++] = vec1[i++]; } } - if(j<=b) + + if(j <= b) { - while (j<=b) + while (j <= b) { - vec2[cnt++]=vec1[j++]; + vec2[cnt++] = vec1[j++]; } } } void solution(vector& vec1,vector& vec2,int length,int N) { - if(length>N) + if(length > N) { copy(vec1.begin(),vec1.end(),vec2.begin()); return; } int i=0; - for (;i& vec1,vector& vec2,int length,int N) void Merge_Sort(vector& vec) { vector vec_cp(vec.size(),0); - int length=1; - int N=vec.size(); - while (length vec_in; - cin>>n; + cin >> n; for (int i=0;i>a; + cin >> a; vec_in.push_back(a); } + Merge_Sort(vec_in); for (auto it=vec_in.begin();it!=vec_in.end();it++) { - cout<<*it< - - - - - - - - - diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.lastbuildstate b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.lastbuildstate deleted file mode 100644 index bb2a86e..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.lastbuildstate +++ /dev/null @@ -1,2 +0,0 @@ -#v4.0:v100 -Debug|Win32|C:\Users\xcg\Desktop\Program_Practice\sort_algorithm\merge_sort\| diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.log b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.log deleted file mode 100644 index d795c1e..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.log +++ /dev/null @@ -1,20 +0,0 @@ -锘跨敓鎴愬惎鍔ㄦ椂闂翠负 2018/6/10 16:12:14銆 - 1>椤圭洰鈥淐:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\merge_sort\merge_sort.vcxproj鈥濆湪鑺傜偣 2 涓(build 涓洰鏍)銆 - 1>InitializeBuildStatus: - 姝ｅ湪鍒涘缓鈥淒ebug\merge_sort_recursion.unsuccessfulbuild鈥濓紝鍥犱负宸叉寚瀹氣淎lwaysCreate鈥濄 - ClCompile: - I:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\CL.exe /c /ZI /nologo /W3 /WX- /Od /Oy- /D _MBCS /Gm /EHsc /RTC1 /MDd /GS /fp:precise /Zc:wchar_t /Zc:forScope /Fo"Debug\\" /Fd"Debug\vc100.pdb" /Gd /TP /analyze- /errorReport:prompt main.cpp - main.cpp - Link: - I:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\link.exe /ERRORREPORT:PROMPT /OUT:"C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\Debug\merge_sort_recursion.exe" /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /ManifestFile:"Debug\merge_sort_recursion.exe.intermediate.manifest" /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /DEBUG /PDB:"C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\Debug\merge_sort_recursion.pdb" /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\Debug\merge_sort_recursion.lib" /MACHINE:X86 Debug\main.obj - merge_sort.vcxproj -> C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\Debug\merge_sort_recursion.exe - Manifest: - C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin\mt.exe /nologo /verbose /outputresource:"C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\Debug\merge_sort_recursion.exe;#1" /manifest Debug\merge_sort_recursion.exe.intermediate.manifest - FinalizeBuildStatus: - 姝ｅ湪鍒犻櫎鏂囦欢鈥淒ebug\merge_sort_recursion.unsuccessfulbuild鈥濄 - 姝ｅ湪瀵光淒ebug\merge_sort_recursion.lastbuildstate鈥濇墽琛 Touch 浠诲姟銆 - 1>宸插畬鎴愮敓鎴愰」鐩淐:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\merge_sort\merge_sort.vcxproj鈥(build 涓洰鏍)鐨勬搷浣溿 - -鐢熸垚鎴愬姛銆 - -宸茬敤鏃堕棿 00:00:01.46 diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.vcxprojResolveAssemblyReference.cache b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.vcxprojResolveAssemblyReference.cache deleted file mode 100644 index bde9b77..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.vcxprojResolveAssemblyReference.cache and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.write.1.tlog b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort.write.1.tlog deleted file mode 100644 index e69de29..0000000 diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.exe.intermediate.manifest b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.exe.intermediate.manifest deleted file mode 100644 index ecea6f7..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.exe.intermediate.manifest +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - - - - - diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.lastbuildstate b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.lastbuildstate deleted file mode 100644 index 65cef56..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.lastbuildstate +++ /dev/null @@ -1,2 +0,0 @@ -#v4.0:v100 -Debug|Win32|C:\Users\xcg\Desktop\Code_Pra\Algorithm\search_and_sort_algorithm\merge_sort_recursion\| diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.write.1.tlog b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/merge_sort_recursion.write.1.tlog deleted file mode 100644 index e69de29..0000000 diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.command.1.tlog b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.command.1.tlog deleted file mode 100644 index 4b8281a..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.command.1.tlog and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.read.1.tlog b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.read.1.tlog deleted file mode 100644 index faa1bac..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.read.1.tlog and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.write.1.tlog b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.write.1.tlog deleted file mode 100644 index 85490bc..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/mt.write.1.tlog and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.idb b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.idb deleted file mode 100644 index 49eb834..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.idb and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.pdb b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.pdb deleted file mode 100644 index e4aee49..0000000 Binary files a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/Debug/vc100.pdb and /dev/null differ diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/main.cpp b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/main.cpp index af35849..ad515c4 100644 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/main.cpp +++ b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/main.cpp @@ -6,11 +6,11 @@ using namespace std; void Merge(vector& vec1,int b,int m,int e); void MergeSort(vector& vec,int l,int r) { - if(l& vec,int l,int r) void Merge(vector& vec1,int b,int m,int e) { - int n1=m-b+1; - int n2=e-m; - vector vec_l(vec1.begin()+b,vec1.begin()+m+1); - vector vec_r(vec1.begin()+m+1,vec1.end()); + int n1 = m - b + 1; + int n2 = e - m; + vector vec_l(vec1.begin() + b,vec1.begin() + m + 1); + vector vec_r(vec1.begin() + m + 1,vec1.end()); int i,j,a; for (i=0,j=0,a=b;i num; - while (cin>>n) + while (cin >> n) { for (int i=0;i>tmp; + cin >> tmp; num.push_back(tmp); } - int len=num.size(); + + int len = num.size(); MergeSort(num,0,len-1); for (int i=0;i - - - - Debug - Win32 - - - Release - Win32 - - - - {F3580C0F-B182-4EC5-942B-26CB5C217B05} - merge_sort - merge_sort_recursion - - - - Application - true - MultiByte - - - Application - false - true - MultiByte - - - - - - - - - - - - - - - Level3 - Disabled - - - true - - - - - Level3 - MaxSpeed - true - true - - - true - true - true - - - - - - - - - \ No newline at end of file diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.filters b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.filters deleted file mode 100644 index 63d98f2..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.filters +++ /dev/null @@ -1,22 +0,0 @@ -锘 - - - - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} - cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx - - - {93995380-89BD-4b04-88EB-625FBE52EBFB} - h;hpp;hxx;hm;inl;inc;xsd - - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - - - 婧愭枃浠 - - - \ No newline at end of file diff --git a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.user b/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.user deleted file mode 100644 index ace9a86..0000000 --- a/Algorithm/search_and_sort_algorithm/merge_sort_recursion/merge_sort/merge_sort.vcxproj.user +++ /dev/null @@ -1,3 +0,0 @@ -锘 - - \ No newline at end of file diff --git a/Algorithm/search_and_sort_algorithm/quick_sort/quick_sort/main.cpp b/Algorithm/search_and_sort_algorithm/quick_sort/quick_sort/main.cpp index fd8beeb..a7ee1df 100644 --- a/Algorithm/search_and_sort_algorithm/quick_sort/quick_sort/main.cpp +++ b/Algorithm/search_and_sort_algorithm/quick_sort/quick_sort/main.cpp @@ -25,32 +25,36 @@ pair patition_divide(vector& v,int l,int r) b--; //替换代替交换，优化不必要的交换 v[a]=v[b]; - //swap(v[a],v[b]); while(a=v[a]) a++; v[b]=v[a]; - //swap(v[a],v[b]); } - v[a]=c;*/ - //浙大公开课方法 - //特殊情况：当所有元素全部相等时，low和high指针会停下来互相交换元素，可以保证每次patition分到比较中间的位置，使得整体复杂度NlogN - /*int low=a+1; - int high=b; + v[a]=c; + */ + + //分段第一种方法：双指针（来自浙大公开课），分为两段：<= pivot , > pivot + //特殊情况处理：当所有元素全部相等时，low和high指针会停下来互相交换元素，可以保证每次patition分到比较中间的位置，使得整体复杂度NlogN + /* + int low = a+1; + int high = b; for(;;) { - while(v[low]c) + while(v[high] > c) high--; - if(low + // + //分段第二种方法：荷兰国旗问题，分为三段 < pivot, = pivot, > pivot。（当数组存在多个重复元素是，可以降低时间复杂度） int less = l - 1; int cur = l; int more = r; @@ -82,6 +86,8 @@ void Quick_Sort(vector& vc,int l,int r) Quick_Sort(vc,pr.second+1,r); } + +/********测试主函数*********/ int main() { vector vec; @@ -92,20 +98,20 @@ int main() for (int i=0;i>a; + input >> a; vec.push_back(a); } - int len=vec.size(); + int len = vec.size(); Quick_Sort(vec,0,len-1); for (int i=0;i nums[l]`锛屽垯鍦ㄥ乏鍗婃鎼滅储锛 +1. 濡傛灉`nums[m] < nums[r]`锛屽垯鍦ㄥ彸鍗婃鎼滅储锛 +2. 濡傛灉`nums[m] > nums[r]`锛屽垯鍦ㄥ乏鍗婃鎼滅储锛 鐩村埌l鍜宺鐩搁偦锛岃繑鍥瀈nums[r]` @@ -122,23 +124,21 @@ class Solution: class Solution { public: int findMin(vector& nums) { - int len = nums.size(); - if(len == 0) return -1; - int l = 0,r = len-1; - if(nums[l] < nums[r]) return nums[l]; - while(nums[l] > nums[r]) - { - if(r - l == 1) - { - return nums[r]; - } - - int m = l + (r - l)/2; - if(nums[m] > nums[r]) l = m; - else r = m; + if (nums.empty()) throw "nums is empty"; + int len = nums.size(); + if (nums[0] < nums[len - 1]) { + return nums.front(); + } + int l = 0, r = len - 1; + while (l < r) { + int m = (l + r) / 2; + if (nums[m] > nums[r]) { + l = m + 1; + } else { + r = m; } - - return nums[0]; + } + return nums[r]; } }; ``` @@ -180,7 +180,7 @@ public: ### 瑙ｇ瓟 -鎬濊矾鍜 [瀵绘壘鏃嬭浆鎺掑簭鏁扮粍涓殑鏈灏忓糫(#瀵绘壘鏃嬭浆鎺掑簭鏁扮粍涓殑鏈灏忓) 涓鏍,浣嗘槸鐢变簬鏁扮粍瀛樺湪閲嶅鍏冪礌锛屼細褰卞搷浜屽垎鏌ユ壘鐨勬晥鏋滐紝瑕佺壒娈婂鐞嗚繖绉嶆儏鍐碉紝褰揱nums[m] == num[l] && nums[m] == nums[r]`鏃讹紝浜屽垎鏌ユ壘閫鍖栦负閬嶅巻鏁扮粍鏌ユ壘銆 +鎬濊矾鍜 [瀵绘壘鏃嬭浆鎺掑簭鏁扮粍涓殑鏈灏忓糫(#瀵绘壘鏃嬭浆鎺掑簭鏁扮粍涓殑鏈灏忓) 涓鏍,浣嗘槸鐢变簬鏁扮粍瀛樺湪閲嶅鍏冪礌锛屼細褰卞搷浜屽垎鏌ユ壘鐨勬晥鏋滐紝瑕佺壒娈婂鐞嗚繖绉嶆儏鍐碉紝褰揱nums[m] == num[r]`鏃讹紝r宸︾Щ鐩村埌`nums[m] != nums[r]` - 鏃堕棿澶嶆潅搴︼細O(*log n*)~O(*n*) - 绌洪棿澶嶆潅搴︼細O(1) @@ -188,40 +188,24 @@ public: ```c++ class Solution { public: - int normalSearch(vector& nums) - { - int len = nums.size(); - int res = nums[0]; - bool flag = false; - for(int i=1;i& nums) { - int len = nums.size(); - if(len == 0) return -1; - int l = 0,r = len-1; - if(nums[l] < nums[r]) return nums[l]; - while(l < r) - { - if(r - l == 1) return nums[r]; - - int m = l + (r - l)/2; - if(nums[m] == nums[l] && nums[m] == nums[r]) - { - return normalSearch(nums); - } - if(nums[m] > nums[r]) l = m; - else r = m; + if (nums.empty()) throw "nums is empty"; + int len = nums.size(); + if (nums[0] < nums[len - 1]) { + return nums.front(); + } + int l = 0, r = len - 1; + while (l < r) { + int m = (l + r) / 2; + if (nums[m] > nums[r]) { + l = m + 1; + } else if (nums[m] < nums[r]) { + r = m; + } else { + --r; } - - return nums[0]; + } + return nums[r]; } }; ``` @@ -340,30 +324,28 @@ public: class Solution { public: int search(vector& nums, int target) { - int len = nums.size(); - int l = 0,r = len-1; - while(l <= r) - { - int m = (r + l)/2; - if(nums[m] == target) - return m; - else if(nums[m] > nums[r]) - { - if(target >= nums[l] && target < nums[m]) - r = m-1; - else - l = m+1; - } - else if(nums[m] <= nums[r]) - { - if(target > nums[m] && target <= nums[r]) - l = m+1; - else - r = m-1; - } + if (nums.empty()) return -1; + int l = 0, r = nums.size() - 1; + while (l < r) { + int m = (l + r) / 2; + if (target == nums[m]) { + return m; } - - return -1; + if (nums[m] > nums[r]) { + if (target >= nums[l] && target <= nums[m]) { + r = m; + } else { + l = m + 1; + } + } else { + if (target > nums[m] && target <= nums[r]) { + l = m + 1; + } else { + r = m; + } + } + } + return target == nums[r] ? r : -1; } }; ``` @@ -412,30 +394,27 @@ public: class Solution { public: bool search(vector& nums, int target) { - int len = nums.size(); - int l = 0,r = len-1; - while(l <= r) - { - int m = (r + l)/2; - if(nums[m] == target) return true; - else if(nums[m] > nums[r])//nums[m]浣嶄簬宸﹁竟鏈夊簭娈 - { - if(target >= nums[l] && target < nums[m]) - r = m-1; - else - l = m+1; - } - else if(nums[m] < nums[r])//nums[m]浣嶄簬鍙宠竟鏈夊簭娈 - { - if(target > nums[m] && target <= nums[r]) - l = m+1; - else - r = m-1; - } - else --r; + if (nums.empty()) return false; + int l = 0, r = nums.size() - 1; + while (l < r) { + int m = (l + r) / 2; + if (nums[m] > nums[r]) { + if (target >= nums[l] && target <= nums[m]) { + r = m; + } else { + l = m + 1; + } + } else if (nums[m] < nums[r]) { + if (target > nums[m] && target <= nums[r]) { + l = m + 1; + } else { + r = m; + } + } else { + --r; } - - return false; + } + return nums[r] == target; } }; ``` @@ -664,7 +643,7 @@ public: #### 鏂规硶2锛氫簩鍒嗘煡鎵 -[鍙傝鍗氬](http://www.cnblogs.com/grandyang/p/4465932.html) +[鍙傝瑙ｆ硶涓塢(https://leetcode.cn/problems/median-of-two-sorted-arrays/solutions/8999/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-2/) - 鏃堕棿澶嶆潅搴(*log(m+n)*) - 绌洪棿澶嶆潅搴(1) @@ -672,25 +651,23 @@ public: ```c++ class Solution { public: - double recursionFind(const vector& nums1,int i,const vector& nums2,int j,int k) - { - if(i >= nums1.size()) return nums2[j + k - 1]; - if(j >= nums2.size()) return nums1[i + k - 1]; - if(k == 1) return min(nums1[i],nums2[j]); - - int val1 = ( i + k/2 - 1 < nums1.size() ) ? nums1[i + k/2 - 1] : INT_MAX; - int val2 = ( j + k/2 - 1 < nums2.size() ) ? nums2[j + k/2 - 1] : INT_MAX; - if(val1 < val2) - return recursionFind(nums1,i + k/2,nums2,j,k - k/2); - else - return recursionFind(nums1,i,nums2,j + k/2,k - k/2); + int recursion(const vector& nums1, const vector& nums2, int k, int start1, int start2) { + int len1 = nums1.size(), len2 = nums2.size(); + if (start1 >= len1) return nums2[start2 + k - 1]; + if (start2 >= len2) return nums1[start1 + k - 1]; + if (k == 1) return min(nums1[start1], nums2[start2]); + int n1 = min(start1 + k / 2 - 1, len1 - 1); + int n2 = min(start2 + k / 2 - 1, len2 - 1); + if (nums1[n1] < nums2[n2]) { + return recursion(nums1, nums2, k - (n1 - start1 + 1), n1 + 1, start2); + } else { + return recursion(nums1, nums2, k - (n2 - start2 + 1), start1, n2 + 1); + } } - double findMedianSortedArrays(vector& nums1, vector& nums2) { - int len1 = nums1.size(),len2 = nums2.size(); - int k1 = (len1 + len2 + 1)/2,k2 = (len1 + len2 + 2)/2; - - return (recursionFind(nums1,0,nums2,0,k1) + recursionFind(nums1,0,nums2,0,k2)) / 2.0; + int len1 = nums1.size(), len2 = nums2.size(); + int k1 = (len1 + len2 + 1) / 2, k2 = (len1 + len2 + 2) / 2; + return double(recursion(nums1, nums2, k1, 0, 0) + recursion(nums1, nums2, k2, 0, 0)) / 2.0; } }; ``` diff --git "a/LeetCode/\344\272\214\345\217\211\346\240\221.md" "b/LeetCode/\344\272\214\345\217\211\346\240\221.md" index e9861eb..1a11358 100644 --- "a/LeetCode/\344\272\214\345\217\211\346\240\221.md" +++ "b/LeetCode/\344\272\214\345\217\211\346\240\221.md" @@ -24,13 +24,13 @@ * [骞宠　浜屽弶鏍慮(#骞宠　浜屽弶鏍) (`easy`) * [鍏锋湁鎵鏈夋渶娣辩粨鐐圭殑鏈灏忓瓙鏍慮(#鍏锋湁鎵鏈夋渶娣辩粨鐐圭殑鏈灏忓瓙鏍) (`medium`) * [浜屽弶鏍戜腑鐨勬渶澶ц矾寰勫拰](#浜屽弶鏍戜腑鐨勬渶澶ц矾寰勫拰) (`hard` `鍔ㄦ佽鍒抈) - * [浜屽弶鏍戠殑鍚庡簭閬嶅巻](#浜屽弶鏍戠殑鍚庡簭閬嶅巻)(`hard`) + * [浜屽弶鏍戠殑鍚庡簭閬嶅巻](#浜屽弶鏍戠殑鍚庡簭閬嶅巻)(`easy`) * **鍏朵粬** * [瀵圭О浜屽弶鏍慮(#瀵圭О浜屽弶鏍) (`easy`) * [浜屽弶鏍戠殑搴忓垪鍖栦笌鍙嶅簭鍒楀寲](#浜屽弶鏍戠殑搴忓垪鍖栦笌鍙嶅簭鍒楀寲) (`hard`) - - + + # 浜屽弶鏍戞荤粨 ## 浜屽弶鏍戠殑鏈澶ф繁搴 [LeetCode涓枃](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/) @@ -45,6 +45,7 @@ **绀轰緥**锛 缁欏畾浜屽弶鏍 `[3,9,20,null,null,15,7]` + ``` 3 / \ @@ -125,6 +126,8 @@ public: 缁忚繃鏁翠釜閬嶅巻杩囩▼锛屽氨鍙互鏋勯犲嚭鍚堝苟鍚庣殑浜屽弶鏍 銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -150,6 +153,30 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode: + if t1 is None: + return t2 + if t2 is None: + return t1 + + node = TreeNode(t1.val + t2.val) + node.left = self.mergeTrees(t1.left,t2.left) + node.right = self.mergeTrees(t1.right,t2.right) + + return node +``` + ## 灏嗘湁搴忔暟缁勮浆鎹负浜屽弶鎼滅储鏍 @@ -182,7 +209,9 @@ public: 瀵规瘡涓涓瓙鏍戠粍鎴愮殑鏁扮粍锛屾湁浠ヤ笅鍑犵鎯呭喌锛 1. 鏁扮粍涓虹┖锛氬凡缁忓埌浜**绌鸿妭鐐**锛岀洿鎺ヨ繑鍥瀈nullptr`锛 -2. 鏁扮粍闈炵┖锛氭柊寤轰竴涓妭鐐逛綔涓哄綋鍓嶅瓙鏍戠殑鏍硅妭鐐癸紝瀹冪殑鍊煎彇涓烘暟缁勪腑闂翠綅缃殑鍊硷紝鐒跺悗灏嗘暟缁勫乏杈归儴鍒嗘瀯鎴愮殑瀛愭暟缁勭敤鏉ユ瀯閫犲乏瀛愭爲锛屽皢鏁扮粍鍙宠竟閮ㄥ垎鏋勬垚鐨勫瓙鏁扮粍鐢ㄦ潵鏋勯犲彸瀛愭爲銆 +2. 鏁扮粍闈炵┖锛氭柊寤轰竴涓妭鐐逛綔涓哄綋鍓嶅瓙鏍戠殑鏍硅妭鐐癸紝瀹冪殑鍊煎彇涓烘暟缁勪腑闂翠綅缃殑鍊硷紝鐒跺悗灏嗘暟缁勫乏杈归儴鍒嗘瀯鎴愮殑瀛愭暟缁勭敤鏉ユ瀯閫犲乏瀛愭爲锛屽皢鏁扮粍鍙宠竟閮ㄥ垎鏋勬垚鐨勫瓙鏁扮粍鐢ㄦ潵鏋勯犲彸瀛愭爲銆 + +**C++浠ｇ爜** ```c++ /** @@ -219,6 +248,32 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: + +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,nums: List[int],l: int,r: int) -> TreeNode: + if l > r: + return None + m = (l + r) // 2 + node = TreeNode(nums[m]) + node.left = self.recursion(nums,l,m - 1) + node.right = self.recursion(nums,m + 1,r) + return node + + def sortedArrayToBST(self, nums: List[int]) -> TreeNode: + n = len(nums) + return self.recursion(nums,0,n - 1) +``` + ## 浜屽弶鏍戠殑鎵鏈夎矾寰 @@ -252,6 +307,8 @@ public: **娉ㄦ剰**锛歚->`绗﹀彿鐨勫鐞嗐 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -305,6 +362,48 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,root: TreeNode): + if root is None: + return + + self.str = self.str + str(root.val) + + if not root.left and not root.right: + self.res.append(self.str) + self.str = self.str.rstrip(str(root.val)) + return + + self.str = self.str + "->" + + if root.left: + self.recursion(root.left) + if root.right: + self.recursion(root.right) + + self.str = self.str.rstrip("->") + self.str = self.str.rstrip(str(root.val)) + + + def binaryTreePaths(self, root: TreeNode) -> List[str]: + self.res = [] + self.str = "" + + self.recursion(root) + + return self.res +``` + ## 浜屽弶鎼滅储鏍戠殑鏈杩戝叕鍏辩鍏 @@ -349,7 +448,7 @@ public: 3. 褰撳墠`鑺傜偣鐨勫 > qv 涓 < pv`锛屽叕鍏辩鍏堝氨鏄綋鍓嶈妭鐐癸紱 4. 鍏朵粬鎯呭喌锛屽叕鍏辩鍏堝氨鍦╜p`,`q`涓や釜涔嬮棿锛屾壘鍒板拰鍏朵腑涓涓粨鐐瑰肩浉绛夌殑缁撶偣鍗冲彲銆 -鍏朵粬涓ょ鏂规硶鍙傝[**浜屽弶鏍戠殑鏈杩戝叕鍏辩鍏**](#浜屽弶鏍戠殑鏈杩戝叕鍏辩鍏) 銆 +**C++浠ｇ爜** ```c++ /** @@ -395,6 +494,37 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def findNode(self,node: TreeNode,a: int,b: int): + if not node: + return None + tmp = node.val + if tmp >= a and tmp <= b: + return node + elif tmp < a: + return self.findNode(node.right,a,b) + elif tmp > b: + return self.findNode(node.left,a,b) + + def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': + pa = min(p.val,q.val) + pb = max(p.val,q.val) + return self.findNode(root,pa,pb) + +``` + +鍏朵粬涓ょ鏂规硶鍙傝[**浜屽弶鏍戠殑鏈杩戝叕鍏辩鍏**](#浜屽弶鏍戠殑鏈杩戝叕鍏辩鍏) 銆 + ## 骞宠　浜屽弶鏍 @@ -653,11 +783,11 @@ public: 鍒嗕负浠ヤ笅鍑犱釜姝ラ锛 1. 鎵惧埌浠庢牴鍒皃鎸囧悜缁撶偣鐨勮矾寰勶紝骞跺瓨鍌ㄥ湪涓涓悜閲忔垨鏁扮粍涓紱 - -2. 鎵惧埌浠庢牴鍒皅鎸囧悜缁撶偣鐨勮矾寰勶紝骞跺瓨鍌ㄥ湪涓涓悜閲忔垨鏁扮粍涓紱 - +2. 鎵惧埌浠庢牴鍒皅鎸囧悜缁撶偣鐨勮矾寰勶紝骞跺瓨鍌ㄥ湪涓涓悜閲忔垨鏁扮粍涓紱 3. **鍚屾椂**浠庤繖涓ゆ潯璺緞璧风偣寮濮嬭蛋锛岀洿鍒**閬囧埌涓涓笉鍚岀殑鑺傜偣**锛屽垯**瀹冨墠闈㈢殑閭ｄ釜**鍗充负`p`,`q`鐨勬渶杩戝叕鍏辩鍏堛 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -710,7 +840,59 @@ private: }; ``` +**Pythono浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def findPath(self,root: TreeNode,path: List,node: TreeNode) -> bool: + if not root: + return False + if root == node: + path.append(root) + return True + + path.append(root) + l = self.findPath(root.left,path,node) + r = self.findPath(root.right,path,node) + if l or r: + return True + + path.pop() + return False + + + def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': + path_p = [] + path_q = [] + + self.findPath(root,path_p,p) + self.findPath(root,path_q,q) + + i = 0 + while i < len(path_p) and i < len(path_q): + if path_p[i] != path_q[i]: + break + i += 1 + + if i == len(path_p): + return path_p[-1] + if i == len(path_q): + return path_q[-1] + + return path_p[i - 1] +``` + + + #### 鏂规硶2 + 浠庢牴鑺傜偣寮濮嬮亶鍘嗕簩鍙夋爲锛屽浜屽弶鏍戠殑姣忎竴涓瓙鏍戯紙鍖呮嫭鏁翠釜鏍戯級锛岃瀹冪殑鏍硅妭鐐逛负`root`濡傛灉`node1`鍜宍node2`涓殑浠讳竴涓拰`root`鍖归厤锛岄偅涔坄root`灏辨槸鏈浣庡叕鍏辩鍏堛 濡傛灉閮戒笉鍖归厤锛屽垯鍒嗗埆閫掑綊宸︺佸彸瀛愭爲锛屽鏋滄湁涓涓 鑺傜偣鍑虹幇鍦ㄥ乏瀛愭爲锛屽苟涓斿彟涓涓妭鐐瑰嚭鐜板湪鍙冲瓙鏍戯紝鍒檂root`灏辨槸鏈杩戝叕鍏辩鍏. 濡傛灉涓や釜鑺傜偣閮藉嚭鐜板湪宸﹀瓙鏍戯紝鍒欒鏄庢渶浣庡叕鍏辩鍏堝湪宸﹀瓙鏍戜腑锛屽惁鍒欏湪鍙冲瓙鏍戙 鍏蜂綋杩囩▼锛氬悗搴忛亶鍘嗕簩鍙夋爲锛屽姣忎釜瀛愭爲锛屾湁浠ヤ笅鍑犵鎯呭喌锛 @@ -723,6 +905,8 @@ private: 鏈鍚庯紝褰撻亶鍘嗗畬鏁翠釜浜屽弶鏍戯紝寰楀埌鐨勫氨鏄痯,q鑺傜偣鐨勬渶杩戝叕鍏辩鍏堛 +**C++浠ｇ爜** + ```c++ /** @@ -756,6 +940,39 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,root: TreeNode,p: TreeNode,q: TreeNode) -> TreeNode: + if not root: + return None + if root == p: + return p + if root == q: + return q + l = self.recursion(root.left,p,q) + r = self.recursion(root.right,p,q) + + if not l and not r: + return None + if not l: + return r + if not r: + return l + return root + def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': + return self.recursion(root,p,q) + +``` + ## 浠庡墠搴忎笌涓簭閬嶅巻搴忓垪鏋勯犱簩鍙夋爲 @@ -790,6 +1007,8 @@ public: 鍒╃敤浜屽弶鏍戝墠搴忓拰涓簭閬嶅巻鐨勬ц川锛屽墠搴忓簭鍒楃殑绗竴涓厓绱犳槸鏍戠殑鏍圭粨鐐癸紝鑰屽浜庝腑搴忓簭鍒楋紝鍦ㄦ牴鑺傜偣宸﹀崐閮ㄥ垎鏄爲鐨勫乏瀛愭爲锛屽湪鏍硅妭鐐瑰彸鍗婇儴鍒嗘槸鏍戠殑鍙冲瓙鏍戙傚浜庝簩鍙夋爲鐨勬瘡涓瓙鏍戦兘鏈夎繖鏍风殑瑙勫緥锛岃繖寰堢鍚堥掑綊鐨勭壒鐐广傚洜姝わ紝鍦ㄩ掑綊鍑芥暟涓紝鍒╃敤杩欎竴瑙勫緥澶勭悊姣忎釜瀛愭爲銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -861,13 +1080,43 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,preorder,pre_l,pre_r,inorder,in_l,in_r): + if pre_l > pre_r: + return None + if pre_l == pre_r: + return TreeNode(preorder[pre_l]) + + root = preorder[pre_l] + node = TreeNode(root) + idx = inorder.index(root) + + node.left = self.recursion(preorder,pre_l + 1,pre_l + idx - in_l,inorder,in_l,idx - 1) + node.right = self.recursion(preorder,pre_l + idx - in_l + 1,pre_r,inorder,idx + 1,in_r) + + return node + + def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: + return self.recursion(preorder,0,len(preorder) - 1,inorder,0,len(inorder) - 1) +``` + ## 姹傛牴鍒板彾瀛愯妭鐐规暟瀛椾箣鍜 [LeetCode涓枃](https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/) -[LeetCode鑻辨枃](https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/) +[LeetCode鑻辨枃](https://leetcode.com/problems/sum-root-to-leaf-numbers/) 缁欏畾涓涓簩鍙夋爲锛屽畠鐨勬瘡涓粨鐐归兘瀛樻斁涓涓 `0-9` 鐨勬暟瀛楋紝姣忔潯浠庢牴鍒板彾瀛愯妭鐐圭殑璺緞閮戒唬琛ㄤ竴涓暟瀛椼 @@ -912,6 +1161,8 @@ public: 鏍戠殑鍓嶅簭閬嶅巻 + 瀛楃涓叉暟瀛楄浆鎹紙璇︾粏鎬濊矾鍙傝锛歔浜屽弶鏍戠殑鎵鏈夎矾寰刔(#浜屽弶鏍戠殑鎵鏈夎矾寰)锛夈 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -925,40 +1176,76 @@ public: class Solution { public: int sumNumbers(TreeNode* root) { - if(!root) return 0; - string str(""); - int sum = 0; + int sum = 0,tmp = 0; - recursion(root,sum,str); + recursion(root,sum,tmp); return sum; } - void recursion(TreeNode* root,int& sum,string& str) + void recursion(TreeNode* root,int& sum,int& tmp) { - str.push_back('0' + root->val); + if(!root) return; + + tmp = tmp * 10 + root->val; if(!root->left && !root->right) { - sum += stoi(str); - str.pop_back(); + sum += tmp; + tmp = (tmp - root->val) / 10; return; } if(root->left) { - recursion(root->left,sum,str); + recursion(root->left,sum,tmp); } if(root->right) { - recursion(root->right,sum,str); + recursion(root->right,sum,tmp); } - str.pop_back(); + tmp = (tmp - root->val) / 10; } }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,root: TreeNode): + if not root: + return + self.tmp = self.tmp * 10 + root.val + + if not root.left and not root.right: + self.res = self.res + self.tmp + self.tmp = int((self.tmp - root.val) / 10) + return + + if root.left: + self.recursion(root.left) + if root.right: + self.recursion(root.right) + + self.tmp = int((self.tmp - root.val) / 10) + + def sumNumbers(self, root: TreeNode) -> int: + self.res = 0 + self.tmp = 0 + self.recursion(root) + + return self.res +``` + ## 浜屽弶鏍戠殑灞傛閬嶅巻 @@ -994,6 +1281,8 @@ public: ### 瑙ｇ瓟 鑰冨療浜屽弶鏍戠殑灞傚簭閬嶅巻锛屽埄鐢ㄩ槦鍒楃粨鏋刞queue`瀹炵幇銆傚眰搴忛亶鍘嗙殑杩囩▼涓渶瑕佸皢姣忓眰鐨勫厓绱犲垎寮瀛樻斁锛屽畾涔変袱涓寚閽坄pre`鍜宍next`锛宍pre`鎸囧悜褰撳墠灞傜殑鏈鍚庝竴涓妭鐐癸紝`next`鎸囧悜涓嬩竴灞傜殑鏈鍚庝竴涓妭鐐癸紝褰撻亶鍘嗗埌鐨勫綋鍓嶇粨鐐筦cur == pre`鏃讹紝浠pre = next`锛宍next`涓鐩存洿鏂帮紝瀹冩寚鍚戝凡鍏ラ槦鍒楃殑鏈鍚庝竴涓妭鐐广 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1047,6 +1336,44 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def levelOrder(self, root: TreeNode) -> List[List[int]]: + if root is None: + return [] + res = [] + que = [] + vec = [] + pre = root + nex = None + que.append(root) + while len(que) > 0: + cur = que.pop(0) + vec.append(cur.val) + + if cur.left: + que.append(cur.left) + nex = cur.left + if cur.right: + que.append(cur.right) + nex = cur.right + if cur == pre: + pre = nex + res.append(vec) + vec = [] + + return res +``` + ## 浜屽弶鏍戠殑鍙宠鍥 @@ -1074,6 +1401,8 @@ public: 鏍戠殑灞傚簭閬嶅巻鐨勮繘闃讹紝閬嶅巻鏍戠殑鏃跺欒缃弻鎸囬拡锛宍pre`鎸囧悜褰撳墠灞傜殑鏈鍚庝竴涓妭鐐癸紝`next`鎸囧悜閬嶅巻鍒扮殑鏈鏂扮殑缁撶偣锛屽彇鍑烘瘡灞傛渶鍚庝竴涓粨鐐(`pre`)鐨勫煎埌缁撴灉鏁扮粍`res`銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1122,6 +1451,41 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def rightSideView(self, root: TreeNode) -> List[int]: + if root is None: + return [] + res = [] + que = [] + pre = root + nex = None + que.append(root) + while len(que) > 0: + cur = que.pop(0) + + if cur.left: + que.append(cur.left) + nex = cur.left + if cur.right: + que.append(cur.right) + nex = cur.right + if cur == pre: + pre = nex + res.append(cur.val) + + return res +``` + ## 浜屽弶鏍戠殑閿娇灞傛閬嶅巻 @@ -1156,6 +1520,8 @@ public: 浜屽弶鏍戝眰搴忛亶鍘嗙殑杩涢樁锛屽姞涓涓**鏍囧織浣**`flag`锛屾瘡涓灞傛牴鎹甡flag`鍒ゆ柇鏄惁鍙嶈浆褰撳墠灞傜殑鏁扮粍銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1217,6 +1583,50 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]: + if root is None: + return [] + res = [] + vec = [] + que = [] + + flag = True + pre = root + nex = None + que.append(root) + while len(que) > 0: + cur = que.pop(0) + vec.append(cur.val) + + if cur.left: + que.append(cur.left) + nex = cur.left + if cur.right: + que.append(cur.right) + nex = cur.right + + if cur == pre: + pre = nex + if not flag: + vec.reverse() + res.append(vec) + vec = [] + flag = not flag + + return res +``` + ## 濉厖鍚屼竴灞傜殑鍏勫紵鑺傜偣 @@ -1267,6 +1677,8 @@ struct TreeLinkNode { 鏍戠殑灞傚簭閬嶅巻缁撳悎閾捐〃鎸囬拡鎿嶄綔銆 +**C++浠ｇ爜** + ```c++ /** * Definition for binary tree with next pointer. @@ -1324,6 +1736,45 @@ public: }; ``` +**Python浠ｇ爜** + +```python +""" +# Definition for a Node. +class Node: + def __init__(self, val, left, right, next): + self.val = val + self.left = left + self.right = right + self.next = next +""" +class Solution: + def connect(self, root: 'Node') -> 'Node': + if root is None: + return None + pre = root + nex = None + que = [] + que.append(root) + while len(que) > 0: + cur = que.pop(0) + + if cur.left: + que.append(cur.left) + nex = cur.left + if cur.right: + que.append(cur.right) + nex = cur.right + + if cur == pre: + cur.next = None + pre = nex + elif len(que) > 0: + cur.next = que[0] + + return root +``` + ## 楠岃瘉浜屽弶鎼滅储鏍 @@ -1351,6 +1802,7 @@ public: ``` **绀轰緥 2**: + ``` 杈撳叆: 5 @@ -1367,6 +1819,8 @@ public: 鑰冨療浜屽弶鏍戠殑涓簭閬嶅巻鍜岄摼琛ㄧ殑鍙屾寚閽堛備腑搴忛亶鍘嗕簩鍙夋悳绱㈡爲锛岃缃甡pre`鍜宍cur`涓や釜鎸囬拡鍒嗗埆鎸囧悜鍓嶄竴涓粨鐐瑰拰鍚庝竴涓妭鐐癸紝鍦ㄤ腑搴忛亶鍘嗕簩鍙夋爲鐨勮繃绋嬩腑锛宍pre`鍜宍cur`璺熺潃鍚戝悗绉诲姩锛屼竴鏃﹀彂鐜 `pre->val >= cur->val`锛屽垯璇存槑涓嶆槸浜屽弶鎼滅储鏍戯紱鍚﹀垯锛屼究鏄簩鍙夋悳绱㈡爲銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1411,6 +1865,32 @@ private: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def isValidBST(self, root: TreeNode) -> bool: + path = [] + self.inorder(root,path) + for i in range(1,len(path)): + if path[i - 1] >= path[i]: + return False + return True + def inorder(self,root: TreeNode,path: List[int]): + if not root: + return + self.inorder(root.left,path) + path.append(root.val) + self.inorder(root.right,path) +``` + ## 璺緞鎬诲拰II @@ -1425,6 +1905,7 @@ private: **绀轰緥**: 缁欏畾濡備笅浜屽弶鏍戯紝浠ュ強鐩爣鍜 `sum = 22`锛 + ``` 5 / \ @@ -1446,6 +1927,8 @@ private: 鎵惧嚭浜屽弶鏍戠殑鎵鏈夎矾寰勶紝娌＄粡杩囦竴涓妭鐐癸紝绱姞涓娆″苟涓斿姞鍒颁复鏃舵暟缁勪腑銆傚湪姣忔潯璺緞缁撴潫鐨勬椂鍊欙紝鍒ゆ柇绱姞鐨勫兼槸鍚﹀拰鐩爣鍊肩浉绛夛紝濡傛灉鐩哥瓑锛屽垯灏嗚繖鏉¤矾寰勫搴旂殑涓存椂鏁扮粍鍔犲叆缁撴灉鏁扮粍涓紱鍚﹀垯锛岀户缁蛋鍏朵粬璺緞銆傛壘鍑烘墍鏈夎矾寰勭殑鏂规硶鍙傝 [浜屽弶鏍戠殑鎵鏈夎矾寰刔(#浜屽弶鏍戠殑鎵鏈夎矾寰) 銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1491,6 +1974,46 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,root: TreeNode,sum: int): + if not root: + return + + sum -= root.val + self.lt.append(root.val) + + if not root.left and not root.right: + if sum == 0: + self.res.append(self.lt[:]) + self.lt.pop() + return + + if root.left: + self.recursion(root.left,sum) + if root.right: + self.recursion(root.right,sum) + + self.lt.pop() + + def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]: + self.res = [] + self.lt = [] + + self.recursion(root,sum) + + return self.res +``` + ## 浜屽弶鏍戜腑鐨勬渶澶ц矾寰勫拰 @@ -1623,6 +2146,8 @@ public: ### 瑙ｇ瓟 #### 鏂规硶1锛氶掑綊 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1653,11 +2178,40 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def recursion(self,root): + if root is None: + return + self.recursion(root.left) + self.lt.append(root.val) + self.recursion(root.right) + + def inorderTraversal(self, root: TreeNode) -> List[int]: + self.lt = [] + self.recursion(root) + return self.lt +``` + + + #### 鏂规硶2锛氳凯浠ｆ硶锛堝埄鐢ㄦ爤瀹炵幇锛 + 锛1锛夋爲鍏堜竴鐩村悜宸﹁蛋鍒板彾鑺傜偣骞跺皢娌块旂殑缁撶偣鍏ユ爤 锛 锛2锛夌劧鍚庡悜鍙宠蛋涓姝ワ紝閲嶅绗竴姝ユ搷浣溿 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1695,6 +2249,33 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def inorderTraversal(self, root: TreeNode) -> List[int]: + if not root: + return [] + sta,res = [],[] + head = root + while head or len(sta) > 0: + while head: + sta.append(head) + head = head.left + head = sta.pop() + res.append(head.val) + head = head.right + return res + +``` + ## 浜屽弶鎼滅储鏍戜腑绗琄灏忕殑鍏冪礌 @@ -1705,10 +2286,12 @@ public: 缁欏畾涓涓簩鍙夋悳绱㈡爲锛岀紪鍐欎竴涓嚱鏁 `kthSmallest` 鏉ユ煡鎵惧叾涓 **k** 涓渶灏忕殑鍏冪礌銆 -**璇存槑**锛 +**璇存槑**锛 + 浣犲彲浠ュ亣璁 k 鎬绘槸鏈夋晥鐨勶紝1 鈮 k 鈮 浜屽弶鎼滅储鏍戝厓绱犱釜鏁般 **绀轰緥 1**: + ``` 杈撳叆: root = [3,1,4,null,2], k = 1 3 @@ -1740,6 +2323,8 @@ public: 涓簭閬嶅巻浜屽弶鎼滅储鏍戯紝鍦ㄩ亶鍘嗙殑杩囩▼涓紝姣忕粡杩囦竴涓妭鐐瑰皢`k`鍑1锛屽綋`k == 0`鐨勬椂鍊欙紝鍒欐壘鍒颁簡绗琸灏忕殑鍏冪礌(`娉ㄦ剰杈圭晫`)銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1778,6 +2363,42 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def kthSmallest(self, root: TreeNode, k: int) -> int: + self.k = k + self.inorder(root) + return self.res + + def inorder(self,root) -> bool: + if root is None: + return False + + if self.inorder(root.left): + return True + + self.k -= 1 + if self.k == 0: + self.res = root.val + return True + + if self.inorder(root.right): + return True + + return False + + +``` + ## 浜屽弶鏍戠殑鍓嶅簭閬嶅巻 @@ -1805,6 +2426,8 @@ public: ### 瑙ｇ瓟 #### 鏂规硶1锛氶掑綊 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1834,9 +2457,38 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + res = [] + self.preOrder(root,res) + return res + + def preOrder(self,root,lt: List[int]): + if root is None: + return + + lt.append(root.val) + + self.preOrder(root.left,lt) + self.preOrder(root.right,lt) +``` + #### 鏂规硶2锛氳凯浠 + 鎬濊矾锛氬姣忎釜缁撶偣鎸夌収 **鏍->鍙->宸** 鐨勯『搴忓叆鏍堬紝鍑烘爤鐨勯『搴忓氨鏄墠搴忛亶鍘嗙殑缁撴灉銆 +**C++浠ｇ爜** + ```c++ /** * Definition for a binary tree node. @@ -1873,6 +2525,34 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + if root is None: + return [] + sta = [] + res = [] + sta.append(root) + while len(sta) > 0: + tmp = sta.pop() + res.append(tmp.val) + + if tmp.right: + sta.append(tmp.right) + if tmp.left: + sta.append(tmp.left) + return res +``` + ## 鍏锋湁鎵鏈夋渶娣辩粨鐐圭殑鏈灏忓瓙鏍 diff --git "a/LeetCode/\345\205\266\344\273\226.md" "b/LeetCode/\345\205\266\344\273\226.md" index 85814b8..210d402 100644 --- "a/LeetCode/\345\205\266\344\273\226.md" +++ "b/LeetCode/\345\205\266\344\273\226.md" @@ -1,7 +1,7 @@ * **鍏朵粬绫绘荤粨** * [Nim娓告垙](#Nim娓告垙) (`easy` `鏅哄姏棰榒) * [鍥涙暟鐩稿姞II](#鍥涙暟鐩稿姞II) (`medium` `鍝堝笇`) - * [鎵撲贡鏁扮粍](#鎵撲贡鏁扮粍) (`mqdium` `娲楃墝绠楁硶`) + * [鎵撲贡鏁扮粍](#鎵撲贡鏁扮粍) (`mdium` `娲楃墝绠楁硶`) diff --git "a/LeetCode/\345\210\206\346\262\273.md" "b/LeetCode/\345\210\206\346\262\273.md" new file mode 100644 index 0000000..5a6a8ab --- /dev/null +++ "b/LeetCode/\345\210\206\346\262\273.md" @@ -0,0 +1,115 @@ +**鍒嗘不绠楁硶** + * [涓鸿繍绠楄〃杈惧紡璁捐浼樺厛绾(#涓鸿繍绠楄〃杈惧紡璁捐浼樺厛绾) (`medium`) + * [鑷冲皯鏈塊涓噸澶嶅瓧绗︾殑鏈闀垮瓙涓瞉(#鑷冲皯鏈塊涓噸澶嶅瓧绗︾殑鏈闀垮瓙涓) (`medium` `閫掑綊`) + +# 鍒嗘不绠楁硶 + +## 鑷冲皯鏈塊涓噸澶嶅瓧绗︾殑鏈闀垮瓙涓 + +[LeetCode涓枃](https://leetcode.cn/problems/longest-substring-with-at-least-k-repeating-characters/description/) + +**瑙ｆ硶**锛氬垎娌绘濇兂锛岄掑綊瑙ｅ喅瀛愰棶棰 + +https://leetcode.cn/problems/longest-substring-with-at-least-k-repeating-characters/solutions/623432/zhi-shao-you-kge-zhong-fu-zi-fu-de-zui-c-o6ww/ + +鏃堕棿澶嶆潅搴︼細O(n * 26) + +```c++ +class Solution { +public: + int longestSubstring(string s, int k) { + return dfs(s, 0, s.size() - 1, k); + } + int dfs(const string& s, int l, int r, int k) { + if (r - l + 1 < k) return 0; + vector mp(26, 0); + for (int i = l; i <= r; ++i) { + ++mp[s[i] - 'a']; + } + char ch = 0; + for (int i = 0; i < 26; ++i) { + if (mp[i] > 0 && mp[i] < k) { + ch = 'a' + i; + break; + } + } + if (ch == 0) { + return r - l + 1; + } + while (l <= r && s[l] == ch) { + ++l; + } + int idx = l; + int res = 0; + while (idx <= r) { + if (s[idx] == ch) { + res = max(res, dfs(s, l, idx - 1, k)); + while (idx <= r && s[idx] == ch) { + ++idx; + } + l = idx; + } else { + if (idx == r) { + res = max(res, dfs(s, l, idx, k)); + } + ++idx; + } + } + return res; + } +}; +``` + + +## 涓鸿繍绠楄〃杈惧紡璁捐浼樺厛绾 + +[LeetCode涓枃](https://leetcode.cn/problems/different-ways-to-add-parentheses/description/) + +瑙ｆ硶锛氬垎娌伙紝瀛愰棶棰樻槸 `num1 op num2` + +**鏂规硶1: 閫掑綊** + +```c++ +class Solution { +public: + vector diffWaysToCompute(string expression) { + return recursive(expression, 0, expression.size() - 1); + } + vector recursive(const string& exp, int l, int r) { + vector res; + if (r - l <= 1) { + if (res.empty()) { + int i = l; + int tmp = 0; + while (i <= r) { + tmp = tmp * 10 + (exp[i] - '0'); + ++i; + } + res.push_back(tmp); + } + return res; + } + for (int i = l; i <= r; ++i) { + char op = exp[i]; + if (op == '+' || op == '-' || op == '*') { + const vector& left = recursive(exp, l, i - 1); + const vector& right = recursive(exp, i + 1, r); + for (const int a : left) { + for (const int b : right) { + int val; + if (op == '+') { + val = a + b; + } else if (op == '-') { + val = a - b; + } else { + val = a * b; + } + res.push_back(val); + } + } + } + } + return res; + } +}; +``` diff --git "a/LeetCode/\345\211\215\347\274\200\345\222\214.md" "b/LeetCode/\345\211\215\347\274\200\345\222\214.md" new file mode 100644 index 0000000..9cac747 --- /dev/null +++ "b/LeetCode/\345\211\215\347\274\200\345\222\214.md" @@ -0,0 +1,36 @@ +* **鏁扮粍绫绘荤粨** + * [鍜屼负K鐨勫瓙鏁扮粍](#鍜屼负K鐨勫瓙鏁扮粍) + * [璺緞鎬诲拰III](https://github.com/Miller-Xie/Code/blob/master/LeetCode/%E5%9B%9E%E6%BA%AF.md#%E8%B7%AF%E5%BE%84%E6%80%BB%E5%92%8Ciii) + + +# 鏁扮粍绫绘荤粨 + +## 鍜屼负K鐨勫瓙鏁扮粍 + +[LeetCode涓枃](https://leetcode.cn/problems/subarray-sum-equals-k/description/) + +瑙ｆ硶锛氬搱甯岃〃 + 鍓嶇紑鍜 + +```c++ +class Solution { +public: + int subarraySum(vector& nums, int k) { + unordered_map mp; + mp[0] = 1; + int pre = 0; + int res = 0; + for (int i = 0; i < nums.size(); i++) { + pre += nums[i]; + if (mp.find(pre - k) != mp.end()) { + res += mp[pre - k]; + } + if (mp.find(pre) != mp.end()) { + mp[pre] += 1; + } else { + mp[pre] = 1; + } + } + return res; + } +}; +``` diff --git "a/LeetCode/\345\212\250\346\200\201\350\247\204\345\210\222.md" "b/LeetCode/\345\212\250\346\200\201\350\247\204\345\210\222.md" index e31d005..0d094b2 100644 --- "a/LeetCode/\345\212\250\346\200\201\350\247\204\345\210\222.md" +++ "b/LeetCode/\345\212\250\346\200\201\350\247\204\345\210\222.md" @@ -3,8 +3,11 @@ * [鐖ゼ姊痌(#鐖ゼ姊) (`easy`) * [涔板崠鑲＄エ鐨勬渶浣虫椂鏈篯(#涔板崠鑲＄エ鐨勬渶浣虫椂鏈) (`easy`) * [涔板崠鑲＄エ鐨勬渶浣虫椂鏈篒II](#涔板崠鑲＄エ鐨勬渶浣虫椂鏈篒II) (`hard` `鍒嗘不`) - * [鏈澶у瓙搴忓拰](#鏈澶у瓙搴忓拰) (`easy`) - * [鎵撳鍔垗](#鎵撳鍔垗) (`easy`) + * [涔板崠鑲＄エ鐨勬渶浣虫椂鏈哄惈鍐峰喕鏈焆(#涔板崠鑲＄エ鐨勬渶浣虫椂鏈哄惈鍐峰喕鏈) (`medium` `鐘舵乨p`) + * [鏈澶у瓙鏁扮粍鍜宂(#鏈澶у瓙鏁扮粍鍜) (`medium`) + * [涔樼Н鏈澶у瓙鏁扮粍](#涔樼Н鏈澶у瓙鏁扮粍) (`medium`) + * [鎵撳鍔垗](#鎵撳鍔垗) (`medium`) + * [鎵撳鍔垗III](#鎵撳鍔垗III) (`medium` `鏍戝舰鍔ㄦ佽鍒抈) * [鏈灏忚矾寰勫拰](#鏈灏忚矾寰勫拰) (`medium`) * [涓嶅悓璺緞](#涓嶅悓璺緞) (`medium`) * [涓夎褰㈡渶灏忚矾寰勫拰](#涓夎褰㈡渶灏忚矾寰勫拰) (`medium`) @@ -13,15 +16,439 @@ * [閫掑鐨勪笁鍏冨瓙搴忓垪](#閫掑鐨勪笁鍏冨瓙搴忓垪) (`medium` `璐績`) * [鏈澶ф鏂瑰舰](#鏈澶ф鏂瑰舰) (`medium`) * [鎽嗗姩搴忓垪](#鎽嗗姩搴忓垪) (`medium` `璐績`) - * [闆堕挶鍏戞崲](#闆堕挶鍏戞崲) (`medium` `鑳屽寘闂`) + * [闆堕挶鍏戞崲](#闆堕挶鍏戞崲) (`medium` `瀹屽叏鑳屽寘`) * [鏈澶у洖鏂囧瓙涓瞉(#鏈澶у洖鏂囧瓙涓) (`medium`) * [鏃犻噸澶嶅瓧绗︾殑鏈闀垮瓙涓瞉(#鏃犻噸澶嶅瓧绗︾殑鏈闀垮瓙涓) (`medium` `hash` `婊戝姩绐楀彛`) * [鎴虫皵鐞僝(#鎴虫皵鐞) (`hard`) + * [鏈闀跨瓑宸暟鍒梋(#鏈闀跨瓑宸暟鍒) (`medium`) + * [鏈闀块掑瀛愬簭鍒楃殑涓暟](#鏈闀块掑瀛愬簭鍒楃殑涓暟) (`medium`) + * [鎺ラ洦姘碷(#鎺ラ洦姘) (`hard`) + * [鍒嗗壊绛夊拰瀛愰泦](#鍒嗗壊绛夊拰瀛愰泦) (`medium` `01鑳屽寘`) + * [缂栬緫璺濈](#缂栬緫璺濈) (`medium` `dp`) + * [瀹屽叏骞虫柟鏁癩(#瀹屽叏骞虫柟鏁) (`medium` `dp` `璁板繂鍖朻) + * [鍗曡瘝鎷嗗垎](#鍗曡瘝鎷嗗垎) (`medium` `dp` `璁板繂鍖朻) + * [鏈闀挎湁鏁堟嫭鍙穄(#鏈闀挎湁鏁堟嫭鍙) (`hard` `dp`) + * [鏈鍚庝竴鍧楃煶澶寸殑閲嶉噺II](#鏈鍚庝竴鍧楃煶澶寸殑閲嶉噺II) (`medium` `01鑳屽寘`) - - - # 鍔ㄦ佽鍒掓荤粨 + +## 鏈鍚庝竴鍧楃煶澶寸殑閲嶉噺II + +[LeetCode涓枃](https://leetcode.cn/problems/last-stone-weight-ii/description/) + +鑳屽寘闂閫氱敤棰樿В锛歨ttps://leetcode.cn/problems/last-stone-weight-ii/solutions/805162/yi-pian-wen-zhang-chi-tou-bei-bao-wen-ti-5lfv + + +```c++ +class Solution { +public: + int lastStoneWeightII(vector& stones) { + int total = accumulate(stones.begin(), stones.end(), 0); + int target = total / 2; + vector dp(target + 1, 0); + int len = stones.size(); + // dp[i][j] = max(dp[i - 1][j], dp[i-1][j-v[i] + v[i]]) + // 浼樺寲鍚: dp[j] = max(dp[j], dp[j-v[i]] + v[i]) + dp[0] = 0; + for (int i = 0; i < len; i++) { + for (int j = target; j >= 1; j--) { + if (j >= stones[i]) dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]); + } + } + return total - 2 * dp[target]; + // vector> dp(len, vector(target + 1, 0)); + // for (int i = 0; i < len; i++) { + // for (int j = 1; j <= target; j++) { + // if (i == 0) { + // if (j >= stones[i]) dp[i][j] = stones[i]; + // continue; + // } + // if (j >= stones[i]) { + // dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]); + // } else { + // dp[i][j] = dp[i - 1][j]; + // } + // } + // } + // return total - 2 * dp[len - 1][target]; + } +}; +``` + + +## 鏈闀挎湁鏁堟嫭鍙 + +[LeetCode涓枃](https://leetcode.cn/problems/longest-valid-parentheses/) + +棰樿В锛氳`dp[i]`涓轰互s[i]缁撳熬鐨勫瓧绗︿覆鏈闀挎湁鏁堟嫭鍙烽暱搴 + +``` +if s[i] == '(': + dp[i] = 0 +if s[i] == ')': + if s[i - 1] == '(': + dp[i] = dp[i - 2] + 2 + else if s[i - dp[i - 1] - 1] == '(': + dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2] (闇瑕乮 - dp[i - 1] - 2 >= 0) +``` + +```c++ +class Solution { +public: + int longestValidParentheses(string s) { + int len = s.size(); + if (len < 2) return 0; + int res = 0; + vector dp(len, 0); + if (s[0] == '(' && s[1] == ')') { + dp[1] = 2; + res = 2; + } + for (int i = 2; i < len; i++) { + if (s[i] == ')') { + if (s[i - 1] == '(') { + dp[i] = dp[i - 2] + 2; + } else { + int pre = i - dp[i - 1] - 1; + if (pre >= 0 && s[pre] == '(') { + dp[i] = dp[i - 1] + 2; + if (pre >= 1) { + dp[i] = dp[pre - 1] + dp[i]; + } + } + } + } + res = max(res, dp[i]); + } + return res; + } +}; +``` + +## 涔樼Н鏈澶у瓙鏁扮粍 + +[LeetCode涓枃](https://leetcode.cn/problems/maximum-product-subarray/description/) + +棰樿В锛氬姩鎬佽鍒 + +璁句互nums[i]缁撳熬鐨勫瓙鏁扮粍鏈澶т箻绉槸dp[i][0]锛屾渶灏忎箻绉槸dp[i][1]锛屽姩鎬佽浆绉绘柟绋嬪涓嬶細 + +``` +if nums[i] >= 0: + dp[i][0] = max(dp[i][0] * nums[i], nums[i]) + dp[i][1] = min(dp[i][1] * nums[i], nums[i]) + +if nums[i] < 0: + dp[i][0] = max(dp[i][1] * nums[i], nums[i]) + dp[i][1] = min(dp[i][0] * nums[i], nums[i]) +``` + +**娉ㄦ剰**: nums[i] < 0鐨勬椂鍊欙紝鐘舵佽浆绉荤殑杩囩▼涓渶灏忓煎拰鏈澶у煎洖浜ゆ浛浣跨敤锛岄渶瑕佺敤tmp鏆傚瓨鏌愪竴涓奸槻姝㈣瑕嗙洊 + +```c++ +class Solution { +public: + int maxProduct(vector& nums) { + int len = nums.size(); + if (len == 0) return 0; + int imax = nums[0], imin = nums[0]; + int res = imax; + for (int i = 1; i < len; i++) { + if (nums[i] >= 0) { + imax = max(imax * nums[i], nums[i]); + imin = min(imin * nums[i], nums[i]); + } else { + int tmp = imax; + imax = max(imin * nums[i], nums[i]); + imin = min(tmp * nums[i], nums[i]); + } + res = max(imax, res); + } + return res; + } +}; +``` + +## 鍗曡瘝鎷嗗垎 + +[LeetCode涓枃](https://leetcode.cn/problems/word-break/) + +瑙ｇ瓟锛氬姩鎬佽鍒 + 璁板繂鍖 + +鐢ㄤ竴涓猻et璁板綍鎵鏈夌殑鍗曡瘝 + +璁綿p[i]浠ｈ〃0锝瀒鐨勫瓧涓茶兘鍚﹁瀛楀吀涓殑鍗曡瘝鎷兼帴 + +dp[i] = dp[j] 涓 鍗曡瘝s.substr(j + 1, i - j)鍦╯et涓, 0 <= j < i + + +```c++ +class Solution { +public: + bool wordBreak(string s, vector& wordDict) { + unordered_set st; + for (const auto& a : wordDict) { + st.insert(a); + } + int len = s.size(); + vector dp(len + 1, false); + dp[0] = true; + for (int i = 1; i <= len; ++i) { + for (int j = 0; j <= i - 1; ++j) { + if (dp[j] && st.find(s.substr(j, i - j)) != st.end()) { + dp[i] = true; + break; + } + } + } + return dp[len]; + } +}; +``` + +## 瀹屽叏骞虫柟鏁 + +[LeetCode涓枃](https://leetcode.cn/problems/perfect-squares/description/) + +瑙ｆ硶锛氬姩鎬佽鍒 + 璁板繂鍖 + +鍏堢敤bool鏁扮粍flag璁板綍1锝瀗鑼冨洿鍐呯殑鏁板瓧鏄惁涓哄畬鍏ㄥ钩鏂规暟 + +璁綿p[i]浠ｈ〃鍜屼负鏁板瓧i鐨勫畬鍏ㄥ钩鏂规暟鐨勬渶灏忔暟閲 + +濡傛灉flag[i] = true, dp[i] = 1 +鍚﹀垯锛宒p[i] = min(dp[i - j * j] + 1, j * j <= i) + +```c++ +class Solution { +public: + int numSquares(int n) { + if (n <= 1) return n; + vector flag(n + 1, false); + for (int i = 1; i * i <= n; i++) { + flag[i * i] = true; + } + vector dp(n + 1, INT_MAX); + dp[0] = 0; + dp[1] = 1; + for (int i = 2; i <= n; i++) { + if (flag[i]) { + dp[i] = 1; + continue; + } + for (int j = 1; j * j <= i; j++) { + if (dp[i - j * j] != INT_MAX) { + dp[i] = min(dp[i], dp[i - j * j] + 1); + } + } + } + return dp[n]; + } +}; +``` + +## 缂栬緫璺濈 + +[LeetCode涓枃](https://leetcode.cn/problems/edit-distance/) + +瑙ｆ硶锛氬姩鎬佽鍒 + +https://leetcode.cn/problems/edit-distance/solutions/6455/zi-di-xiang-shang-he-zi-ding-xiang-xia-by-powcai-3/ + +```c++ +class Solution { +public: + int minDistance(string word1, string word2) { + if (word1.empty()) return word2.size(); + if (word2.empty()) return word1.size(); + int len1 = word1.size(), len2 = word2.size(); + vector> dp(len1, vector(len2)); + bool flag = false; + for (int j = 0; j < len2; j++) { + if (word2[j] == word1[0]) flag = true; + if (flag) dp[0][j] = j; + else dp[0][j] = j + 1; + } + flag = false; + for (int i = 0; i < len1; ++i) { + if (word1[i] == word2[0]) flag = true; + if (flag) dp[i][0] = i; + else dp[i][0] = i + 1; + } + for (int i = 1; i < len1; i++) { + for (int j = 1; j < len2; j++) { + if (word1[i] == word2[j]) { + dp[i][j] = dp[i - 1][j - 1]; + } else { + dp[i][j] = min(min(dp[i - 1][j - 1], dp[i - 1][j]), dp[i][j - 1]) + 1; + } + } + } + return dp[len1 - 1][len2 - 1]; + } +}; +``` + +## 鎵撳鍔垗III + +[LeetCode涓枃](https://leetcode.cn/problems/house-robber-iii/solutions/47828/san-chong-fang-fa-jie-jue-shu-xing-dong-tai-gui-hu/) + +瑙ｆ硶锛氭爲褰㈠姩鎬佽鍒 + 璁板繂鍖 + 閫掑綊 + +```c++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + int rob(TreeNode* root) { + return max(pickRecursive(root), unpickRecursive(root)); + } + int pickRecursive(TreeNode* root) { + if (!root) return 0; + if (pick_mp.find(root) != pick_mp.end()) { + return pick_mp[root]; + } + int res = root->val + unpickRecursive(root->left) + unpickRecursive(root->right); + pick_mp[root] = res; + return res; + } + int unpickRecursive(TreeNode* root) { + if (!root) return 0; + if (unpicked_mp.find(root) != unpicked_mp.end()) { + return unpicked_mp[root]; + } + int res = max(pickRecursive(root->left), unpickRecursive(root->left)) + max(pickRecursive(root->right), unpickRecursive(root->right)); + unpicked_mp[root] = res; + return res; + } + +private: + unordered_map pick_mp; + unordered_map unpicked_mp; +}; +``` + +## 涔板崠鑲＄エ鐨勬渶浣虫椂鏈哄惈鍐峰喕鏈 + +[LeetCode涓枃](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/) + +棰樿В锛氬悓涓澶╃殑鑲＄エ鎯呭喌鍒嗕笁绉嶏細 +* dp[i][0]: 浠婂ぉ涓嶆寔鏈夛紝娌℃湁鍗栧嚭 +* dp[i][1]: 浠婂ぉ涓嶆寔鏈夛紝涓斿崠鍑 +* dp[i][2]: 浠婂ぉ鎸佹湁(1. 浠婂ぉ涔板叆 2. 浠婂ぉ娌′拱鍏ワ紝涔嬪墠灏辨寔鏈) + +鍔ㄦ佽浆绉绘柟绋嬶細 + +``` +dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]); +dp[i][1] = dp[i - 1][2] + prices[i]; +dp[i][2] = max(dp[i - 1][0] - prices[i], dp[i - 1][2]); +``` + +```c++ +class Solution { +public: + int maxProfit(vector& prices) { + if (prices.empty()) return 0; + int n = prices.size(); + vector> dp(n, vector(3)); + dp[0][0] = 0; // 浠婂ぉ涓嶆寔鏈夛紝娌℃湁鍗栧嚭 + dp[0][1] = 0; // 浠婂ぉ涓嶆寔鏈夛紝涓斿崠鍑 + dp[0][2] = -1 * prices[0]; // 浠婂ぉ鎸佹湁(1. 浠婂ぉ涔板叆 2. 浠婂ぉ娌′拱鍏ワ紝涔嬪墠灏辨寔鏈) + for (int i = 1; i < n; ++i) { + dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]); + dp[i][1] = dp[i - 1][2] + prices[i]; + dp[i][2] = max(dp[i - 1][0] - prices[i], dp[i - 1][2]); + } + return max(dp[n - 1][0], dp[n - 1][1]); + } +}; +``` + +## 鍒嗗壊绛夊拰瀛愰泦 + +[LeetCode涓枃](https://leetcode.cn/problems/partition-equal-subset-sum/description/) + +瑙ｆ硶锛01鑳屽寘闂 +棰樻剰绛変环浜庝粠鏁扮粍涓壘鍑轰竴浜涙暟瀛楃殑鍜岀瓑浜庢暟缁勪腑鎵鏈夋暟瀛椾箣鍜岀殑涓鍗婏紝璁句负target +璁綿p[i][j]鏄粠[0, i]涓夋暟瀛椾箣鍜屾槸鍚﹁兘缁勬垚j(bool绫诲瀷)锛岀姸鎬佽浆绉绘柟绋嬶細 + +dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]] (nums[i) < j) +dp[i][j] = true (nums[i] == j) +dp[i][j] = dp[i - 1][j] (nums[i) > j) + +鍒濆鏉′欢: +dp[i][0] = true (i = 0 ~ nums.size() - 1) +dp[nums[0]][0] = true + +**鎵╁睍**锛氭洿澶氳儗鍖呴棶棰樺弬鑰 [鑳屽寘涔濊](https://zhuanlan.zhihu.com/p/139368825) + +浜岀淮鏁扮粍浠ｇ爜锛 +```c++ +class Solution { +public: + bool canPartition(vector& nums) { + if (nums.size() == 0) return true; + if (nums.size() == 1) return false; + int sum = accumulate(nums.begin(), nums.end(), 0); + if (sum % 2 == 1) return false; + int target = sum / 2; + int len = nums.size(); + vector> dp(len, vector(target + 1, false)); + for (int i = 0; i < len; ++i) { + dp[i][0] = true; + } + if (nums[0] < target) dp[0][nums[0]] = true; + for (int i = 1; i < len; ++i) { + for (int j = 1; j <= target; ++j) { + if (j == nums[i]) dp[i][j] = true; + else if (j > nums[i]) { + dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]; + } else { + dp[i][j] = dp[i - 1][j]; + } + } + } + return dp[len - 1][target]; + } +}; +``` + +鏃堕棿鍜岀┖闂翠紭鍖栧悗锛屼竴缁存暟缁勪唬鐮侊細 + +```c++ +class Solution { +public: + bool canPartition(vector& nums) { + if (nums.size() == 0) return true; + if (nums.size() == 1) return false; + int sum = accumulate(nums.begin(), nums.end(), 0); + if (sum % 2 == 1) return false; + int target = sum / 2; + if (*max_element(nums.begin(), nums.end()) > target) return false; + int len = nums.size(); + vector dp(target + 1, false); + if (nums[0] < target) dp[nums[0]] = true; + dp[0] = true; + for (int i = 1; i < len; ++i) { + for (int j = target; j >= 0; --j) { + if (nums[i] <= j) dp[j] = dp[j] || dp[j - nums[i]]; + } + } + return dp[target]; + } +}; +``` + ## 鐖ゼ姊 [LeetCode涓枃](https://leetcode-cn.com/problems/climbing-stairs) @@ -95,6 +522,7 @@ class Solution: 娉ㄦ剰浣犱笉鑳藉湪涔板叆鑲＄エ鍓嶅崠鍑鸿偂绁ㄣ **绀轰緥 1**: + ``` 杈撳叆: [7,1,5,3,6,4] 杈撳嚭: 5 @@ -102,6 +530,7 @@ class Solution: 娉ㄦ剰鍒╂鼎涓嶈兘鏄 7-1 = 6, 鍥犱负鍗栧嚭浠锋牸闇瑕佸ぇ浜庝拱鍏ヤ环鏍笺 ``` **绀轰緥 2**: + ``` 杈撳叆: [7,6,4,3,1] 杈撳嚭: 0 @@ -125,7 +554,7 @@ public: for(int i=1;i& prices) { if(prices.empty()) return 0; - int len = prices.size(); int maxp = 0; int minp = prices[0]; for(int i=1;i maxp) - { - maxp = prices[i] - minp; - } - else if(prices[i] < minp) - { - minp = prices[i]; - } - + int tmp = prices[i] - minp; + maxp = max(tmp,maxp); + minp = min(prices[i],minp); } + return maxp; } }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def maxProfit(self, prices: List[int]) -> int: + if len(prices) == 0: + return 0 + minp = prices[0] + maxp = 0 + for i in range(1,len(prices)): + tmp = prices[i] - minp + maxp = max(tmp,maxp) + minp = min(prices[i],minp) + return maxp +``` -## 鏈澶у瓙搴忓拰 + +## 鏈澶у瓙鏁扮粍鍜 [LeetCode涓枃](https://leetcode-cn.com/problems/maximum-subarray) @@ -377,7 +816,7 @@ class Solution: 鍔ㄦ佽浆绉绘柟绋嬶細 ``` -dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + dp[i-1][j-1]) +dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i-1][j-1]) ``` 璁句簩缁寸煩闃电殑琛屾暟涓篳h`锛屽垪鏁颁负`l`锛屽垯`dp[h - 1][l - 1]`鍗充负鎵姹傘 @@ -388,11 +827,6 @@ dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + dp[i-1][j-1]) ```c++ class Solution { public: - int getMin(int a,int b) - { - return a < b ? a : b; - } - int minPathSum(vector>& grid) { int h = grid.size(); int l = grid[0].size(); @@ -413,7 +847,7 @@ public: { for(int j=1;j nums[j]} -dp2[i] = max{dp1[j]+1 , 0 =< j <= i-1 涓 nums[i] > nums[j]} +dp2[i] = max{dp1[j]+1 , 0 =< j <= i-1 涓 nums[i] < nums[j]} ``` 閬嶅巻缁撴潫涔嬪悗锛屾暣涓暟缁勭殑鏈闀挎憜鍔ㄥ瓙搴忓垪灏辨槸`max(dp1.back(),dp2.back())`銆 @@ -1910,3 +2344,106 @@ public: }; ``` + + +## 鏈闀跨瓑宸暟鍒 + +[LeetCode涓枃](https://leetcode-cn.com/problems/longest-arithmetic-sequence/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/longest-arithmetic-sequence/) + +### 瑙ｇ瓟 + +**Python浠ｇ爜** + +```python +from collections import defaultdict + +class Solution: + def longestArithSeqLength(self, A: List[int]) -> int: + l = len(A) + if l <= 1: + return l + dp = [{} for _ in range(l)] + res = 2 + for i in range(1, l): + for j in range(i): + d = A[i] - A[j] + dp[i][d] = dp[j].get(d, 1) + 1 + res = max(dp[i][d], res) + return res +``` + + + +## 鏈闀块掑瀛愬簭鍒楃殑涓暟 + +[LeetCode涓枃](https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/number-of-longest-increasing-subsequence/) + + + +### 瑙ｇ瓟 + +鍔ㄦ佽鍒掞紝璁綻dp_len[i]`浠ｈ〃浠ums[i]缁撳熬鐨勬渶闀夸笂鍗囧瓙搴忓垪闀垮害锛宍dp_num[i]`浠ｈ〃浠ums[i]缁撳熬鐨勬渶闀夸笂鍗囧瓙搴忓垪鏁伴噺锛岀姸鎬佽浆绉绘柟绋嬪涓嬶細 + +``` +dp_len[i] = max{dp_len[j] + 1, j < i && nums[j] < nums[i]} +dp_num[i] = sum{dp_num[j], j < i && nums[j] < nums[i] && dp_len[j] = dp_len[i] - 1} +``` + +**Python浠ｇ爜** + +```python +class Solution: + def findNumberOfLIS(self, nums: List[int]) -> int: + if len(nums) == 0: + return 0 + dp_len, dp_num = [1] * len(nums), [1] * len(nums) + for i in range(1, len(nums)): + for j in range(i): + if nums[i] > nums[j]: + dp_len[i] = max(dp_len[j] + 1, dp_len[i]) + tmp_num = 0 + for j in range(i): + if nums[i] > nums[j] and dp_len[j] == dp_len[i] - 1: + tmp_num += dp_num[j] + dp_num[i] = max(dp_num[i], tmp_num) + max_len = max(dp_len) + return sum(x for i, x in enumerate(dp_num) if dp_len[i] == max_len) +``` + + +## 鎺ラ洦姘 + +[LeetCode涓枃](https://leetcode.cn/problems/trapping-rain-water) + + +### 瑙ｇ瓟 + +[棰樿В](https://leetcode.cn/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/) + +```c++ +class Solution { +public: + int trap(vector& height) { + if (height.size() < 3) return 0; + int len = height.size(); + vector left_max(len),right_max(len); + for (int i = 1; i < len; ++i) { + left_max[i] = max(height[i - 1], left_max[i - 1]); + } + for (int j = len -2; j >= 0; --j) { + right_max[j] = max(right_max[j + 1], height[j + 1]); + } + int res = 0; + for (int i = 1; i < height.size() - 1; ++i) { + int a = min(left_max[i], right_max[i]); + if (a > height[i]) res += a - height[i]; + } + return res; + } +}; +``` + diff --git "a/LeetCode/\345\215\225\350\260\203\346\240\210.md" "b/LeetCode/\345\215\225\350\260\203\346\240\210.md" new file mode 100644 index 0000000..84d654b --- /dev/null +++ "b/LeetCode/\345\215\225\350\260\203\346\240\210.md" @@ -0,0 +1,78 @@ +* **鍗曡皟鏍堟荤粨** + * [姣忔棩娓╁害](#姣忔棩娓╁害) (`medium`) + * [鏌辩姸鍥句腑鏈澶х殑鐭╁舰](#鏌辩姸鍥句腑鏈澶х殑鐭╁舰) (`hard`) + * [鍘婚櫎閲嶅瀛楁瘝](https://github.com/Miller-Xie/Code/blob/master/LeetCode/%E8%B4%AA%E5%BF%83.md#%E5%8E%BB%E9%99%A4%E9%87%8D%E5%A4%8D%E5%AD%97%E6%AF%8D) (`hard` `璐績`) + + +# 鍗曡皟鏍堟荤粨 + +## 姣忔棩娓╁害 + +[LeetCode涓枃](https://leetcode.cn/problems/daily-temperatures/) + +瑙ｆ硶: 鏈鍩烘湰鐨勫崟璋冩爤瀹炵幇 + +```c++ +class Solution { +public: + vector dailyTemperatures(const vector& temperatures) { + stack> sta; + int n = temperatures.size(); + vector res(n, 0); + for (int i = n - 1; i >= 0; --i) { + int cur = temperatures[i]; + while (!sta.empty() && cur >= sta.top().second) { + sta.pop(); + } + if (sta.empty()) res[i] = 0; + else res[i] = sta.top().first - i; + sta.push({i, cur}); + } + return res; + } +}; +``` + +## 鏌辩姸鍥句腑鏈澶х殑鐭╁舰 + +[LeetCode涓枃](https://leetcode.cn/problems/largest-rectangle-in-histogram/) + +瑙ｆ硶锛氬埄鐢ㄥ崟璋冩爤锛屾眰鍑哄乏杈瑰拰鍙宠竟鏈鍚庝竴涓>=褰撳墠鍏冪礌鐨勪綅缃紝鐒跺悗閲嶆柊閬嶅巻鐨勬椂鍊欙紝璁＄畻姣忎釜鍏冪礌褰㈡垚鐨勬渶澶у法鏄熼潰绉 + +```c++ +class Solution { +public: + int largestRectangleArea(vector& heights) { + stack sta, sta1; + int len = heights.size(); + vector left_mp(len), right_mp(len); + for (int i = 0; i < len; ++i) { + while (!sta.empty() && heights[i] <= heights[sta.top()]) { + sta.pop(); + } + if (sta.empty()) { + left_mp[i] = 0; + } else { + left_mp[i] = sta.top() + 1; + } + sta.push(i); + } + for (int i = len - 1; i >= 0; --i) { + while (!sta1.empty() && heights[i] <= heights[sta1.top()]) { + sta1.pop(); + } + if (sta1.empty()) { + right_mp[i] = len - 1; + } else { + right_mp[i] = sta1.top() - 1; + } + sta1.push(i); + } + int res = 0; + for (int i = 0; i < len; ++i) { + res = max(res, (right_mp[i] - left_mp[i] + 1) * heights[i]); + } + return res; + } +}; +``` diff --git "a/LeetCode/\345\215\225\350\260\203\351\230\237\345\210\227.md" "b/LeetCode/\345\215\225\350\260\203\351\230\237\345\210\227.md" new file mode 100644 index 0000000..3f379cf --- /dev/null +++ "b/LeetCode/\345\215\225\350\260\203\351\230\237\345\210\227.md" @@ -0,0 +1,40 @@ +* **鍗曡皟闃熷垪** + * [婊戝姩绐楀彛鏈澶у糫(#婊戝姩绐楀彛鏈澶у) (`hard` `婊戝姩绐楀彛`) + +# 鍗曡皟闃熷垪鎬荤粨 + +## 婊戝姩绐楀彛鏈澶у + +[LeetCode涓枃](https://leetcode.cn/problems/sliding-window-maximum/description/) + +鍙傝冮瑙ｏ細https://leetcode.cn/problems/sliding-window-maximum/solutions/2361228/239-hua-dong-chuang-kou-zui-da-zhi-dan-d-u6h0 + + +```c++ +class Solution { +public: + vector maxSlidingWindow(vector& nums, int k) { + int len = nums.size(); + deque que; + int l = 0, r = 0; + vector res; + while (r < len) { + while (!que.empty() && que.back() < nums[r]) { + que.pop_back(); + } + que.push_back(nums[r]); + r++; + while (r - l > k) { + if (nums[l] == que.front()) { + que.pop_front(); + } + l++; + } + if (r - l == k) { + res.push_back(que.front()); + } + } + return res; + } +}; +``` diff --git "a/LeetCode/\345\233\236\346\272\257.md" "b/LeetCode/\345\233\236\346\272\257.md" index bb887c8..cd3084c 100644 --- "a/LeetCode/\345\233\236\346\272\257.md" +++ "b/LeetCode/\345\233\236\346\272\257.md" @@ -4,12 +4,167 @@ * [鎷彿鐢熸垚](#鎷彿鐢熸垚) (`medium`) * [鐢佃瘽鍙风爜鐨勫瓧姣嶇粍鍚圿(#鐢佃瘽鍙风爜鐨勫瓧姣嶇粍鍚) (`medium`) * [鍏ㄦ帓鍒梋(#鍏ㄦ帓鍒) (`medium`) + * [鍏ㄦ帓鍒桰I](#鍏ㄦ帓鍒桰I) (`medium`) * [鏍奸浄缂栫爜](#鏍奸浄缂栫爜) (`medium`) * [绱姞鏁癩(#绱姞鏁) (`medium`) * [灏嗘暟缁勬媶鍒嗘垚鏂愭尝閭ｅ搴忓垪](#灏嗘暟缁勬媶鍒嗘垚鏂愭尝閭ｅ搴忓垪) (`medium` `璐績`) + * [瑙ｆ暟鐙琞(#瑙ｆ暟鐙) (`hard` `鍝堝笇`) + * [璺緞鎬诲拰III](#璺緞鎬诲拰III) (`medium` `鍥炴函` `鍝堝笇`) + * [N鐨囧悗](#n鐨囧悗) (`hard` `鍥炴函`) + * [鍒嗗壊鍥炴枃涓瞉(#鍒嗗壊鍥炴枃涓) (`medium` `dp`) + + # 鍥炴函娉曟荤粨 +## 鍏ㄦ帓鍒桰I + +[LeetCode涓枃](https://leetcode.cn/problems/permutations-ii/description/) + +璇︾粏棰樿В锛歨ttps://leetcode.cn/problems/permutations-ii/solutions/71776/hot-100-47quan-pai-lie-ii-python3-hui-su-kao-lu-zh + +鍥炴函 + 鍓灊 +image + +```c++ +class Solution { +public: + void dfs(const vector& nums, vector>& res, vector& tmp, vector& vis, int n) { + if (n >= nums.size()) { + res.push_back(tmp); + return; + } + for (int i = 0; i < nums.size(); i++) { + if (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1]) { + continue; + } + if (!vis[i]) { + tmp.push_back(nums[i]); + vis[i] = true; + dfs(nums, res, tmp, vis, n + 1); + tmp.pop_back(); + vis[i] = false; + } + } + } + vector> permuteUnique(vector& nums) { + sort(nums.begin(), nums.end()); + vector vis(nums.size(), false); + vector> res; + vector tmp; + dfs(nums, res, tmp, vis, 0); + return res; + } +}; +``` + + +## 鍒嗗壊鍥炴枃涓 + +[LeetCode涓枃](https://leetcode.cn/problems/palindrome-partitioning/) + +瑙ｆ硶锛氬洖婧 + 鍔ㄦ佽鍒 + +璁綿p[i][j]浠ｈ〃i鍒癹鐨勫瓧绗︿覆鏄惁鍥炴枃 + +d = 1, dp[i][j] = true +d =2, dp[i][j] = (s[i] == s[j]) +d > 2, dp[i][j] = dp[i + 1][j - 1] && (s[i] == s[j]) + +鐒跺悗杩涜鍥炴函锛屾瘡涓灞傞掑綊閫夋嫨涓嬩竴姝ュ垎鍓茬殑浣嶇疆锛屽埌缁撳熬鏃惰褰曞綋鍓峝fs鐨勭粨鏋 + +```c++ +class Solution { +public: + void recursion(const vector>& dp, const string& s, int start, vector>& res, vector& tmp) { + if (start >= s.size()) { + res.push_back(tmp); + return; + } + for (int i = start; i < s.size(); i++) { + if (dp[start][i]) { + tmp.push_back(s.substr(start, i - start + 1)); + recursion(dp, s, i + 1, res, tmp); + tmp.pop_back(); + } + } + } + vector> partition(string s) { + int len = s.size(); + vector> dp(len, vector(len, false)); + for (int i = 0; i < len; i++) { + dp[i][i] = true; + } + for (int d = 2; d <= len; d++) { + for (int i = 0; i + d - 1 < len; i++) { + int j = i + d - 1; + if (d == 2) dp[i][j] = s[i] == s[j]; + else { + dp[i][j] = dp[i + 1][j - 1] && (s[i] == s[j]); + } + } + } + vector> res; + vector tmp; + recursion(dp, s, 0, res, tmp); + return res; + } +}; +``` + +## N鐨囧悗 + +[LeetCode涓枃](https://leetcode.cn/problems/n-queens/) + +瑙ｆ硶锛氬洖婧 + 鐘舵佽褰 + +https://www.hello-algo.com/chapter_backtracking/n_queens_problem/ + + + +## 璺緞鎬诲拰III + +[LeetCode涓枃](https://leetcode.cn/problems/path-sum-iii/description/) + +瑙ｇ瓟锛氳蹇嗗寲鎼滅储 + 鍥炴函 +https://leetcode.cn/problems/path-sum-iii/solutions/596361/dui-qian-zhui-he-jie-fa-de-yi-dian-jie-s-dey6/ + +```c++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + int pathSum(TreeNode* root, int targetSum) { + unordered_map mp; // key: 鍓嶇紑鍜 value: 鍓嶇紑鍜岀瓑浜巏ey鐨勮妭鐐规暟閲 + long prefix_sum = 0; + return pathSumImpl(root, targetSum, mp, prefix_sum); + } + int pathSumImpl(TreeNode* root, int target, unordered_map& mp, long prefix_sum) { + if (root == nullptr) return 0; + int res = 0; + prefix_sum += root->val; + if (prefix_sum == target) res += 1; + if (mp.find(prefix_sum - target) != mp.end()) { + res += mp[prefix_sum - target]; + } + mp[prefix_sum]++; + res += pathSumImpl(root->left, target, mp, prefix_sum); + res += pathSumImpl(root->right, target, mp, prefix_sum); + mp[prefix_sum]--; + return res; + } +}; +``` + ## 瀛愰泦 [LeetCode涓枃](https://leetcode-cn.com/problems/subsets/) @@ -333,7 +488,7 @@ public: #### 鏂规硶1 -鍒╃敤鍏ㄦ帓鍒楃殑鍘熺悊锛岃`nums`澶у皬涓篳n`锛屾兂璞℃湁`n`涓┖浣嶆帓鎴愪竴鎺掞紝浠庡乏寰鍙筹紝姣忎竴娆￠兘浠庢暟缁勯夋嫨涓涓暟`nums[i]`鏀惧叆绌轰綅锛屽悗闈㈢殑绌轰綅灏变笉鑳介夋嫨`nums[i]`锛屾瘡涓涓┖浣嶉兘鏈夊绉嶉夋嫨锛岃繖鏍穈n`涓┖浣嶇殑閫夋嫨缁勫悎鍦ㄤ竴璧凤紝灏卞緱鍒颁簡鎵鏈夊彲鑳界殑鍏ㄦ帓鍒椼傝繖涓繃绋嬬敤閫掑綊鏉ュ疄鐜帮紝瀹氫箟`bool`绫诲瀷鏁扮粍`vis`鏉ヨ褰曡闂繃鐨勬暟瀛楋紝瀹氫箟鏁扮粍`res`瀛樻斁缁撴灉锛屾瘡涓姝ラ掑綊寰幆璁块棶`nums`涓墍鏈夋湭琚闂殑鍏冪礌`nums[i]`锛屽苟鍔犲叆涓存椂鏁扮粍`tmp`锛屽悓鏃跺湪`vis`涓褰(浠vis[i] = true`)锛岀劧鍚庤繘鍏ヤ笅涓灞傞掑綊銆傚畾涔夊彉閲廯idx`璁板綍閫掑綊灞備功锛岄偅涔堥掑綊缁撴潫鏉′欢鏄痐idx == nums.size()`锛屾鏃禶tmp`涓凡缁忓瓨鏀句簡鏁扮粍搴忓垪鐨勫叏鎺掑垪涔嬩竴锛屽皢`tmp`鍔犲叆缁撴灉鏁扮粍`res`锛岀劧鍚庤繑鍥炪傛渶鍚庯紝鎵鏈夐掑綊杩囩▼缁撴潫涔嬪悗锛屾暟缁刞res`灏卞瓨鏀句簡鎵鏈夌殑鍏ㄦ帓鍒椼 +鍒╃敤鍏ㄦ帓鍒楃殑鍘熺悊锛岃`nums`澶у皬涓篳n`锛屾兂璞℃湁`n`涓┖浣嶆帓鎴愪竴鎺掞紝浠庡乏寰鍙筹紝姣忎竴娆￠兘浠庢暟缁勯夋嫨涓涓暟`nums[i]`鏀惧叆绌轰綅锛屽悗闈㈢殑绌轰綅灏变笉鑳介夋嫨`nums[i]`锛屾瘡涓涓┖浣嶉兘鏈夊绉嶉夋嫨锛岃繖鏍穈n`涓┖浣嶇殑閫夋嫨缁勫悎鍦ㄤ竴璧凤紝灏卞緱鍒颁簡鎵鏈夊彲鑳界殑鍏ㄦ帓鍒椼傝繖涓繃绋嬬敤閫掑綊鏉ュ疄鐜帮紝瀹氫箟`bool`绫诲瀷鏁扮粍`vis`鏉ヨ褰曡闂繃鐨勬暟瀛楋紝瀹氫箟鏁扮粍`res`瀛樻斁缁撴灉锛屾瘡涓姝ラ掑綊寰幆璁块棶`nums`涓墍鏈夋湭琚闂殑鍏冪礌`nums[i]`锛屽苟鍔犲叆涓存椂鏁扮粍`tmp`锛屽悓鏃跺湪`vis`涓褰(浠vis[i] = true`)锛岀劧鍚庤繘鍏ヤ笅涓灞傞掑綊銆傚畾涔夊彉閲廯idx`璁板綍閫掑綊灞傛暟锛岄偅涔堥掑綊缁撴潫鏉′欢鏄痐idx == nums.size()`锛屾鏃禶tmp`涓凡缁忓瓨鏀句簡鏁扮粍搴忓垪鐨勫叏鎺掑垪涔嬩竴锛屽皢`tmp`鍔犲叆缁撴灉鏁扮粍`res`锛岀劧鍚庤繑鍥炪傛渶鍚庯紝鎵鏈夐掑綊杩囩▼缁撴潫涔嬪悗锛屾暟缁刞res`灏卞瓨鏀句簡鎵鏈夌殑鍏ㄦ帓鍒椼 * 鏃堕棿澶嶆潅搴︼細O(*n!*) * 绌洪棿澶嶆潅搴︼細O(*n*) (蹇界暐瀛樻斁缁撴灉鐨勬暟缁勫崰鐢ㄧ殑鍐呭瓨) @@ -666,7 +821,7 @@ public: -# 灏嗘暟缁勬媶鍒嗘垚鏂愭尝閭ｅ搴忓垪 +## 灏嗘暟缁勬媶鍒嗘垚鏂愭尝閭ｅ搴忓垪 [LeetCode涓枃](https://leetcode-cn.com/problems/split-array-into-fibonacci-sequence) @@ -804,3 +959,77 @@ public: ``` + +## 瑙ｆ暟鐙 + +[LeetCode涓枃](https://leetcode-cn.com/problems/sudoku-solver/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/sudoku-solver/) + + + +### 瑙ｇ瓟 + +**Python浠ｇ爜** + +```python +class Solution: + def solveSudoku(self, board: List[List[str]]) -> None: + """ + Do not return anything, modify board in-place instead. + """ + def _remove_num(val: int, i: int, j: int, block_i: int): + row_list[val][i] -= 1 + col_list[val][j] -= 1 + block_list[val][block_i] -= 1 + board[i][j] = '.' + + def _add_num(val: int, i: int, j: int, block_i: int): + row_list[val][i] += 1 + col_list[val][j] += 1 + block_list[val][block_i] += 1 + board[i][j] = str(val) + + def _place_next_num(i: int, j: int): + if i == 8 and j == 8: + return True + elif j == 8: + if _dfs(i + 1, 0): + return True + elif _dfs(i, j + 1): + return True + return False + + def _get_block(i: int, j: int): + return (i // 3) * 3 + j // 3 + + def _dfs(i: int, j: int) -> bool: + if board[i][j] != '.': + if _place_next_num(i, j): + return True + else: + for val in range(1, 10): + block_i = _get_block(i, j) + if row_list[val][i] > 0 or col_list[val][j] > 0 \ + or block_list[val][block_i] > 0: + continue + _add_num(val, i, j, block_i) + if _place_next_num(i, j): + return True + _remove_num(val, i, j, block_i) + return False + + row_list = [[0 for i in range(9)] for i in range(10)] + col_list = [[0 for i in range(9)] for i in range(10)] + block_list = [[0 for i in range(9)] for i in range(10)] + for i in range(0, 9): + for j in range(0, 9): + val = board[i][j] + if val != '.': + row_list[int(val)][i] += 1 + col_list[int(val)][j] += 1 + block_i = _get_block(i, j) + block_list[int(val)][block_i] += 1 + _dfs(0, 0) +``` + diff --git "a/LeetCode/\345\233\276.md" "b/LeetCode/\345\233\276.md" index 33ea1f6..ded6183 100644 --- "a/LeetCode/\345\233\276.md" +++ "b/LeetCode/\345\233\276.md" @@ -7,14 +7,222 @@ * [鍗曡瘝鎼滅储](#鍗曡瘝鎼滅储) (`medium`) * [鍗曡瘝鎼滅储II](#鍗曡瘝鎼滅储II) (`hard` `瀛楀吀鏍慲) * [鐭╅樀涓殑鏈闀块掑璺緞](#鐭╅樀涓殑鏈闀块掑璺緞) (`hard` `鍔ㄦ佽鍒抈) + * [浠ュ浘鍒ゆ爲](#浠ュ浘鍒ゆ爲) (`medium`) * **骞舵煡闆** * [鍐椾綑杩炴帴](#鍐椾綑杩炴帴) (`medium`) * [鏈嬪弸鍦圿(#鏈嬪弸鍦) (`medium`) - * **鍏朵粬** + * [闄ゆ硶姹傝В](#闄ゆ硶姹傝В) (`medium`) + * **鏈鐭矾寰** + * [鏈鐭矾寰.涓](#鏈鐭矾寰勪竴) (`hard` `杩澃鏂壒鎷夌畻娉昤) + * [缃戠粶寤惰繜鏃堕棿](#缃戠粶寤惰繜鏃堕棿) (`medium`) + * **鏈灏忕敓鎴愭爲** + * [鏈灏忕敓鎴愭爲涓.Prim绠楁硶](#鏈灏忕敓鎴愭爲涓prim绠楁硶) (`hard`) + * [鏈灏忕敓鎴愭爲浜.Kruscal绠楁硶](#鏈灏忕敓鎴愭爲浜宬ruscal绠楁硶) (`hard`) + * **鎷撴墤鎺掑簭** * [璇剧▼琛╙(#璇剧▼琛) (`medium` `鎷撴墤鎺掑簭`) * [璇剧▼琛↖I](#璇剧▼琛↖I) (`medium` `鎷撴墤鎺掑簭`) # 鍥炬荤粨 + +## 缃戠粶寤惰繜鏃堕棿 + +[LeetCode涓枃](https://leetcode.cn/problems/network-delay-time/description/) + +棰樿В锛歨ttps://leetcode.cn/problems/network-delay-time/solutions/910056/gong-shui-san-xie-yi-ti-wu-jie-wu-chong-oghpz + +瑙ｆ硶涓锛氭湸绱犵殑杩澃鏂壒鎷夌畻娉曪紝鏃堕棿澶嶆潅搴 `O(N^2)` + +```c++ +class Solution { +public: + int networkDelayTime(vector>& times, int n, int k) { + vector dis(n + 1, INT_MAX); + vector vis(n + 1, false); + vector> graph(n + 1, vector(n + 1, -1)); + for (auto time : times) { + graph[time[0]][time[1]] = time[2]; + } + dis[k] = 0; + int cnt = 0; + for (int p = 1; p <= n; p++) { + int tmp = -1, min_dis = INT_MAX; + for (int i = 1; i <= n; i++) { + if (!vis[i] && dis[i] < min_dis) { + min_dis = dis[i]; + tmp = i; + } + } + // tmp = -1锛岃繕娌＄粨鏉熷惊鐜紝璇存槑鏈変簺鏈闂殑鑺傜偣涓嶅彲鍒拌揪 + if (tmp < 0) return -1; + // if (tmp < 0 && p < n) return -1; + vis[tmp] = true; + bool flag = false; + for (int i = 1; i <= n; i++) { + if (!vis[i] && graph[tmp][i] >= 0) { + dis[i] = min(dis[i], dis[tmp] + graph[tmp][i]); + flag = true; + } + } + } + int res = INT_MIN; + for (int i = 1; i <= n; i++) { + res = max(dis[i], res); + } + return res; + } +}; +``` + + + +## 闄ゆ硶姹傝В + +[LeetCode涓枃](https://leetcode.cn/problems/evaluate-division/) + +**瑙ｆ硶**锛氬甫鏉冨煎苟鏌ラ泦 + 鍒嗗瓙鍒嗘瘝琛ㄨ揪寮忚浆鎹 + + +```c++ +class UnionSet { + public: + UnionSet(const set st) { + for (auto iter = st.begin(); iter != st.end(); ++iter) { + const string& str = *iter; + parent_mp_[str] = str; + weight_mp_[str] = 1.0; + size_mp_[str] = 1; + } + } + + bool IsSameSet(const string& str1, const string& str2) { + return FindRoot(str1) == FindRoot(str2); + } + + void Union(const string& str1, const string& str2, double val) { + const string& root1 = FindRoot(str1); + const string& root2 = FindRoot(str2); + double d1 = GetDivideToRoot(str1); + double d2 = GetDivideToRoot(str2); + if (size_mp_[root1] > size_mp_[root2]) { + parent_mp_[root2] = root1; + weight_mp_[root2] = d1 / d2 / val; + size_mp_[root1] = size_mp_[root1] + size_mp_[root2]; + size_mp_.erase(root2); + } else { + parent_mp_[root1] = root2; + weight_mp_[root1] = d2 / d1 * val; + size_mp_[root2] = size_mp_[root1] + size_mp_[root2]; + size_mp_.erase(root1); + } + } + + double GetRes(const string& str1, const string& str2) { + if (str1 == str2) { + return 1.0; + } + if (!IsSameSet(str1, str2)) { + return -1.0; + } + return GetDivideToRoot(str1) / GetDivideToRoot(str2); + } + + private: + // 褰撳墠鑺傜偣 -> 鐖惰妭鐐规槧灏 + unordered_map parent_mp_; + // 褰撳墠鑺傜偣 / 鐖惰妭鐐 鐨勭粨鏋 + unordered_map weight_mp_, size_mp_; + + string FindRoot(const string& str) { + if (parent_mp_[str] != str) { + return FindRoot(parent_mp_[str]); + } + return str; + } + + double GetDivideToRoot(const string& str) { + double res = 1.0; + string tmp = str; + while (parent_mp_[tmp] != tmp) { + res *= weight_mp_[tmp]; + tmp = parent_mp_[tmp]; + } + return res; + } +}; + +class Solution { +public: + vector calcEquation(vector>& equations, vector& values, vector>& queries) { + set st; + for (const auto& equation : equations) { + st.insert(equation[0]); + st.insert(equation[1]); + } + UnionSet union_set(st); + for (int i = 0; i < equations.size(); ++i) { + const string& s1 = equations[i][0]; + const string& s2 = equations[i][1]; + if (union_set.IsSameSet(s1, s2)) continue; + union_set.Union(s1, s2, values[i]); + } + vector res; + res.reserve(queries.size()); + for (const auto& query : queries) { + if (st.find(query[0]) == st.end() || st.find(query[0]) == st.end()) { + res.emplace_back(-1.0); + } else { + res.emplace_back(union_set.GetRes(query[0], query[1])); + } + } + return res; + } +}; +``` + +## 浠ュ浘鍒ゆ爲 + +[LeetCode涓枃](https://leetcode.cn/problems/graph-valid-tree/) + +**瑙ｆ硶**锛氬缓绔嬪浘鐨勬暟鎹粨鏋勶紝dfs鏁翠釜鍥撅紝骞惰褰曞凡缁忚闂繃鐨刵ode锛屽鏋滈亶鍘嗗埌鏌愪釜鑺傜偣鍙戠幇涓庝粬鐩歌繛鐨勮妭鐐规暟澶т簬1涓旈兘璁块棶杩囷紝璇存槑鍥句腑瀛樺湪鐜紱鍙﹀杩樻湁涓绉嶇壒娈婃儏鍐佃冭檻锛屾墍鏈夌殑鑺傜偣鏋勬垚浜嗗涓殧绂荤殑鐜紝杩欑鎯呭喌閬嶅巻涓娆＄殑鑺傜偣鏁颁笉绛変簬鎬荤粨鐐规暟 + +```c++ +class Solution { +public: + bool validTree(int n, vector>& edges) { + if (n < 1) return true; + vector visited(n ,false); + vector> graph(n, vector()); + for (const auto edge : edges) { + graph[edge[0]].push_back(edge[1]); + graph[edge[1]].push_back(edge[0]); + } + int cnt = 0; + visited[0] = true; + return recursive(graph, visited, 0, cnt) && cnt == n; + } + + bool recursive(const vector>& graph, vector& visited, int n, int& cnt) { + bool flag = false; + ++cnt; + for (const int a : graph[n]) { + if (!visited[a]) { + visited[a] = true; + if (!recursive(graph, visited, a, cnt)) { + return false; + } + visited[a] = false; + flag = true; + } + } + if (!flag && graph[n].size() > 1) { + return false; + } + return true; + } +}; +``` + + ## 璇剧▼琛 [LeetCode涓枃](https://leetcode-cn.com/problems/course-schedule/) @@ -59,42 +267,34 @@ ```c++ class Solution { public: - bool canFinish(int numCourses, vector>& prerequisites) { - vector> graph(numCourses,vector()); - vector degree(numCourses,0); - for(auto a : prerequisites) - { - int from = a.second; - int to = a.first; + bool canFinish(int numCourses, vector>& prerequisites) { + vector> graph(numCourses, vector()); + vector degree(numCourses, 0); + for (const auto& vec : prerequisites) { + int from = vec[1]; + int to = vec[0]; graph[from].push_back(to); - degree[to]++; + ++degree[to]; } - queue que; - for(int i=0;i= numCourses) return true; } - - if(cnt == numCourses) return true; - return false; } }; @@ -1119,3 +1319,457 @@ public: } }; ``` + + + +## 鏈鐭矾寰.涓 + +[hihoCoder閾炬帴](http://hihocoder.com/problemset/problem/1081) + +### 鎻忚堪 + +涓囧湥鑺傜殑鏃╀笂锛屽皬Hi鍜屽皬Ho鍦ㄧ粡鍘嗕簡涓涓皬鏃剁殑浜夎鍚庯紝缁堜簬鍐冲畾浜嗗浣曞害杩囪繖鏍锋湁鎰忎箟鐨勪竴澶┾斺斾粬浠喅瀹氬幓闂灞嬶紒 + +鍦ㄩ灞嬮棬鍙ｆ帓涓婁簡鑻ュ共灏忔椂鐨勯槦浼嶄箣鍚庯紝鍒氬垰杩涘叆楝煎眿鐨勫皬Hi鍜屽皬Ho閮介楗ラタ锛屼簬鏄粬浠喅瀹氬埄鐢ㄨ繘闂ㄥ墠棰嗗埌鐨勫湴鍥撅紝鎵惧埌涓鏉￠氬線缁堢偣鐨勬渶鐭矾寰勩 + +楝煎眿涓竴鍏辨湁N涓湴鐐癸紝鍒嗗埆缂栧彿涓1..N锛岃繖N涓湴鐐逛箣闂翠簰鐩告湁涓浜涢亾璺繛閫氾紝涓や釜鍦扮偣涔嬮棿鍙兘鏈夊鏉￠亾璺繛閫氾紝浣嗘槸骞朵笉瀛樺湪涓鏉′袱绔兘鏄悓涓涓湴鐐圭殑閬撹矾銆傞偅涔堝皬Hi鍜屽皬Ho鑷冲皯瑕佽蛋澶氬皯璺▼鎵嶈兘澶熻蛋鍑洪灞嬪幓鍚冧笢瑗垮憿锛 + +### 杈撳叆 + +姣忎釜娴嬭瘯鐐癸紙杈撳叆鏂囦欢锛夋湁涓斾粎鏈変竴缁勬祴璇曟暟鎹 + +鍦ㄤ竴缁勬祴璇曟暟鎹腑锛 + +绗1琛屼负4涓暣鏁癗銆丮銆丼銆乀锛屽垎鍒〃绀洪灞嬩腑鍦扮偣鐨勪釜鏁板拰閬撹矾鐨勬潯鏁帮紝鍏ュ彛锛堜篃鏄竴涓湴鐐癸級鐨勭紪鍙凤紝鍑哄彛锛堝悓鏍蜂篃鏄竴涓湴鐐癸級鐨勭紪鍙枫 + +鎺ヤ笅鏉ョ殑M琛岋紝姣忚鎻忚堪涓鏉￠亾璺細鍏朵腑鐨勭i琛屼负涓変釜鏁存暟u_i, v_i, length_i锛岃〃鏄庡湪缂栧彿涓簎_i鐨勫湴鐐瑰拰缂栧彿涓簐_i鐨勫湴鐐逛箣闂存湁涓鏉￠暱搴︿负length_i鐨勯亾璺 + +瀵逛簬100%鐨勬暟鎹紝婊¤冻N<=10^3锛孧<=10^4, 1 <= length_i <= 10^3, 1 <= S, T <= N, 涓擲涓嶇瓑浜嶵銆 + +瀵逛簬100%鐨勬暟鎹紝婊¤冻灏廐i鍜屽皬Ho鎬绘槸鏈夊姙娉曚粠鍏ュ彛閫氳繃鍦板浘涓婃爣娉ㄥ嚭鏉ョ殑閬撹矾鍒拌揪鍑哄彛銆 + +### 杈撳嚭 + +瀵逛簬姣忕粍娴嬭瘯鏁版嵁锛岃緭鍑轰竴涓暣鏁癆ns锛岃〃绀洪偅涔堝皬Hi鍜屽皬Ho涓轰簡璧板嚭楝煎眿鑷冲皯瑕佽蛋鐨勮矾绋嬨 + +鏍蜂緥杈撳叆 + +``` +5 23 5 4 +1 2 708 +2 3 112 +3 4 721 +4 5 339 +5 4 960 +1 5 849 +2 5 98 +1 4 99 +2 4 25 +2 1 200 +3 1 146 +3 2 106 +1 4 860 +4 1 795 +5 4 479 +5 4 280 +3 4 341 +1 4 622 +4 2 362 +2 3 415 +4 1 904 +2 1 716 +2 5 575 +``` + +鏍蜂緥杈撳嚭 + +``` +123 +``` + + + +### 瑙ｇ瓟 + +杩澃鏂壒鎷夌畻娉 + +```c++ +#include +#include +#include +#include +using namespace std; + +void Dijkstral(int src,vector& dist,vector& vis,vector>& graph) +{ + int vex = graph.size(); + while (1) + { + int idx = -1; + int dis = INT_MAX; + for (int i=0;i graph[idx][i] + dist[idx]) + dist[i] = graph[idx][i] + dist[idx]; + } + } + + + } +} + +int main() +{ + int vex,edge; + cin >> vex >> edge; + int src,dst; + cin >> src >> dst; + vector> graph(vex,vector(vex,INT_MAX)); + + while (edge--) + { + int a,b,len; + cin >> a >> b >> len; + graph[a-1][b-1] = min(graph[a-1][b-1],len); + graph[b-1][a-1] = graph[a-1][b-1]; + } + + vector dist(vex,INT_MAX); + dist[src-1] = 0; + for(int i=0;i vis(vex,false); + + Dijkstral(src,dist,vis,graph); + + cout << dist[dst-1] << endl; + + return 0; +} +``` + + + +## 鏈灏忕敓鎴愭爲涓.Prim绠楁硶 + +[hihoCoder閾炬帴](http://hihocoder.com/problemset/problem/1097?sid=1402285) + +### 鎻忚堪 + +鏈杩戯紝灏廐i寰堝枩娆㈢帺鐨勪竴娆炬父鎴忔ā鎷熷煄甯傚紑鏀惧嚭浜嗘柊Mod锛屽湪杩欎釜Mod涓紝鐜╁鍙互鎷ユ湁涓嶆涓涓煄甯備簡锛 + +浣嗘槸锛岄棶棰樹篃鎺ヨ傅鑰屾潵鈥斺斿皬Hi鐜板湪鎵嬩笂鎷ユ湁N搴у煄甯傦紝涓斿凡鐭ヨ繖N搴у煄甯備腑浠绘剰涓ゅ骇鍩庡競涔嬮棿寤洪犻亾璺墍闇瑕佺殑璐圭敤锛屽皬Hi甯屾湜鐭ラ亾锛屾渶灏戣姳璐瑰灏戝氨鍙互浣垮緱浠绘剰涓ゅ骇鍩庡競閮藉彲浠ラ氳繃鎵寤洪犵殑閬撹矾浜掔浉鍒拌揪锛堝亣璁炬湁A銆丅銆丆涓夊骇鍩庡競锛屽彧闇瑕佸湪AB涔嬮棿鍜孊C涔嬮棿寤洪犻亾璺紝閭ｄ箞AC涔嬮棿涔熸槸鍙互閫氳繃杩欎袱鏉￠亾璺繛閫氱殑锛夈 + +### 杈撳叆 + +姣忎釜娴嬭瘯鐐癸紙杈撳叆鏂囦欢锛夋湁涓斾粎鏈変竴缁勬祴璇曟暟鎹 + +鍦ㄤ竴缁勬祴璇曟暟鎹腑锛 + +绗1琛屼负1涓暣鏁癗锛岃〃绀哄皬Hi鎷ユ湁鐨勫煄甯傛暟閲忋 + +鎺ヤ笅鏉ョ殑N琛岋紝涓轰竴涓狽*N鐨勭煩闃礎锛屾弿杩颁换鎰忎袱搴у煄甯備箣闂村缓閫犻亾璺墍闇瑕佺殑璐圭敤锛屽叾涓i琛岀j涓暟涓篈ij锛岃〃绀虹i搴у煄甯傚拰绗琷搴у煄甯備箣闂村缓閫犻亾璺墍闇瑕佺殑璐圭敤銆 + +瀵逛簬100%鐨勬暟鎹紝婊¤冻N<=10^3锛屽浜庝换鎰廼锛屾弧瓒矨ii=0锛屽浜庝换鎰廼, j婊¤冻Aij=Aji, 0 +#include +#include +#include +using namespace std; + + +void Prim(vector& dist,vector>& graph,int& sum) +{ + int vex = graph.size(); + while (1) + { + int idx = -1; + int dis = INT_MAX; + for (int i=0;i graph[idx][i]) + { + dist[i] = graph[idx][i]; + } + } + } + } +} + +int main() +{ + int vex; + cin >> vex; + vector> graph(vex,vector(vex,0)); + + for(int i=0;i> a; + graph[i][j] = a; + } + + vector dist(vex,INT_MAX); + dist[0] = 0; + for(int i=1;i +#include +#include +#include +#include +using namespace std; + + +struct edge +{ + int begin; + int end; + int weight; + edge(int b,int e,int w):begin(b),end(e),weight(w){} +}; + +inline bool cmp(const edge& e1,const edge& e2) +{ + return e1.weight > e2.weight; +} + +int findRoot(int idx,const vector& path) +{ + while(path[idx] != idx) + { + idx = path[idx]; + } + + return idx; +} + +void Kruscal(vector& graph,int& sum,const int& v) +{ + int e = graph.size(); + int cnt = 0; + + //鏍规嵁鏉冨紈eight寤虹珛鏈灏忓爢,寤虹珛鍫嗘椂闂村鏉傚害O(e) + make_heap(graph.begin(),graph.end(),cmp); + vector path(v,0); + for (int i=0;i> N >> M; + vector> graph(N,vector(N,INT_MAX)); + for(int i=0;i> a >> b >> w; + graph[a-1][b-1] = min(graph[a-1][b-1],w); + } + + vector edges; + for (int i=0;i sons; + int num; + explicit TrieTreeNode(int a) : num(a) { + sons.resize(26); + for (int i = 0; i < sons.size(); ++i) { + sons[i] = nullptr; + } + } +}; + +class TrieTree { +public: + TrieTree() { + root = new TrieTreeNode(0); + } + + void AddStr(const std::string& str) { + AddStrRecursive(str, root, 0); + } + + bool Exists(const std::string& str) { + return ExistsRecursive(str, root, 0); + } + +private: + TrieTreeNode* root = nullptr; + void AddStrRecursive(const std::string& str, TrieTreeNode* node, int idx) { + if (idx == str.size()) { + ++node->num; + return; + } + int a = str[idx] - 'a'; + if (node->sons[a] == nullptr) { + node->sons[a] = new TrieTreeNode(0); + } + AddStrRecursive(str, node->sons[a], idx + 1); + } + + bool ExistsRecursive(const std::string& str, const TrieTreeNode* node, int idx) { + if (node == nullptr) { + return false; + } + if (idx == str.size()) { + if (node->num > 0) { + return true; + } else { + return false; + } + } + if (str[idx] == '.') { + for (int i = 0; i < 26; ++i) { + if (node->sons[i] != nullptr && ExistsRecursive(str, node->sons[i], idx + 1)) { + return true; + } + } + return false; + } + int a = str[idx] - 'a'; + if (node->sons[a] == nullptr) { + return false; + } + return ExistsRecursive(str, node->sons[a], idx + 1); + } +}; + +class WordDictionary { +public: + WordDictionary() { + tree_ = new TrieTree(); + } + + void addWord(string word) { + tree_->AddStr(word); + } + + bool search(string word) { + return tree_->Exists(word); + } + +private: + TrieTree* tree_; +}; + +/** + * Your WordDictionary object will be instantiated and called as such: + * WordDictionary* obj = new WordDictionary(); + * obj->addWord(word); + * bool param_2 = obj->search(word); + */ +``` + ## 瀹炵幇Trie(鍓嶇紑鏍) [LeetCode涓枃](https://leetcode-cn.com/problems/implement-trie-prefix-tree) diff --git "a/LeetCode/\345\255\227\347\254\246\344\270\262.md" "b/LeetCode/\345\255\227\347\254\246\344\270\262.md" index c39b727..8635103 100644 --- "a/LeetCode/\345\255\227\347\254\246\344\270\262.md" +++ "b/LeetCode/\345\255\227\347\254\246\344\270\262.md" @@ -13,10 +13,97 @@ * [瀛楁瘝寮備綅璇嶅垎缁刔(#瀛楁瘝寮備綅璇嶅垎缁) (`medium` `鍝堝笇`) * [瀛楃涓茬浉涔榏(#瀛楃涓茬浉涔) (`medium` `鏁板`) * [瀛楃涓茶浆鏁存暟(atoi)](#瀛楃涓茶浆鏁存暟atoi) (`medium` `鏁板`) - * [瀛楃涓茬殑鎺掑垪](#瀛楃涓茬殑鎺掑垪) (`medium` `鍝堝笇` `婊戝姩绐楀彛`) - * [鏈灏忚鐩栧瓙涓瞉(#鏈灏忚鐩栧瓙涓) (`hard` `婊戝姩绐楀彛` `鍝堝笇`) + * **婊戝姩绐楀彛** + * [瀛楃涓茬殑鎺掑垪](#瀛楃涓茬殑鎺掑垪) (`medium` `鍝堝笇`) + * [鏈灏忚鐩栧瓙涓瞉(#鏈灏忚鐩栧瓙涓) (`hard` `鍝堝笇`) + * [鎵惧埌瀛楃涓蹭腑鎵鏈夊瓧姣嶅紓浣嶈瘝](#鎵惧埌瀛楃涓蹭腑鎵鏈夊瓧姣嶅紓浣嶈瘝) (`medium` `hash`) + * [涓茶仈鎵鏈夊崟璇嶇殑瀛愪覆](#涓茶仈鎵鏈夊崟璇嶇殑瀛愪覆) (`hard` `hash`) # 瀛楃涓茬被鎬荤粨 + +## 涓茶仈鎵鏈夊崟璇嶇殑瀛愪覆 +[LeetCode涓枃](https://leetcode.cn/problems/substring-with-concatenation-of-all-words/description/) + +棰樿В锛氭粦鍔ㄧ獥鍙ｈ繘闃 +https://leetcode.cn/problems/substring-with-concatenation-of-all-words/solutions/1616997/chuan-lian-suo-you-dan-ci-de-zi-chuan-by-244a/ + +棰樿В涓殑鏃堕棿澶嶆潅搴﹀垎鏋愭湁璇紝搴旇鏄痮(n) 锛坣涓哄瓧绗︿覆s鐨勯暱搴︼級 + +```c++ +class Solution { +public: + vector findSubstring(string s, vector& words) { + if (words.empty() || s.empty()) return {}; + int d = words[0].size(), total = words.size() * d; + unordered_map need; + for (auto word : words) { + need[word]++; + } + int len = s.size(); + vector res; + int start = 0; + while (start < d) { + int l = start, r = start; + unordered_map window; + while (r < len) { + window[s.substr(r, d)]++; + r += d; + while (r - l > total) { + string w = s.substr(l, d); + window[w]--; + if (window[w] == 0) { + window.erase(w); + } + l += d; + } + if (window == need) { + res.push_back(l); + } + } + start++; + } + return res; + } +}; +}; +``` + + +## 鎵惧埌瀛楃涓蹭腑鎵鏈夊瓧姣嶅紓浣嶈瘝 +[LeetCode涓枃](https://leetcode.cn/problems/find-all-anagrams-in-a-string/description/) + +棰樿В锛氭粦鍔ㄧ獥鍙ｉ氱敤棰樿В https://leetcode.cn/problems/find-all-anagrams-in-a-string/solutions/9749/hua-dong-chuang-kou-tong-yong-si-xiang-jie-jue-zi-/ + +```c++ +class Solution { +public: + vector findAnagrams(string s, string p) { + unordered_map window, need; + for (auto ch : p) { + need[ch]++; + } + vector res; + int l = 0, r = 0; + int len = s.size(); + while (r < len) { + window[s[r++]]++; + while (r - l > p.size()) { + window[s[l]]--; + if (window[s[l]] == 0) { + window.erase(s[l]); + } + l++; + } + if (window == need) { + res.push_back(l); + } + } + return res; + } +}; +``` + + ## 鏈哄櫒鑳藉惁杩斿洖鍘熺偣 [LeetCode涓枃](https://leetcode-cn.com/problems/robot-return-to-origin) @@ -911,7 +998,7 @@ public: * 鎵鏈夎緭鍏ュ潎涓哄皬鍐欏瓧姣嶃 * 涓嶈冭檻绛旀杈撳嚭鐨勯『搴忋 -### 瑙ｇ瓟 +### 瑙ｆ硶1 鍒╃敤hash琛紝鍏蜂綋鎬濊矾锛 @@ -921,7 +1008,7 @@ public: 璁綻strs`涓瓧绗︿覆鍏冪礌鐨勫钩鍧囬暱搴k`锛宍strs`鐨勯暱搴n`锛岄偅涔 -* 鏃堕棿澶嶆潅搴︼細O(*n log k*) +* 鏃堕棿澶嶆潅搴︼細O(*n klog k*) * 绌洪棿澶嶆潅搴︼細O(*nk*) ```c++ @@ -952,6 +1039,41 @@ public: }; ``` +### 瑙ｆ硶2 + +鍥犱负瀛楁瘝閮芥槸灏忓啓瀛楁瘝锛屽彲浠ュ埄鐢ㄨ鏁版潵鎺掑簭 + +鏃堕棿澶嶆潅搴︼細O(nk) + +```c++ +class Solution { +public: + vector> groupAnagrams(vector& strs) { + unordered_map> mp; + for (string s : strs) { + mp[strSort(s)].push_back(s); + } + vector> anagrams; + for (auto p : mp) { + anagrams.push_back(p.second); + } + return anagrams; + } +private: + string strSort(string s) { + int counter[26] = {0}; + for (char c : s) { + counter[c - 'a']++; + } + string t; + for (int c = 0; c < 26; c++) { + t += string(counter[c], c + 'a'); + } + return t; + } +}; +``` + ## 瀛楃涓茬浉涔 @@ -1165,18 +1287,9 @@ public: 鎬濊矾锛氭粦鍔ㄧ獥鍙 + hash琛 -棣栧厛浣跨敤涓涓猔map`缁熻瀛楃涓瞏t`涓瘡涓瓧绗﹀嚭鐜扮殑娆℃暟锛岃瑙ｅ喅杩欎釜闂锛屽氨鏄鎵惧埌`s`鐨勫瓙涓蹭腑锛屽寘鍚墍鏈塦map`涓殑瀛楃锛屽苟涓斿瓧绗﹀嚭鐜版鏁板ぇ浜庣瓑浜庤瀛楃鍦╜map`涓鏁扮殑瀛愪覆銆傛弧瓒宠姹傜殑鏈鐭瓙涓插氨鏄瓟妗堛 - -浣跨敤涓涓彉閲廯cnt`璁板綍瀛楃涓瞏t`鐨勯暱搴︼紝杩欎釜闀垮害灏嗙敤浜庡垽鏂粦鍔ㄧ獥鍙ｄ腑鏄惁鍖呭惈鎵鏈塦t`涓殑瀛楃銆備娇鐢ㄤ竴涓彉閲廯min`琛ㄧず婊¤冻瑕佹眰鐨勫瓙涓茬殑鏈灏忛暱搴︼紝涓涓彉閲廯start`琛ㄧず璇ュ瓙涓茬殑璧峰涓嬫爣銆傛垜浠寜濡備笅鍋囪閬嶅巻s杩涜澶勭悊锛 - -1. 褰撻亣鍒颁竴涓猔t`涓殑瀛楃鏃讹紝灏嗗叾`map`涓殑璁℃暟鍑1锛堝彲鑳藉皬浜0锛屽洜涓簊涓彲鑳藉寘鍚涓繖鏍风殑瀛楃锛夛紝鍚屾椂鍒ゆ柇锛 - 1. 濡傛灉鍑1涔嬪墠璁℃暟澶т簬0锛岃鏄庤繖涓瓧绗﹀簲璇ュ惈鍏ユ粦鍔ㄧ獥鍙ｄ腑锛屾鏃禶cnt`鍑1锛 - 2. 濡傛灉鍑1涔嬪墠璁℃暟灏忎簬绛変簬0锛岃鏄庤繖涓瓧绗﹀湪s涓嚭鐜颁簡寰堝娆★紝姝ゆ椂`cnt`涓嶅彉锛 -2. 褰撻亣鍒颁竴涓笉鍦╰涓嚭鐜扮殑瀛楃鏃讹紝璺宠繃銆 - -鏄剧劧锛屽綋`cnt`涓0鏃讹紝鎴戜滑鎵惧埌浜嗕竴涓弧瓒宠姹傜殑婊戝姩绐楀彛锛岃繖涓粦鍔ㄧ獥鍙ｄ腑锛屽寘鍚簡鎵鏈塦t`涓殑瀛楃銆傚洜姝わ紝鎴戜滑姣旇緝杩欎釜婊戝姩绐楀彛鐨勯暱搴︿笌`min`鐨勫硷紝濡傛灉灏忎簬`min`锛岃鏄庢壘鍒颁簡涓涓柊鐨勬粦鍔ㄧ獥鍙ｏ紝鍥犳鏇存柊`min`鍜宍start`銆 +鐩存帴濂楃敤閫氱敤妯℃澘锛岄潪甯竐asy -鏃㈢劧褰揱cnt`涓0鏃讹紝鎵惧埌浜嗕竴涓弧瓒宠姹傜殑婊戝姩绐楀彛锛岄偅涔堜笅涓姝ヨ鎬庝箞鍋氾紵娉ㄦ剰鍒版垜浠壘鍒扮殑绗竴涓粦鍔ㄧ獥鍙ｆ槸浣嶄簬鏈宸﹁竟锛屾鏃禶map`涓竴浜涘瓧绗︾殑璁℃暟鍙兘灏忎簬0锛屽洜涓篳t`涓殑鏌愪簺瀛楃鍦ㄨ婊戝姩绐楀彛涓嚭鐜颁簡寰堝娆°傛鏃舵垜浠粠宸﹁竟寮濮嬮噴鏀惧瓧绗︼紝鐩殑鏄笇鏈涘湪鍙宠竟鑳芥壘鍒颁竴涓柊鐨勭浉鍚屽瓧绗︼紝浠庤屽緱鍒颁竴涓柊鐨勬弧瓒宠姹傜殑婊戝姩绐楀彛銆備絾鏄粠宸﹁竟寮濮嬶紝绗竴涓湪`t`涓殑瀛楃鍙兘鏄竴涓啑浣欑殑瀛楃锛堝嵆`map`涓殑璁℃暟灏忎簬0锛夛紝鍥犳閲婃斁浜嗚繖涓瓧绗﹀悗锛屾粦鍔ㄧ獥鍙ｄ腑杩樻槸鎷ユ湁婊¤冻鏉′欢鐨勫瓧绗︼紝閭ｄ箞姝ゆ椂鍥炴敹搴旇鍙鍔犲叾鍦╜map`涓殑璁℃暟锛屼絾鏄笉闇瑕佷粠鍙宠竟寮濮嬫粦鍔ㄧ獥鍙ｏ紙鍗充笉澧炲姞`cnt`锛夈傚洜姝わ紝鍙湁褰撻亣鍒颁竴涓湪`t`涓紝骞朵笖`map`涓鏁颁负0鐨勫瓧绗︼紝鎵嶉渶瑕佸皢`cnt`鍔1銆傚洜涓篳map`璁℃暟涓0璇存槑婊戝姩绐楀彛涓繖涓瓧绗︾殑鏁伴噺鈥滄伆濂解濇弧瓒宠姹傦紝鍥犳鍙互寮濮嬩粠鍙宠竟婊戝姩绐楀彛锛屼篃灏辨槸璇达紝鎴戜滑杩樺簲璇ヤ粠鍙宠竟鎵惧埌1涓繖鏍峰瓧绗︼紝浣垮緱`map`涓叾璁℃暟閫掑噺鍚庯紝鍙堝彉涓0銆 +https://leetcode.cn/problems/find-all-anagrams-in-a-string/solutions/9749/hua-dong-chuang-kou-tong-yong-si-xiang-jie-jue-zi- 璁惧瓧绗︿覆s鐨勯暱搴︿负m,瀛楃涓瞭鐨勯暱搴︿负n锛岄偅涔堬細 @@ -1186,64 +1299,28 @@ public: ```c++ class Solution { public: - string minWindow(string s, string t) { - map mp; - for(auto ch : t) - { - ++mp[ch]; + vector findAnagrams(string s, string p) { + unordered_map window, need; + for (auto ch : p) { + need[ch]++; } - - int m = s.size(); - int n = t.size(); - if(m < n) return ""; - - int cnt = n; - int start = 0,idx = 0,Min = INT_MAX,len = 0; - bool flag = false; - for(int i=0;i 0) - { - --cnt; + vector res; + int l = 0, r = 0; + int len = s.size(); + while (r < len) { + window[s[r++]]++; + while (r - l > p.size()) { + window[s[l]]--; + if (window[s[l]] == 0) { + window.erase(s[l]); } - --mp[ch]; + l++; } - - while(cnt == 0) - { - len = i-idx+1; - if(Min > len) - { - start = idx; - Min = len; - } - - char ch1 = s[idx]; - if(mp.find(ch1) != mp.end()) - { - if(mp[ch1] >= 0) - { - cnt++; - } - - mp[ch1]++; - } - - idx++; + if (window == need) { + res.push_back(l); } - } - - return Min == INT_MAX ? "" : s.substr(start,Min); + return res; } }; ``` @@ -1295,7 +1372,7 @@ public: #### 鏂规硶2 -璺冲嚭鍏ㄦ帓鍒楃殑鎬濈淮瀹氬娍锛屽彧闇瑕侀亶鍘哷s2`锛岀劧鍚庢瘡褰撻亣鍒板湪`s1`涓殑瀛楁瘝鏃讹紝浠ヨ繖涓瓧姣嶄綅缃紑濮嬩粠`s2`鎴彇涓巂s1`鍚岀瓑闀垮害鐨勫瓧绗︿覆锛屽拰`s1`姣旇緝鏄惁涓哄悓涓涓叏鎺掑垪缁勩傝屾瘮杈冧袱涓瓧绗︿覆鏄惁涓哄悓涓涓帓鍒楋紝鍙互鐢ㄥ搱甯岃〃锛岃褰曚笅涓や釜瀛楃涓蹭腑瀛楁瘝鐨勫嚭鐜版鏁扮劧鍚庨愪釜瀛楁瘝杩涜姣旇緝銆傚悓鏃跺埄鐢ㄦ粦鍔ㄧ獥鍙ｇ殑鎬濇兂锛屽湪閬嶅巻`s2`鐨勮繃绋嬩腑锛**鍔ㄦ**鍦版敼鍙樹粠`s2`鎴彇鐨勫瓧绗︿覆瀵瑰簲鐨勫搱甯岃〃`hash1`锛屾瘡閬嶅巻涓涓柊鐨勫瓧姣嶏紝灏卞湪`hash`涓皢瀹冪殑娆℃暟鍔犱竴锛岀敱浜庣獥鍙ｅぇ灏忛檺鍒朵负`s1`鐨勯暱搴︼紝閭ｄ箞姝ゆ椂绐楀彛宸︿晶鐨勫瓧姣嶅湪`hash`涓殑娆℃暟灏遍渶瑕佸噺涓锛岀劧鍚庡拰`s1`瀵瑰簲鐨勫搱甯岃〃`hash`姣旇緝锛屽鏋滅浉绛夛紝鍒欒繑鍥瀈true`锛涘惁鍒欙紝缁х画閬嶅巻涓嬩竴涓瓧姣嶃傚鏋滈亶鍘嗙粨鏉熼兘娌℃湁鍙戠幇鐩稿悓鐨勫搱甯岃〃锛岄偅涔堣繑鍥瀈false`銆 +婊戝姩涓插彛锛屽拰 [鎵惧埌瀛楃涓蹭腑鎵鏈夊瓧姣嶅紓浣嶈瘝](#鎵惧埌瀛楃涓蹭腑鎵鏈夊瓧姣嶅紓浣嶈瘝) 瑙ｆ硶瀹屽叏涓鏍 璁綻s1`鐨勯暱搴︿负*m*锛宍s2`鐨勯暱搴︿负*n* diff --git "a/LeetCode/\346\216\222\345\272\217.md" "b/LeetCode/\346\216\222\345\272\217.md" index d6aebd9..4fac337 100644 --- "a/LeetCode/\346\216\222\345\272\217.md" +++ "b/LeetCode/\346\216\222\345\272\217.md" @@ -4,9 +4,19 @@ * [鏁扮粍涓殑绗琄涓渶澶у厓绱燷(#鏁扮粍涓殑绗琄涓渶澶у厓绱) (`medium` `蹇熸帓搴廯 `鍫哷) * [鍓岾涓珮棰戝厓绱燷(#鍓岾涓珮棰戝厓绱) (`medium` `妗舵帓搴廯 `鍫哷) * [鏈澶ч棿璺漖(#鏈澶ч棿璺) (`hard` `妗舵帓搴廯) + * [鎽嗗姩鎺掑簭II](#鎽嗗姩鎺掑簭II) (`medium` `蹇熼夋嫨`) # 鎺掑簭鎬荤粨 + +## 鎽嗗姩鎺掑簭II + +[LeetCode涓枃](https://leetcode.cn/problems/wiggle-sort-ii/description/) + +**棰樿В**锛氬揩閫熼夋嫨 + 鏁扮粍鍙嶅簭绌挎彃 + +璇﹁锛歨ttps://leetcode.cn/problems/wiggle-sort-ii/solutions/45144/yi-bu-yi-bu-jiang-shi-jian-fu-za-du-cong-onlognjia/ + ## 棰滆壊鍒嗙被 [LeetCode涓枃](https://leetcode-cn.com/problems/sort-colors) @@ -286,6 +296,80 @@ public: }; ``` +#### 鏂规硶3 褰掑苟鎺掑簭闈為掑綊 + +```c++ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ + +class Solution { +public: + ListNode* mergeSort(ListNode* head) { + if (!head || !head->next) return head; + ListNode *slow = head, *fast = head; + int len = 0; + while (slow) { + slow = slow->next; + ++len; + } + slow = head; + ListNode node(0), *p = &node; + ListNode* tmp; + for (int step = 1; step <= len; step *= 2) { + slow = fast = head; + ListNode *s_end, *f_end; + p = &node; + while (slow && fast) { + fast = slow; + for (int j = 0; j < step && fast; ++j) { + fast = fast->next; + } + s_end = f_end = fast; + for (int j = 0; j < step && f_end; ++j) { + f_end = f_end->next; + } + while (slow != s_end && fast != f_end) { + if (slow->val < fast->val) { + p->next = slow; + p = p->next; + slow = slow->next; + } else { + p->next = fast; + p = p->next; + fast = fast->next; + } + } + while (slow != s_end) { + p->next = slow; + p = p->next; + slow = slow->next; + } + while (fast != f_end) { + p->next = fast; + p = p->next; + fast = fast->next; + } + p->next = f_end; + slow = f_end; + } + } + return node.next; + } + + ListNode* sortList(ListNode* head) { + return mergeSort(head); + } +}; +``` + ## 鏁扮粍涓殑绗琄涓渶澶у厓绱 diff --git "a/LeetCode/\346\225\260\347\273\204.md" "b/LeetCode/\346\225\260\347\273\204.md" index fae9e14..b5498d9 100644 --- "a/LeetCode/\346\225\260\347\273\204.md" +++ "b/LeetCode/\346\225\260\347\273\204.md" @@ -7,10 +7,12 @@ * [闄よ嚜韬互澶栨暟缁勭殑涔樼Н](#闄よ嚜韬互澶栨暟缁勭殑涔樼Н) (`medium`) * [鎼滅储浜岀淮鐭╅樀II](#鎼滅储浜岀淮鐭╅樀II) (`medium` `浜屽垎鏌ユ壘`) * **鍙屾寚閽** + * [鏈夊簭鏁扮粍鐨勫钩鏂筣(#鏈夊簭鏁扮粍鐨勫钩鏂) (`easy` `鍙屾寚閽坄 `鏁扮粍鍚堝苟`) * [绉诲姩闆禲(#绉诲姩闆) (`easy` `鍙屾寚閽坄) * [鍒ゆ柇瀛愬簭鍒梋(#鍒ゆ柇瀛愬簭鍒) (`medium` `鍙屾寚閽坄) * [鐩涙渶澶氭按鐨勫鍣╙(#鐩涙渶澶氭按鐨勫鍣) (`medium` `鍙屾寚閽坄) * [涓夋暟涔嬪拰](#涓夋暟涔嬪拰) (`medium` `鍙屾寚閽坄) + * [鍥涙暟涔嬪拰](#鍥涙暟涔嬪拰) (`medium` `鍙屾寚閽坄) * [鏈鎺ヨ繎鐨勪笁鏁颁箣鍜宂(#鏈鎺ヨ繎鐨勪笁鏁颁箣鍜) (`medium` `鍙屾寚閽坄) * [鍒犻櫎鎺掑簭鏁扮粍涓殑閲嶅椤筣(#鍒犻櫎鎺掑簭鏁扮粍涓殑閲嶅椤) (`easy` `鍙屾寚閽坄) * [鍚堝苟涓や釜鏈夊簭鏁扮粍](#鍚堝苟涓や釜鏈夊簭鏁扮粍) (`easy` `鍙屾寚閽坄) @@ -20,7 +22,11 @@ * [瀛樺湪閲嶅鍏冪礌](#瀛樺湪閲嶅鍏冪礌) (`easy` `鍝堝笇`) * [涓ゆ暟涔嬪拰](#涓ゆ暟涔嬪拰) (`easy` `鍝堝笇`) * [姹備紬鏁癩(#姹備紬鏁) (`easy` `鍝堝笇`) + * [澶氭暟鍏冪礌](#澶氭暟鍏冪礌) (`medium` `鎽╁皵鎶曠エ`) * [鏈夋晥鐨勬暟鐙琞(#鏈夋晥鐨勬暟鐙) (`medium` `鍝堝笇`) + * [鍒掑垎瀛楁瘝鍖洪棿](#鍒掑垎瀛楁瘝鍖洪棿) (`medium` `鍝堝笇`) + * **婊戝姩绐楀彛** + * [闀垮害鏈灏忕殑瀛愭暟缁刔(#闀垮害鏈灏忕殑瀛愭暟缁) (`medium`) * **鍏朵粬** * [鏉ㄨ緣涓夎](#鏉ㄨ緣涓夎) (`easy` `杩唬`) * [缂哄け鏁板瓧](#缂哄け鏁板瓧) (`easy` `浣嶈繍绠梎 `鏁板`) @@ -29,10 +35,145 @@ * [涓嬩竴涓帓鍒梋(#涓嬩竴涓帓鍒) (`medium`) * [瀵绘壘閲嶅鏁癩(#瀵绘壘閲嶅鏁) (`medium` `浜ゆ崲`) * [缂哄け鐨勭涓涓鏁癩(#缂哄け鐨勭涓涓鏁) (`hard` `浜ゆ崲`) - + * [鏁扮粍涓噸澶嶇殑鏁板瓧](#鏁扮粍涓噸澶嶇殑鏁板瓧) (`medium` `浜ゆ崲`) + # 鏁扮粍绫绘荤粨 +## 鍒掑垎瀛楁瘝鍖洪棿 + +[LeetCode涓枃](https://leetcode.cn/problems/partition-labels/description/) + +棰樿В锛歨ttps://leetcode.cn/problems/partition-labels/solutions/2884165/zui-yi-dong-bu-fu-lai-zhan-by-zealous-ho-j17e + +宸у鍦拌В娉曪紝鏃堕棿澶嶆潅搴﹀彧闇瑕 O(N) + +```c++ +class Solution { +public: + vector partitionLabels(string s) { + unordered_map mp1; + unordered_set st; + for (auto ch : s) mp1[ch]++; + vector res; + int cnt = 0; + for (int i = 0; i < s.size(); i++) { + char ch = s[i]; + mp1[ch]--; + if (mp1[ch] > 0) { + st.insert(ch); + } else { + st.erase(ch); + } + cnt++; + if (st.empty()) { + res.push_back(cnt); + cnt = 0; + } + } + return res; + } +}; +``` + + +## 鏈夊簭鏁扮粍鐨勫钩鏂 + +[LeetCode涓枃](https://leetcode.cn/problems/squares-of-a-sorted-array/description/) + +棰樿В锛氱被浼煎悎骞舵湁搴忔暟缁勶紝鍙屾寚閽 + +https://leetcode.cn/problems/squares-of-a-sorted-array/solutions/2806253/xiang-xiang-shuang-zhi-zhen-cong-da-dao-blda6 + +```c++ +class Solution { +public: + vector sortedSquares(vector& nums) { + int len = nums.size(); + vector res(len); + int l = 0, r = len - 1, p = len - 1; + while (p >= 0) { + int a = nums[l] * nums[l], b = nums[r] * nums[r]; + if (a > b) { + res[p--] = a; + l++; + } else { + res[p--] = b; + r--; + } + } + return res; + } +}; +``` + + +## 闀垮害鏈灏忕殑瀛愭暟缁 + +[LeetCode涓枃](https://leetcode.cn/problems/minimum-size-subarray-sum/description/) + +棰樿В锛氭粦鍔ㄤ覆鍙ｏ紝娉ㄦ剰杈圭晫鍊 + +```c++ +class Solution { +public: + int minSubArrayLen(int target, vector& nums) { + if (nums.empty()) return 0; + int l = 0, r = 0, tmp = 0; + int res = INT_MAX; + while (l <= r && r <= nums.size()) { + if (tmp < target) { + if (r < nums.size()) tmp += nums[r]; + r++; + continue; + } else { + res = min(res, r - l); + while (l <= r && tmp >= target) { + res = min(res, r - l); + tmp = tmp - nums[l]; + l++; + } + } + } + return res == INT_MAX ? 0 : res; + } +}; +``` + +## 鏁扮粍涓噸澶嶇殑鏁板瓧 + +[LeetCode涓枃](https://leetcode.cn/problems/find-all-duplicates-in-an-array/description/) + +棰樿В锛氶亶鍘嗘暟缁勪氦鎹 + 鏍囪閲嶅鐨勬暟瀛 + +https://leetcode.cn/problems/find-all-duplicates-in-an-array/solutions/1476879/by-ac_oier-0m3c/ + +```c++ +class Solution { +public: + vector findDuplicates(vector& nums) { + vector res; + int i = 0; + while (i < nums.size()) { + if (nums[i] == 0 || nums[i] == i + 1) { + ++i; + continue; + } + else if (nums[nums[i] - 1] == nums[i]) { + res.push_back(nums[i]); + nums[i] = 0; + ++i; + } else { + int tmp = nums[nums[i] - 1]; + nums[nums[i] - 1] = nums[i]; + nums[i] = tmp; + } + } + return res; + } +}; +``` + ## 涓や釜鏁扮粍鐨勪氦闆 [LeetCode涓枃](https://leetcode-cn.com/problems/intersection-of-two-arrays/) @@ -66,13 +207,13 @@ 灏嗘暟缁刞nums1`鐨勫厓绱犳斁鍏ヤ竴涓猔set`涓紝鐒跺悗閬嶅巻`nums2`鐨勫厓绱燻nums2[i]`锛屽垽鏂畠鏄惁鍦╜set`涓紝濡傛灉鍦╜set`涓紝鍒欒鏄庤繖涓厓绱犳槸浜ら泦鐨勯儴鍒嗭紝灏嗗畠鍔犲叆缁撴灉涓 - - 璁綻nums1`鐨勫ぇ灏忎负`m`锛屾暟缁刞nums2`鐨勫ぇ灏忎负`n` - 鏃堕棿澶嶆潅搴︼細O(*m + n*) - 绌洪棿澶嶆潅搴︼細O(*m*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -99,6 +240,22 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]: + s = set() + res = [] + for a in nums1: + s.add(a) + for a in nums2: + if a in s: + res.append(a) + s.remove(a) + return res +``` + #### 鏂规硶2锛氭帓搴 +鍙屾寚閽 鍏堝皢`nums1`鍜宍nums2`鎺掑簭(**浠庡皬鍒板ぇ鎺掑簭**)锛岀淮鎶や竴涓猔set`瀛樻斁浜ら泦鍏冪礌锛屽畾涔変袱涓寚閽坄p1`鍜宍p2`鍒嗗埆浠巂nums1`鍜宍nums2`鍑哄彂锛屽鐞嗘儏鍐靛涓嬶細 @@ -115,6 +272,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*m log m + n log n*) * 绌洪棿澶嶆潅搴︼細O(*max(m,n)*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -145,6 +304,31 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]: + nums1.sort() + nums2.sort() + i = 0 + s = set() + res = [] + i,j = 0,0 + while i < len(nums1) and j < len(nums2): + if nums1[i] == nums2[j]: + s.add(nums1[i]) + i += 1 + j += 1 + elif nums1[i] > nums2[j]: + j += 1 + else: + i += 1 + for a in s: + res.append(a) + return res +``` + #### 鏂规硶3 鐜板皢`nums1`浠庡皬鍒板ぇ鎺掑簭锛岄亶鍘嗘暟缁刞nums2`鐨勬瘡涓涓厓绱燻nums2[i]`锛屽悓鏃跺湪`nums1`涓簩鍒嗘煡鎵綻nums2[i]`锛屽鏋滆兘鎵惧埌`nums2[i]`锛屽垯灏嗗畠鍔犲叆`set`涓紱鍚﹀垯锛岃烦杩囥傛渶鍚庯紝灏哷set`涓殑鍏冪礌鏀惧叆缁撴灉鏁扮粍鍗冲彲銆 @@ -154,6 +338,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*(m + n) log m*) * 绌洪棿澶嶆潅搴︼細O(*min(m,n)*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -234,6 +420,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*m + n*) * 绌洪棿澶嶆潅搴︼細O(*max(m,n)*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -256,11 +444,34 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: + dt = {} + res = [] + for a in nums1: + if a not in dt: + dt[a] = 1 + else: + dt[a] += 1 + for b in nums2: + if b in dt and dt[b] > 0: + res.append(b) + dt[b] -= 1 + return res +``` + + + **浼樺寲绌洪棿**锛氬搱甯岃〃缁熻涓ゆ暟缁勪腑**闀垮害杈冨皬**鐨勯偅涓暟缁勭殑鍏冪礌涓暟銆 * 鏃堕棿澶嶆潅搴︼細O(*m + n*) * 绌洪棿澶嶆潅搴︼細O(*min(m,n)*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -306,6 +517,8 @@ public: - 鏃堕棿澶嶆潅搴︼細O(*m log m + n log n*) - 绌洪棿澶嶆潅搴︼細O(*max(m,n)*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -367,6 +580,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n2*) * 绌洪棿澶嶆潅搴︼細O(*n2*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -406,6 +621,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 姹備紬鏁 @@ -438,6 +659,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -460,6 +683,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + #### 鏂规硶2锛氭懇灏旀姇绁ㄦ硶 [鍙傝鍗氬](https://www.cnblogs.com/grandyang/p/4233501.html) @@ -467,6 +696,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -492,7 +723,11 @@ public: }; ``` +**Python浠ｇ爜** +```python + +``` ## 绉诲姩闆 @@ -519,7 +754,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -544,6 +781,24 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def moveZeroes(self, nums: List[int]) -> None: + """ + Do not return anything, modify nums in-place instead. + """ + slow = fast = 0 + while fast < len(nums): + if nums[fast] != 0: + nums[slow] = nums[fast] + slow += 1 + fast += 1 + for i in range(slow,len(nums)): + nums[i] = 0 +``` + ## 缂哄け鏁板瓧 @@ -578,6 +833,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -593,6 +850,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + #### 鏂规硶2锛氱瓑宸暟鍒 绛夊樊鏁板垪姹0~n鐨勫拰鍑忓幓鏁扮粍鎵鏈夊厓绱犵浉鍔犲緱鍒扮殑鍜屽嵆涓虹己澶辩殑鏁板瓧 @@ -600,6 +863,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ``` class Solution { public: @@ -612,6 +877,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 瀛樺湪閲嶅鍏冪礌 @@ -643,6 +914,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -665,6 +938,19 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def containsDuplicate(self, nums: List[int]) -> bool: + st = set() + for a in nums: + if a in st: + return True + st.add(a) + return False +``` + ## 涓ゆ暟涔嬪拰 @@ -692,6 +978,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -711,6 +999,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 鏈鎺ヨ繎鐨勪笁鏁颁箣鍜 @@ -738,6 +1032,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n2*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -785,6 +1081,40 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def threeSumClosest(self, nums: List[int], target: int) -> int: + n = len(nums) + if n < 3: + return [] + nums.sort() + res = nums[0] + nums[1] + nums[2] + for i in range(n - 2): + if i == 0 or (i > 0 and nums[i] != nums[i - 1]): + l = i + 1 + r = n - 1 + while l < r: + tmp = nums[i] + nums[l] + nums[r] + if abs(tmp - target) < abs(res - target): + res = tmp + if tmp < target: + l += 1 + elif tmp > target: + r -= 1 + else: + return tmp + while l < r and nums[l] == nums[l - 1]: + l += 1 + while l < r and nums[r - 1] == nums[r]: + r -= 1 + if r < n - 1 and nums[r] == nums[r + 1]: + r -= 1 + + return res +``` + ## 涓夋暟涔嬪拰 @@ -865,6 +1195,36 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def threeSum(self, nums: List[int]) -> List[List[int]]: + n = len(nums) + res = [] + nums.sort() + for i in range(n - 2): + if i == 0 or (i > 0 and nums[i] != nums[i - 1]): + l = i + 1 + r = n - 1 + tmp = 0 - nums[i] + while l < r: + if tmp < nums[l] + nums[r]: + r -= 1 + elif tmp > nums[l] + nums[r]: + l += 1 + else: + res.append([nums[i] , nums[l] , nums[r]]) + l += 1 + r -= 1 + while l < r and nums[l] == nums[l - 1]: + l += 1 + while l < r and nums[r] == nums[r + 1]: + r -= 1 + + return res +``` + ## 鍒犻櫎鎺掑簭鏁扮粍涓殑閲嶅椤 @@ -901,7 +1261,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -927,6 +1289,7 @@ public: + ## 鍚堝苟涓や釜鏈夊簭鏁扮粍 [LeetCode涓枃](https://leetcode-cn.com/problems/merge-sorted-array/) @@ -955,7 +1318,9 @@ nums2 = [2,5,6], n = 3 * 鏃堕棿澶嶆潅搴︼細O(*m + n*) * 绌洪棿澶嶆潅搴︼細O(*m + n*) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -983,6 +1348,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 鏃嬭浆鏁扮粍 @@ -1027,6 +1398,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1043,6 +1416,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + #### 鏂规硶2 璁炬暟缁勭殑闀垮害涓篳len`锛宍k`瀵筦len`鍙栨ā寰楀埌`k1 = k % len`锛岀劧鍚庤繘琛屽涓嬫楠わ細 @@ -1054,7 +1433,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1072,6 +1453,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 铻烘棆鐭╅樀 @@ -1114,8 +1501,12 @@ public: 3. `(x1,y1)`鍜宍(x2,y2)`鏄悓涓涓厓绱 * 鏃堕棿澶嶆潅搴︼細O(*mn*) + * 绌洪棿澶嶆潅搴︼細O(*mn*) + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1173,6 +1564,56 @@ public: }; ``` +**Python浠ｇ爜** + +```python +class Solution: + def solution(self,x1,y1,x2,y2,vec:List[int],matrix:List[List[int]]): + i = x1 + j = y1 + if x1 < x2 and y1 < y2: + while j < y2: + vec.append(matrix[i][j]) + j += 1 + while i < x2: + vec.append(matrix[i][j]) + i += 1 + while j > y1: + vec.append(matrix[i][j]) + j -= 1 + while i > x1: + vec.append(matrix[i][j]) + i -= 1 + elif x1 == x2: + while j <= y2: + vec.append(matrix[i][j]) + j += 1 + else: + while i <= x2: + vec.append(matrix[i][j]) + i += 1 + + def spiralOrder(self, matrix: List[List[int]]) -> List[int]: + if len(matrix) == 0: + return matrix + + res = list() + m = len(matrix) + n = len(matrix[0]) + x1 = 0 + y1 = 0 + x2 = m-1 + y2 = n-1 + while x1 <= x2 and y1 <= y2: + self.solution(x1,y1,x2,y2,res,matrix) + x1 += 1 + y1 += 1 + x2 -= 1 + y2 -= 1 + + return res +``` + ## 铻烘棆鐭╅樀II @@ -1181,7 +1622,7 @@ public: [LeetCode鑻辨枃](https://leetcode.com/problems/spiral-matrix-ii/) -缁欏畾涓涓鏁存暟 `n`锛岀敓鎴愪竴涓寘鍚 1 鍒 `n2` 鎵鏈夊厓绱狅紝涓斿厓绱犳寜椤烘椂閽堥『搴忚灪鏃嬫帓鍒楃殑姝ｆ柟褰㈢煩闃点 +缁欏畾涓涓鏁存暟 `n`锛岀敓鎴愪竴涓寘鍚 1 鍒 n2 鎵鏈夊厓绱狅紝涓斿厓绱犳寜椤烘椂閽堥『搴忚灪鏃嬫帓鍒楃殑姝ｆ柟褰㈢煩闃点 **绀轰緥**: @@ -1201,7 +1642,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n2*) * 绌洪棿澶嶆潅搴︼細O(*n2*) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1270,6 +1713,65 @@ private: +**Python浠ｇ爜** + +```python +class Solution: + def solution(self,x1,y1,x2,y2,matrix:List[List[int]],cnt) -> int: + i = x1 + j = y1 + if x1 < x2 and y1 < y2: + while j < y2: + matrix[i][j] = cnt + cnt += 1 + j += 1 + while i < x2: + matrix[i][j] = cnt + cnt += 1 + i += 1 + while j > y1: + matrix[i][j] = cnt + cnt += 1 + j -= 1 + while i > x1: + matrix[i][j] = cnt + cnt += 1 + i -= 1 + elif x1 == x2: + while j <= y2: + matrix[i][j] = cnt + cnt += 1 + j += 1 + else: + while i <= x2: + matrix[i][j] = cnt + cnt += 1 + i += 1 + + return cnt + + def generateMatrix(self, n: int) -> List[List[int]]: + if n == 0: + return [[]] + + cnt = 1 + res = [[0]*n for i in range(n)] + x1 = 0 + y1 = 0 + x2 = n - 1 + y2 = n - 1 + while x1 <= x2 and y1 <= y2: + cnt = self.solution(x1,y1,x2,y2,res,cnt) + x1 += 1 + y1 += 1 + x2 -= 1 + y2 -= 1 + + return res +``` + + + ## 鏃嬭浆鍥惧儚 [LeetCode涓枃](https://leetcode-cn.com/problems/rotate-image/) @@ -1327,7 +1829,9 @@ private: * 鏃堕棿澶嶆潅搴︼細O(*n2*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1382,6 +1886,19 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def rotate(self, matrix: List[List[int]]) -> None: + """ + Do not return anything, modify matrix in-place instead. + """ + matrix[:] = list(zip(*matrix[::-1])) +``` + + + ## 瀵绘壘閲嶅鏁 [LeetCode涓枃](https://leetcode-cn.com/problems/find-the-duplicate-number/) @@ -1420,7 +1937,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1446,6 +1965,29 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def findDuplicate(self, nums: List[int]) -> int: + if len(nums) <= 0: + return False + + for i in range(len(nums)): + while i != nums[i]: + m = nums[i] + if m == nums[m]: + return m + else: + a = nums[i] + nums[i] = nums[m] + nums[m] = a + + return False +``` + + + ## 闄よ嚜韬互澶栨暟缁勭殑涔樼Н [LeetCode涓枃](https://leetcode-cn.com/problems/product-of-array-except-self/) @@ -1455,6 +1997,7 @@ public: 缁欏畾闀垮害涓 `n` 鐨勬暣鏁版暟缁 `nums`锛屽叾涓 `n > 1`锛岃繑鍥炶緭鍑烘暟缁 `output` 锛屽叾涓 `output[i]` 绛変簬 `nums` 涓櫎 `nums[i]` 涔嬪鍏朵綑鍚勫厓绱犵殑涔樼Н銆 **绀轰緥**: + ``` 杈撳叆: [1,2,3,4] 杈撳嚭: [24,12,8,6] @@ -1481,6 +2024,8 @@ D[i] = D[i+1]*nums[i+1] (i = 0~len-2) * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1511,6 +2056,25 @@ public: }; ``` + + +**Python浠ｇ爜** + +```python +class Solution: + def productExceptSelf(self, nums: List[int]) -> List[int]: + n = len(nums) + nums_l,nums_r = [1 for x in range(n)],[1 for x in range(n)] + res = [] + for i in range(1,n): + nums_l[i] = nums_l[i-1] * nums[i-1] + for i in range(n - 2,-1,-1): + nums_r[i] = nums_r[i + 1] * nums[i + 1] + for i in range(n): + res.append(nums_l[i] * nums_r[i]) + return res +``` + #### 鏂规硶2锛氫紭鍖栫┖闂村鏉傚害 鍏堝皢鏁扮粍C鐨勬暟鍊艰绠楀埌杈撳嚭鏁扮粍`res`涓紝鐒跺悗瀹氫箟涓涓彉閲廯tmp`浠ｆ浛鏁扮粍D鐨勯掓帹鍏崇郴璁＄畻锛屽鏁扮粍`res`浠庡悗鍚戝墠杩涜閫掓帹璁＄畻寰楀嚭鏈缁堢粨鏋溿傚彲浠ヤ紭鍖栫┖闂村鏉傚害鍒板父鏁版椂闂淬 @@ -1518,6 +2082,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) (杈撳嚭鏁扮粍**涓嶈瑙嗕负**棰濆绌洪棿) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1545,6 +2111,25 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def productExceptSelf(self, nums: List[int]) -> List[int]: + n = len(nums) + res = [1 for x in range(n)] + for i in range(1,n): + res[i] = nums[i-1] * res[i-1] + + tmp = 1 + for i in range(n - 1,-1,-1): + res[i] *= tmp + tmp *= nums[i] + return res +``` + + + ## 鐭╅樀缃浂 [LeetCode涓枃](https://leetcode-cn.com/problems/set-matrix-zeroes) @@ -1554,6 +2139,7 @@ public: 缁欏畾涓涓 `m x n` 鐨勭煩闃碉紝濡傛灉涓涓厓绱犱负 0锛屽垯灏嗗叾鎵鍦ㄨ鍜屽垪鐨勬墍鏈夊厓绱犻兘璁句负 0銆傝浣跨敤鍘熷湴绠楁硶銆 **绀轰緥 1**: + ``` 杈撳叆: [ @@ -1570,6 +2156,7 @@ public: ``` **绀轰緥 2**: + ``` 杈撳叆: [ @@ -1597,6 +2184,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*mn*) * 绌洪棿澶嶆潅搴︼細O(*m + n*) + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1630,6 +2220,35 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def setZeroes(self, matrix: List[List[int]]) -> None: + """ + Do not return anything, modify matrix in-place instead. + """ + dt_h,dt_l = dict(),dict() + m,n = len(matrix),len(matrix[0]) + for i in range(m): + dt_h[i] = False + for i in range(n): + dt_l[i] = False + for i in range(m): + for j in range(n): + if matrix[i][j] == 0: + dt_h[i] = True + dt_l[j] = True + + for i in range(m): + for j in range(n): + if dt_h[i] or dt_l[j]: + matrix[i][j] = 0 + +``` + + + ## 鐩涙渶澶氭按鐨勫鍣 [LeetCode涓枃](https://leetcode-cn.com/problems/container-with-most-water) @@ -1661,7 +2280,9 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) - + +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1694,6 +2315,33 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def maxArea(self, height: List[int]) -> int: + n = len(height) + l = 0 + r = n - 1 + res = 0 + while l < r: + tmp = min(height[l],height[r]) + res = max(res,(r - l) * tmp) + if height[l] < height[r]: + l += 1 + else: + r -= 1 + + while l < r and tmp == height[l]: + l += 1 + while l < r and tmp == height[r]: + r -= 1 + + return res +``` + + + ## 鍚堝苟鍖洪棿 [LeetCode涓枃](https://leetcode-cn.com/problems/merge-intervals) @@ -1725,6 +2373,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n log n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ /** * Definition for an interval. @@ -1766,6 +2416,12 @@ public: }; ``` +**Python浠ｇ爜** + +```python + +``` + ## 涓嬩竴涓帓鍒 @@ -1819,6 +2475,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1854,6 +2512,14 @@ public: +**Python浠ｇ爜** + +```python + +``` + + + ## 缂哄け鐨勭涓涓鏁 [LeetCode涓枃](https://leetcode-cn.com/problems/first-missing-positive) @@ -1893,6 +2559,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(*n*) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -1915,6 +2583,14 @@ public: } }; ``` + + +**Python浠ｇ爜** + +```python + +``` + #### 鏂规硶2锛氫紭鍖栫┖闂村鏉傚害 瀵逛簬澶у皬涓簄锛坣>0锛夌殑鏁扮粍锛岃繖n涓暟鍙互鍒嗕负浠ヤ笅鍑犵鎯呭喌锛 @@ -1935,6 +2611,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -2003,6 +2681,8 @@ s = "`axc`", t = "`ahbgdc`" * 鏃堕棿澶嶆潅搴︼細O(*m+n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -2031,6 +2711,21 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def isSubsequence(self, s: str, t: str) -> bool: + i = j = 0 + while i < len(s) and j < len(t): + if s[i] == t[j]: + i += 1 + j += 1 + return i == len(s) +``` + + + ## 鎼滅储浜岀淮鐭╅樀II [LeetCode涓枃](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) @@ -2073,6 +2768,8 @@ public: - 鏃堕棿澶嶆潅搴︼細O(*m + n*) - 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -2105,6 +2802,33 @@ public: +**Python浠ｇ爜** + +```python +class Solution: + def searchMatrix(self, matrix, target): + """ + :type matrix: List[List[int]] + :type target: int + :rtype: bool + """ + if len(matrix) == 0: + return False + m,n = len(matrix),len(matrix[0]) + i,j = 0,n - 1 + while i < m and j >= 0: + if target < matrix[i][j]: + j -= 1 + elif target > matrix[i][j]: + i += 1 + else: + return True + + return False +``` + + + ## 鏈夋晥鐨勬暟鐙 [LeetCode涓枃](https://leetcode-cn.com/problems/valid-sudoku/) @@ -2175,6 +2899,8 @@ public: - 鏃堕棿澶嶆潅搴︼細O(9x9) = O(1) - 绌洪棿澶嶆潅搴︼細O(9) = O(1) +**C++浠ｇ爜** + ```c++ class Solution { public: @@ -2240,3 +2966,118 @@ public: }; ``` + + +**Python浠ｇ爜** + +```python + +``` + + + +## 鍥涙暟涔嬪拰 + +[LeetCode涓枃](https://leetcode-cn.com/problems/4sum/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/4sum/) + +### 瑙ｇ瓟 + +鍙屾寚閽 + + + +**Python浠ｇ爜** + +```python +class Solution: + def fourSum(self, nums: list, target: int) -> list: + nums.sort() + if len(nums) < 4: + return [] + idx1 = 0 + out_list = [] + while idx1 < len(nums) - 3: + idx2 = idx1 + 1 + while idx2 < len(nums) - 2: + target_tmp = target - nums[idx1] - nums[idx2] + l = idx2 + 1 + r = len(nums) - 1 + while l < r: + if target_tmp > nums[l] + nums[r]: + l += 1 + elif target_tmp < nums[l] + nums[r]: + r -= 1 + else: + tmp_list = [nums[idx1], nums[idx2], nums[l], nums[r]] + if tmp_list not in out_list: + out_list.append(tmp_list) + while l < r and nums[l] == nums[l + 1]: + l += 1 + while l < r and nums[r - 1] == nums[r]: + r -= 1 + l += 1 + r -= 1 + idx2 += 1 + while idx2 < len(nums) - 2 and nums[idx2] == nums[idx2 - 1]: + idx2 += 1 + idx1 += 1 + while idx1 < len(nums) - 3 and nums[idx1] == nums[idx1 - 1]: + idx1 += 1 + return out_list +``` + +# 澶氭暟鍏冪礌 + +[LeetCode涓枃](https://leetcode.cn/problems/majority-element-ii/) + +### 瑙ｇ瓟 + +鎽╁皵鎶曠エ娉 +瑕佹眰 > N / k涓轰紬鏁帮紝鍒欒繖鏍风殑鏁版渶澶氭湁k - 1涓 鍥犳缁存姢涓や釜鍊欓夊彉閲廲and1鍜宑and2 涓や釜闃舵锛屾姷娑 + 璁℃暟 cand1鍜宑and2鐨勫垵濮嬪间换鎰忥紝杩欓噷璁句负0 鍙鍙戠幇鏈夎鏁颁负0锛屽垯椹笂鏇存柊鏂扮殑cand 姣忚冨療鍒颁竴涓暟锛屽彧鏈変互涓5绉嶆儏鍐 + +鏄痗and1锛屽垯璁℃暟鍣++ +鏄痗and2锛屽垯璁℃暟鍣++ +閮戒笉鏄紝涓斾袱涓鏁板櫒閮 > 0锛屽垯涓や釜璁℃暟鍣-- +閮戒笉鏄紝涓攃ount1鏄0锛屽垯璁╂柊鐨勬暟鎴愪负cand1锛屼笖count1++ +閮戒笉鏄紝涓攃ount2鏄0锛屽垯璁╂柊鐨勬暟鎴愪负cand2锛屼笖count2++ +鏄撻敊鐐 +鏈川涓婃槸涓変釜涓姣 +褰撲笖浠呭綋纰板埌鐨勬暟鏃笉鏄痗and1涔熶笉鏄痗and2锛屼笖涓や釜璁℃暟鍣ㄩ兘 > 0鏃讹紝璁℃暟鍣ㄦ墠浼--锛屽叾浠栨儏鍐典竴寰嬩笉鍑 +cand1鍜宑and2鍙兘涓鏍凤紝鎵浠ュ湪璁℃暟闃舵姣忎釜鏁板彧鑳界畻鍒颁竴涓欓変汉澶翠笂锛屽嵆蹇呴』鐢╥f else璇彞 + + +```c++ +class Solution { +public: + vector majorityElement(vector& nums) { + vector res{}; + int res1, res2, cnt1, cnt2; + res1 = res2 = cnt1 = cnt2 = 0; + for (const auto& a : nums) { + if (a == res1) ++cnt1; + else if (a == res2) ++cnt2; + else if (cnt1 > 0 && cnt2 > 0) { + --cnt1; + --cnt2; + } else if (cnt1 == 0) { + res1 = a; + ++cnt1; + } else { + res2 = a; + ++cnt2; + } + } + cnt1 = 0, cnt2 = 0; + for (const auto& a : nums) { + if (a == res1) ++cnt1; + else if (a == res2) ++cnt2; + } + if (cnt1 > nums.size() / 3) res.push_back(res1); + if (cnt2 > nums.size() / 3) res.push_back(res2); + return res; + } +}; +``` + diff --git "a/LeetCode/\346\240\210\345\222\214\351\230\237\345\210\227.md" "b/LeetCode/\346\240\210\345\222\214\351\230\237\345\210\227.md" index 4978619..e830438 100644 --- "a/LeetCode/\346\240\210\345\222\214\351\230\237\345\210\227.md" +++ "b/LeetCode/\346\240\210\345\222\214\351\230\237\345\210\227.md" @@ -4,12 +4,149 @@ * [鏈夋晥鐨勬嫭鍙穄(#鏈夋晥鐨勬嫭鍙) (`easy`) * [閫嗘尝鍏拌〃杈惧紡姹傚糫(#閫嗘尝鍏拌〃杈惧紡姹傚) (`medium`) * [绠鍖栬矾寰刔(#绠鍖栬矾寰) (`medium`) + * [鍩烘湰璁＄畻鍣↖I](#鍩烘湰璁＄畻鍣↖I) (`medium`) + * [鍩烘湰璁＄畻鍣↖II](#鍩烘湰璁＄畻鍣↖II) (`hard`) * **闃熷垪** * [璁捐寰幆闃熷垪](#璁捐寰幆闃熷垪) (`medium`) * [璁捐寰幆鍙岀闃熷垪](#璁捐寰幆鍙岀闃熷垪) (`medium`) * [婊戝姩绐楀彛鏈澶у糫(#婊戝姩绐楀彛鏈澶у) (`hard` `婊戝姩绐楀彛` `鍙屽悜闃熷垪`) # 鏍堝拰闃熷垪鎬荤粨 + +# 鍩烘湰璁＄畻鍣↖II + +[LeetCode涓枃](https://leetcode.cn/problems/basic-calculator-iii/description/) + +閫氱敤瑙ｆ硶锛歨ttps://leetcode.cn/problems/basic-calculator/solutions/646865/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/ + +```c++ +class Solution { +public: + int calculate(string s) { + mp['+'] = 1; + mp['-'] = 1; + mp['*'] = 2; + mp['/'] = 2; + stack ops; + ops.push('('); + stack nums; + int num = 0; + int len = s.size(); + for (int i = 0; i < len; ++i) { + char ch = s[i]; + if (ch == ' ') { + continue; + } else if (ch == '(') { + ops.push(ch); + } else if (isNum(ch)) { + num = 0; + while (i < len && isNum(s[i])) { + num = num * 10 + (s[i] - '0'); + ++i; + } + nums.push(num); + --i; + } else { + calc(ops, nums, ch); + if (ch != ')') { + ops.push(ch); + } + } + } + calc(ops, nums, ')'); + return nums.empty() ? 0 : nums.top(); + } + bool isNum(char ch) { + return ch >= '0' && ch <= '9'; + } + void calc(stack& ops, stack& nums, char ch) { + if (nums.size() < 2) return; + if (ops.empty()) return; + while (!ops.empty() && ops.top() != '(' && nums.size() >= 2 && (ch == ')' || mp[ops.top()] >= mp[ch])) { + int num2 = nums.top(); + nums.pop(); + int num1 = nums.top(); + nums.pop(); + char op = ops.top(); + ops.pop(); + nums.push(getByOp(num1, num2, op)); + } + if (ch == ')' && !ops.empty() && ops.top() == '(') { + ops.pop(); + } + } + int getByOp(int num1, int num2, char op) { + int num = 0; + if (op == '+') { + num = num1 + num2; + } else if (op == '-') { + num = num1 - num2; + } else if (op == '*') { + num = num1 * num2; + } else { + num = num1 / num2; + } + return num; + } + +private: + unordered_map mp; +}; +``` + +# 鍩烘湰璁＄畻鍣↖I + +[LeetCode涓枃](https://leetcode.cn/problems/basic-calculator-ii/description/) + +棰樿В锛歨ttps://leetcode.cn/problems/basic-calculator-ii/solutions/648647/ji-ben-ji-suan-qi-ii-by-leetcode-solutio-cm28/ + +```c++ +class Solution { +public: + int calculate(string s) { + stack sta; + char flag = '$'; + int num = 0; + for (char ch : s) { + if (ch == ' ') continue; + else if (ch >= '0' && ch <= '9') { + num = num * 10 + (ch - '0'); + } else { + if (flag == '-') { + num = -1 * num; + } else if (flag == '*') { + num = sta.top() * num; + sta.pop(); + } else if (flag == '/') { + num = sta.top() / num; + sta.pop(); + } + flag = ch; + sta.push(num); + num = 0; + } + } + if (flag == '-') { + num = -1 * num; + } else if (flag == '*') { + num = sta.top() * num; + sta.pop(); + } else if (flag == '/') { + num = sta.top() / num; + sta.pop(); + } + sta.push(num); + + int res = 0; + while (!sta.empty()) { + res += sta.top(); + sta.pop(); + } + return res; + } +}; +``` + ## 鏈灏忔爤 [LeetCode涓枃](https://leetcode-cn.com/problems/min-stack/) @@ -99,6 +236,48 @@ private: */ ``` +**浼樺寲**锛氬彧浣跨敤涓涓爤 + +鎬濊矾锛歔瑙ｇ瓟](https://leetcode.cn/problems/min-stack/solutions/42521/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-38/) 涓殑瑙ｇ瓟浜 + +```c++ +class MinStack { +public: + MinStack() { + min_element = INT_MAX; + } + + void push(int val) { + if (val <= min_element) { + sta.push(min_element); + min_element = val; + } + sta.push(val); + } + + void pop() { + if (sta.top() == min_element) { + sta.pop(); + min_element = sta.top(); + } + sta.pop(); + } + + int top() { + return sta.top(); + } + + int getMin() { + return min_element; + } + +private: + stack sta; + int min_element; +}; + +``` + ## 鏈夋晥鐨勬嫭鍙 @@ -772,4 +951,4 @@ public: return res; } }; -``` \ No newline at end of file +``` diff --git "a/LeetCode/\347\272\277\346\256\265\346\240\221.md" "b/LeetCode/\347\272\277\346\256\265\346\240\221.md" index fbe90e4..e26944b 100644 --- "a/LeetCode/\347\272\277\346\256\265\346\240\221.md" +++ "b/LeetCode/\347\272\277\346\256\265\346\240\221.md" @@ -1,6 +1,7 @@ * **绾挎鏍戞荤粨** * [鍖洪棿鍜屾绱-鏁扮粍鍙慨鏀筣(#鍖洪棿鍜屾绱-鏁扮粍鍙慨鏀) (`medium`) * [璁＄畻鍙充晶灏忎簬褰撳墠鍏冪礌鐨勪釜鏁癩(#璁＄畻鍙充晶灏忎簬褰撳墠鍏冪礌鐨勪釜鏁) (`hard`) + * [瀛楃涓蹭腑鐨勫姞绮楀崟璇峕(#瀛楃涓蹭腑鐨勫姞绮楀崟璇) (`easy`) # 绾挎鏍戞荤粨 ## 鍖洪棿鍜屾绱-鏁扮粍鍙慨鏀 @@ -28,7 +29,7 @@ sumRange(0, 2) -> 8 1. 鏁扮粍浠呭彲浠ュ湪 `update` 鍑芥暟涓嬭繘琛屼慨鏀广 2. 浣犲彲浠ュ亣璁 `update` 鍑芥暟涓 `sumRange` 鍑芥暟鐨勮皟鐢ㄦ鏁版槸鍧囧寑鍒嗗竷鐨勩 -## 瑙ｇ瓟 +### 瑙ｇ瓟 鍙傝 [绾挎鏍戣绋-涔濈珷绠楁硶](https://www.jiuzhang.com/tutorial/segment-tree) @@ -173,7 +174,7 @@ private: 1 鐨勫彸渚ф湁 0 涓洿灏忕殑鍏冪礌. ``` -## 瑙ｇ瓟 +### 瑙ｇ瓟 姝ら棶棰樺彲浠ヨ浆鍖栦负绾挎鏍戠殑鍖洪棿闂锛屽浜巂nums[i]`锛屾眰灏忎簬瀹冪殑鍏冪礌涓暟鐩稿綋浜庢槸姹傚湪鍖洪棿`0~nums[i]-1`涓殑鍏冪礌涓暟銆傚紑杈熸暟缁刞count`锛屾壘鍑烘暟缁刞nums`鐨勬渶澶у糮num_max`鍜屾渶灏忓糮num_min`锛宍count`鐨勫ぇ灏忎负`num_max-num_min+1`锛宍count[i]`琛ㄧず鏁癭i+num_min`鍒扮洰鍓嶄负姝㈢殑鏁伴噺锛屽皢`count`寤虹珛鎴愮嚎娈垫爲銆傜劧鍚庝粠鍙冲線宸﹂亶鍘哷nums`锛岄亣鍒癭nums[i]`鏃讹紝鍘绘煡璇count`鍦╜0~nums[i]-1`鍖洪棿鐨勬诲拰锛屽嵆`nums[i]`鍙宠竟灏忎簬瀹冪殑鍏冪礌涓暟銆傛瘡娆℃煡璇㈠畬鍚庯紝灏嗘煡璇㈢粨鏋滄坊鍔犲埌缁撴灉`res`涓紝鐒跺悗灏哷nums[i]`鍦╜count`瀵瑰簲鐨勮鏁板煎姞涓(鍗砢count[nums[i] - num_min]`鍔犱竴)锛屽悓鏃舵洿鏂板埌绾挎鏍戙傞亶鍘嗙粨鏉熷悗锛屽皢缁撴灉鏁扮粍`res`鍙嶈浆鍗充负鎵姹傘 @@ -315,3 +316,75 @@ private: ``` + +## 瀛楃涓蹭腑鐨勫姞绮楀崟璇 + +[LeetCode涓枃](https://leetcode-cn.com/problems/bold-words-in-string/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/bold-words-in-string/) + +缁欏畾涓涓叧閿瘝闆嗗悎 `words` 鍜屼竴涓瓧绗︿覆 `S`锛屽皢鎵鏈 `S` 涓嚭鐜扮殑鍏抽敭璇嶅姞绮椼傛墍鏈夊湪鏍囩 `` 鍜 `` 涓殑瀛楁瘝閮戒細鍔犵矖銆 + +杩斿洖鐨勫瓧绗︿覆闇瑕佷娇鐢ㄥ敖鍙兘灏戠殑鏍囩锛屽綋鐒舵爣绛惧簲褰㈡垚鏈夋晥鐨勭粍鍚堛 + +渚嬪锛岀粰瀹歚words = ["ab", "bc"]` 鍜 `S = "aabcd"`锛岄渶瑕佽繑鍥 `"aabcd"`銆傛敞鎰忚繑鍥 `"aabcd"` 浼氫娇鐢ㄦ洿澶氱殑鏍囩锛屽洜姝ゆ槸閿欒鐨勩 + +**娉**锛 + +* `words` 闀垮害鐨勮寖鍥翠负 `[0, 50]`銆 +* `words[i]` 闀垮害鐨勮寖鍥翠负 `[1, 10]`銆 +* `S` 闀垮害鐨勮寖鍥翠负 `[0, 500]`銆 +* 鎵鏈 `words[i]` 鍜 `S` 涓殑瀛楃閮戒负灏忓啓瀛楁瘝銆 + +### 瑙ｇ瓟 + +#### 鏂规硶1锛氬瓧鍏告爲 + + + +**C++浠ｇ爜** + +```c++ + +``` + +#### 鏂规硶2锛氬搱甯 + + + +**Python浠ｇ爜** + +```python +class Solution: + def boldWords(self, words: List[str], S: str) -> str: + bold_tag = [False] * len(S) + for w in words: + b = 0 + l = len(w) + while b < len(S): + if w not in S[b:]: + break + idx = S.index(w, b) + for i in range(idx, idx + l): + bold_tag[i] = True + b = idx + 1 + res = '' + i = 0 + while i < len(S): + if not bold_tag[i]: + res += S[i] + i += 1 + else: + res += '' + S[i] + i += 1 + while i < len(S) and bold_tag[i]: + res += S[i] + i += 1 + res += '' + return res +``` + + + + + diff --git "a/LeetCode/\350\256\260\345\277\206\345\214\226\346\220\234\347\264\242.md" "b/LeetCode/\350\256\260\345\277\206\345\214\226\346\220\234\347\264\242.md" new file mode 100644 index 0000000..e688cdb --- /dev/null +++ "b/LeetCode/\350\256\260\345\277\206\345\214\226\346\220\234\347\264\242.md" @@ -0,0 +1,98 @@ +**璁板繂鍖栨悳绱** + * [鎵撳鍔垗III](#鎵撳鍔垗III) (`medium` `鏍戝舰鍔ㄦ佽鍒抈) + * [璺緞鎬诲拰III](#璺緞鎬诲拰III) (`medium` `鍓嶇紑鍜宍) + +# 璁板繂鍖栨悳绱 + +## 璺緞鎬诲拰III + +[LeetCode涓枃](https://leetcode.cn/problems/path-sum-iii/) + + +```c++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + int pathSum(TreeNode* root, int targetSum) { + unordered_map mp; // key: 鍓嶇紑鍜 value: 鍓嶇紑鍜岀瓑浜巏ey鐨勮妭鐐规暟閲 + long prefix_sum = 0; + return pathSumImpl(root, targetSum, mp, prefix_sum); + } + int pathSumImpl(TreeNode* root, int target, unordered_map& mp, long prefix_sum) { + if (root == nullptr) return 0; + int res = 0; + prefix_sum += root->val; + if (prefix_sum == target) res += 1; + if (mp.find(prefix_sum - target) != mp.end()) { + res += mp[prefix_sum - target]; + } + mp[prefix_sum]++; + res += pathSumImpl(root->left, target, mp, prefix_sum); + res += pathSumImpl(root->right, target, mp, prefix_sum); + mp[prefix_sum]--; + return res; + } +}; +``` + +## 鎵撳鍔垗III + +[LeetCode涓枃](https://leetcode.cn/problems/house-robber-iii/description/) + +瑙ｆ硶锛氭爲褰㈠姩鎬佽鍒 + 璁板繂鍖栨悳绱 + +棰樿В锛 https://leetcode.cn/problems/house-robber-iii/solutions/361038/da-jia-jie-she-iii-by-leetcode-solution/ + +鎵撳鍔垗绯诲垪鎵╁睍锛歨ttps://leetcode.cn/problems/house-robber-iii/solutions/67467/tong-yong-si-lu-tuan-mie-da-jia-jie-she-wen-ti-b-2/ + +```c++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + int rob(TreeNode* root) { + return max(pickRecursive(root), unpickRecursive(root)); + } + int pickRecursive(TreeNode* root) { + if (!root) return 0; + if (pick_mp.find(root) != pick_mp.end()) { + return pick_mp[root]; + } + int res = root->val + unpickRecursive(root->left) + unpickRecursive(root->right); + pick_mp[root] = res; + return res; + } + int unpickRecursive(TreeNode* root) { + if (!root) return 0; + if (unpicked_mp.find(root) != unpicked_mp.end()) { + return unpicked_mp[root]; + } + int res = max(pickRecursive(root->left), unpickRecursive(root->left)) + max(pickRecursive(root->right), unpickRecursive(root->right)); + unpicked_mp[root] = res; + return res; + } + +private: + unordered_map pick_mp; + unordered_map unpicked_mp; +}; +``` diff --git "a/LeetCode/\350\256\276\350\256\241.md" "b/LeetCode/\350\256\276\350\256\241.md" index 2a5880f..84d8fe9 100644 --- "a/LeetCode/\350\256\276\350\256\241.md" +++ "b/LeetCode/\350\256\276\350\256\241.md" @@ -1,6 +1,6 @@ * **璁捐绫绘荤粨** * [甯告暟鏃堕棿鎻掑叆銆佸垹闄ゅ拰鑾峰彇闅忔満鍏冪礌](#甯告暟鏃堕棿鎻掑叆鍒犻櫎鍜岃幏鍙栭殢鏈哄厓绱) (`medium` `鍝堝笇`) - * [LRU缂撳瓨鏈哄埗](#LRU缂撳瓨鏈哄埗) (`hard` `绯荤粺璁捐` `鍝堝笇`) + * [LRU缂撳瓨鏈哄埗](#LRU缂撳瓨鏈哄埗) (`medium` `绯荤粺璁捐` `鍝堝笇`) # 璁捐绫绘荤粨 diff --git "a/LeetCode/\350\264\252\345\277\203.md" "b/LeetCode/\350\264\252\345\277\203.md" index 0b8eac9..e676341 100644 --- "a/LeetCode/\350\264\252\345\277\203.md" +++ "b/LeetCode/\350\264\252\345\277\203.md" @@ -1,14 +1,131 @@ * **璐績鎬荤粨** - + * [涔板崠鑲＄エ鐨勬渶浣虫椂鏈篒I](#涔板崠鑲＄エ鐨勬渶浣虫椂鏈篒I) (`easy`) * [鏌犳姘存壘闆禲(#鏌犳姘存壘闆) (`easy`) * [鍒嗗彂楗煎共](#鍒嗗彂楗煎共) (`easy`) * [浠诲姟璋冨害鍣╙(#浠诲姟璋冨害鍣) (`medium`) * [鍒嗗壊鏁扮粍涓鸿繛缁瓙搴忓垪](#鍒嗗壊鏁扮粍涓鸿繛缁瓙搴忓垪) (`medium`) * [璺宠穬娓告垙](#璺宠穬娓告垙) (`medium` `鍔ㄦ佽鍒抈) - + * [璺宠穬娓告垙II](#璺宠穬娓告垙II) (`medium` `璐績`) + * [浣挎暟缁勫敮涓鐨勬渶澶у閲廬(#浣挎暟缁勫敮涓鐨勬渶澶у閲) (`medium` ) + * [鍒嗗彂绯栨灉](#鍒嗗彂绯栨灉) (`hard`) + * [鏍规嵁韬珮閲嶅缓闃熷垪](#鏍规嵁韬珮閲嶅缓闃熷垪) (`medium`) + * [鏁戠敓鑹嘳(#鏁戠敓鑹) (`medium`) + * [鐢ㄦ渶灏戞暟閲忕殑绠紩鐖嗘皵鐞僝(#鐢ㄦ渶灏戞暟閲忕殑绠紩鐖嗘皵鐞) (`medium`) + * [绉绘帀K浣嶆暟瀛梋(#绉绘帀K浣嶆暟瀛) (`medium` `鍗曡皟鏍坄) + * [鏃犻噸鍙犲尯闂碷(#鏃犻噸鍙犲尯闂) (`medium`) + * [鍔犳补绔橾(#鍔犳补绔) (`medium`) + * [鍒ゆ柇涓涓嫭鍙峰瓧绗︿覆鏄惁鏈夋晥](#鍒ゆ柇涓涓嫭鍙峰瓧绗︿覆鏄惁鏈夋晥) (`medium`) + * [鍘婚櫎閲嶅瀛楁瘝](#鍘婚櫎閲嶅瀛楁瘝) (`璐績` `鍝堝笇` `鍗曡皟鏍坄) + # 璐績鎬荤粨 + +## 璺宠穬娓告垙II + +[LeetCode涓枃](https://leetcode.cn/problems/jump-game-ii/description/) + +棰樿В锛氬拰 [璺宠穬娓告垙](#璺宠穬娓告垙) 璐績鏂规硶绫讳技锛屼絾鏄渶瑕侀夋嫨涓嬩竴姝ョ殑浣嶇疆锛屾潵淇濊瘉璧板緱鏈杩滐紝鍦ㄨ蛋鐨勮繃绋嬩腑璁板綍姝ユ暟 + +```c++ +class Solution { +public: + int jump(vector& nums) { + if (nums.size() <= 1) return 0; + int len = nums.size(); + int Max = 0 + nums[0]; + if (Max >= len - 1) return 1; + int step = 0; + int idx = 0; + while (idx < len) { + int end = idx + nums[idx]; + for (int i = idx + 1; i <= end && i < len; i++) { + if (i + nums[i] > Max) { + idx = i; + Max = i + nums[i]; + } + } + step++; + if (Max >= len - 1) { + step++; + break; + } + } + return step; + } +}; +``` + + +## 鍘婚櫎閲嶅瀛楁瘝 + +[LeetCode涓枃](https://leetcode.cn/problems/remove-duplicate-letters/description/) + +鍒╃敤瀛楁瘝鐨勭浉瀵瑰ぇ灏忔瘮杈冩潵閫夋嫨鏄惁涓㈠純瀛楁瘝锛岃椽蹇冩濊矾姣旇緝宸у + +https://leetcode.cn/problems/remove-duplicate-letters/solutions/290200/yi-zhao-chi-bian-li-kou-si-dao-ti-ma-ma-zai-ye-b-4/ + +鍜 [绉绘帀K浣嶆暟瀛梋(#绉绘帀K浣嶆暟瀛) 鎬濊矾寰堢浉浼硷紝涓昏鍖哄埆鏄渶瑕佽冭檻閲嶅鍏冪礌锛屽湪浠庡乏寰鍙抽亶鍘嗙殑鏃跺欙紝濡傛灉褰撳墠鍏冪礌cur宸茬粡鍦╯tack涓瓨鍦紝鐩存帴涓㈠純 + +```c++ +class Solution { +public: + string removeDuplicateLetters(string s) { + string res; + unordered_set st; + unordered_map mp; + for (const char& ch : s) { + ++mp[ch]; + } + for (const char ch : s) { + if (st.find(ch) != st.end()) { + --mp[ch]; + continue; + } + while (!res.empty() && res.back() > ch && mp[res.back()] > 1) { + char top = res.back(); + res.pop_back(); + --mp[top]; + st.erase(top); + } + res.push_back(ch); + st.insert(ch); + } + return res; + } +}; +``` + +## 鍒ゆ柇涓涓嫭鍙峰瓧绗︿覆鏄惁鏈夋晥 + +[LeetCode涓枃](https://leetcode.cn/problems/check-if-a-parentheses-string-can-be-valid/description/) + +棰樿В锛 https://leetcode.cn/problems/check-if-a-parentheses-string-can-be-valid/solutions/1176807/qian-hou-ge-bian-li-yi-ci-fen-bie-pan-du-w5nu/ + +```c++ +class Solution { +public: + bool canBeValid(string s, string locked) { + if(s.size() % 2 == 1) return false; + int r = 0, l = 0; + for (int i = 0; i < s.size(); ++i) { + if (s[i] == ')' && locked[i] == '1') { + ++r; + if (i + 1 < 2 * r) return false; + } + } + int n = s.size(); + for (int i = n - 1; i >= 0; --i) { + if (s[i] == '(' && locked[i] == '1') { + ++l; + if (n - i < 2 * l) return false; + } + } + return true; + } +}; +``` + ## 涔板崠鑲＄エ鐨勬渶浣虫椂鏈篒I [LeetCode涓枃](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/) @@ -254,7 +371,7 @@ public: -# 浠诲姟璋冨害鍣 +## 浠诲姟璋冨害鍣 [LeetCode涓枃](https://leetcode-cn.com/problems/task-scheduler) @@ -356,7 +473,7 @@ public: -# 鍒嗗壊鏁扮粍涓鸿繛缁瓙搴忓垪 +## 鍒嗗壊鏁扮粍涓鸿繛缁瓙搴忓垪 [LeetCode涓枃](https://leetcode-cn.com/problems/split-array-into-consecutive-subsequences) @@ -445,7 +562,7 @@ public: -# 璺宠穬娓告垙 +## 璺宠穬娓告垙 [LeetCode涓枃](https://leetcode-cn.com/problems/jump-game) @@ -538,3 +655,333 @@ public: ``` + +## 浣挎暟缁勫敮涓鐨勬渶澶у閲 + +[LeetCode涓枃](https://leetcode-cn.com/problems/minimum-increment-to-make-array-unique/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/minimum-increment-to-make-array-unique/) + +缁欏畾鏁存暟鏁扮粍 `A`锛屾瘡娆 move 鎿嶄綔灏嗕細閫夋嫨浠绘剰 `A[i]`锛屽苟灏嗗叾閫掑 1銆 + +杩斿洖浣 `A` 涓殑姣忎釜鍊奸兘鏄敮涓鐨勬渶灏戞搷浣滄鏁般 + +**绀轰緥 1**: + +``` +杈撳叆锛歔1,2,2] +杈撳嚭锛1 +瑙ｉ噴锛氱粡杩囦竴娆 move 鎿嶄綔锛屾暟缁勫皢鍙樹负 [1, 2, 3]銆 +``` + +**绀轰緥 2**: +``` +杈撳叆锛歔3,2,1,2,1,7] +杈撳嚭锛6 +瑙ｉ噴锛氱粡杩 6 娆 move 鎿嶄綔锛屾暟缁勫皢鍙樹负 [3, 4, 1, 2, 5, 7]銆 +鍙互鐪嬪嚭 5 娆℃垨 5 娆′互涓嬬殑 move 鎿嶄綔鏄笉鑳借鏁扮粍鐨勬瘡涓煎敮涓鐨勩 +``` + +**鎻愮ず**锛 + +1. 0 <= A.length <= 40000 +2. 0 <= A[i] < 40000 + +### 瑙ｇ瓟 + +璐績娉 + +```python +class Solution: + def minIncrementForUnique(self, A: List[int]) -> int: + if len(A) == 0: + return 0 + A.sort() + move = 0 + for i in range(1, len(A)): + if A[i] <= A[i - 1]: + add = A[i - 1] - A[i] + 1 + move += add + A[i] += add + return move +``` + + + +## 鍒嗗彂绯栨灉 + +[LeetCode涓枃](https://leetcode-cn.com/problems/candy/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/candy/) + +### 瑙ｇ瓟 + +**C++浠ｇ爜** + +```python +class Solution { +public: + int candy(vector& ratings) { + vector nums(ratings.size(),1); + for(int i = 1;i < ratings.size();i++) + { + if(ratings[i] > ratings[i-1]) + nums[i] = nums[i-1] + 1; + } + + for(int i = ratings.size() - 1;i >= 1;i--) + { + if(ratings[i-1] > ratings[i]) + nums[i-1] = max(nums[i-1],nums[i] + 1); + } + + return accumulate(nums.begin(),nums.end(),0); + } +}; +``` + + + +## 鏍规嵁韬珮閲嶅缓闃熷垪 + +[LeetCode涓枃](https://leetcode-cn.com/problems/queue-reconstruction-by-height/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/queue-reconstruction-by-height/) + + + +### 瑙ｇ瓟 + +閫氫織瑙ｉ噴锛氱煯涓瓙鎻掗槦锛岄珮涓瓙鐪嬩笉瑙侊紱鎵浠ユ垜浠彲浠ュ厛瀹夋帓楂樹釜瀛愮殑浣嶇疆锛屽啀閫氳繃鎻掗槦鐨勬柟寮忓畨鎺掔煯涓瓙鐨勪綅缃 + +璇︾粏澶勭悊锛氬鏁扮粍鎺掑簭锛岀涓涓厓绱狅紙韬珮锛夐檷搴忥紝绗簩涓厓绱狅紙浜烘暟锛夊崌搴忥紝鐒跺悗閬嶅巻鏁扮粍锛屾牴鎹浜屼釜鍏冪礌锛堜汉鏁帮級鎻掑叆鍒扮粨鏋滄暟缁 + +**C++浠ｇ爜** + +```c++ +class Solution { +public: + vector> reconstructQueue(vector>& people) { + if(people.size() <= 0) return {}; + sort(people.begin(),people.end(),[](const vector& vec1,const vector& vec2) + { + return (vec1[0] > vec2[0]) || (vec1[0] == vec2[0] && vec1[1] < vec2[1]); + }); + vector> res; + for(auto& vec : people) + { + res.insert(res.begin() + vec[1],vec); + } + + return res; + } +}; +``` + + + +## 鏁戠敓鑹 + +[LeetCode涓枃](https://leetcode-cn.com/problems/boats-to-save-people/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/boats-to-save-people/) + + + +### 瑙ｇ瓟 + +**Python浠ｇ爜** + +```python +class Solution: + def numRescueBoats(self, people: List[int], limit: int) -> int: + # 闄嶅簭鎺掑簭 + people.sort(reverse=True) + max_x = max(people) + if max_x > limit: + raise Exception('瀛樺湪鑸瑰憳鐨勪綋閲嶅ぇ浜巐imit鏁板硷紝涓嶅彲鑳借杞芥墍鏈変汉') + out = 0 + left, right = 0, len(people) - 1 + tmp = 0 + while left < right: + tmp = people[left] + people[right] + if tmp > limit: + left += 1 + else: + left += 1 + right -= 1 + out += 1 + if left == right: + out += 1 + return out +``` + + + +## 鐢ㄦ渶灏戞暟閲忕殑绠紩鐖嗘皵鐞 + +[LeetCode涓枃](https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/) + +### 瑙ｇ瓟 + +**C++浠ｇ爜** + +```c++ +class Solution { +public: + int findMinArrowShots(vector>& points) { + int n = points.size(); + if(n <= 1) return n; + + sort(points.begin(),points.end(),[](const vector& v1,const vector& v2) + {return v1[0] < v2[0] || (v1[0] == v2[0] && v1[1] < v2[1]);}); + auto pre = points[0]; + int res = 1; + for(int i = 1;i < n;i++) + { + int start = points[i][0]; + int end = points[i][1]; + if(start > pre[1]) + { + res++; + pre = points[i]; + } + else{ + if(end <= pre[1]) + { + pre = points[i]; + } + } + } + + return res; + } +}; +``` + + + +## 绉绘帀K浣嶆暟瀛 + +[LeetCode涓枃](https://leetcode-cn.com/problems/remove-k-digits/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/remove-k-digits/) + + + +### 瑙ｇ瓟 + +**C++浠ｇ爜** + +```c++ +class Solution { +public: + string removeKdigits(string num, int k) { + int n = num.size(); + int sz = n - k; + string res; + for(auto ch : num) + { + while(!res.empty() && ch < res.back() && k > 0) + { + res.pop_back(); + k--; + } + + res.push_back(ch); + } + + res.resize(sz); + while(res.size() > 0 && res[0] == '0') res.erase(res.begin()); + + return res.empty() ? "0" : res; + } +}; +``` + + + +## 鏃犻噸鍙犲尯闂 + +[LeetCode涓枃](https://leetcode-cn.com/problems/non-overlapping-intervals/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/non-overlapping-intervals/) + +### 瑙ｇ瓟 + +**C++浠ｇ爜** + +```c++ +class Solution { +public: + int eraseOverlapIntervals(vector>& intervals) { + int len = intervals.size(); + if(len <= 1) return 0; + sort(intervals.begin(),intervals.end(), + [](const vector& v1,const vector& v2) + {return v1[0] < v2[0] || (v1[0] == v2[0] && v1[1] < v2[1]);}); + int cnt = 0; + auto pre = intervals[0]; + for(int i = 1;i < len;i++) + { + int start = intervals[i][0]; + int end = intervals[i][1]; + if(start < pre[1]) + { + if(end <= pre[1]) + { + cnt++; + pre = intervals[i]; + } + else + { + cnt++; + } + } + else{ + pre = intervals[i]; + } + } + + return cnt; + } +}; +``` + + + +## 鍔犳补绔 + +[LeetCode涓枃](https://leetcode-cn.com/problems/gas-station/) + +[LeetCode鑻辨枃](https://leetcode.com/problems/gas-station/) + + + +### 瑙ｇ瓟 + +**C++浠ｇ爜** + +```c++ +class Solution { +public: + int canCompleteCircuit(vector& gas, vector& cost) { + int cur = 0,total = 0,start = 0; + for(int i = 0;i < gas.size();i++) + { + total += gas[i] - cost[i]; + cur += gas[i] - cost[i]; + if(cur < 0) + { + start = i + 1; + cur = 0; + } + } + + return total >= 0 ? start : -1; + } +}; +``` + diff --git "a/LeetCode/\351\200\222\345\275\222.md" "b/LeetCode/\351\200\222\345\275\222.md" new file mode 100644 index 0000000..ff547dd --- /dev/null +++ "b/LeetCode/\351\200\222\345\275\222.md" @@ -0,0 +1,55 @@ +* **閫掑綊鎬荤粨** + * [瀛楃涓茶В鐮乚(#瀛楃涓茶В鐮) (`閫掑綊` `鍥炴函`) + + +# 閫掑綊鎬荤粨 + +## 瀛楃涓茶В鐮 + +[LeetCode涓枃](https://leetcode.cn/problems/decode-string/description/) + + + +```c++ +class Solution { +public: + string recursion(const string& s, int idx) { + if (idx >= s.size()) return ""; + stack> sta; + string res; + while (idx < s.size()) { + if (s[idx] >= '1' && s[idx] <= '9') { + int a = 0; + while (idx < s.size() && (s[idx] >= '0' && s[idx] <= '9')) { + a = a * 10 + (s[idx] - '0'); + idx++; + } + if (s[idx] == '[') { + sta.push({res, a}); + idx++; + res = ""; + } + } else if (s[idx] == ']') { + auto pr = sta.top(); + sta.pop(); + idx++; + string tmp = pr.first; + for (int i = 0; i < pr.second; i++) { + tmp += res; + } + res = tmp; + } else if (s[idx] >= 'a' && s[idx] <= 'z') { + while (idx < s.size() && (s[idx] >= 'a' && s[idx] <= 'z')) { + res += s[idx]; + idx++; + } + } + } + return res; + } + string decodeString(string s) { + int idx = 0; + return recursion(s, idx); + } +}; +``` diff --git "a/LeetCode/\351\223\276\350\241\250.md" "b/LeetCode/\351\223\276\350\241\250.md" index 2cf53d7..02768ca 100644 --- "a/LeetCode/\351\223\276\350\241\250.md" +++ "b/LeetCode/\351\223\276\350\241\250.md" @@ -1,5 +1,6 @@ * **閾捐〃绫绘荤粨** * [鍙嶈浆閾捐〃](#鍙嶈浆閾捐〃) (`easy` `涓夋寚閽坄 `dummy鑺傜偣`) + * [鍙嶈浆閾捐〃II](#鍙嶈浆閾捐〃II) (`medium` `鍙屾寚閽坄) * [鍚堝苟涓や釜鏈夊簭閾捐〃](#鍚堝苟涓や釜鏈夊簭閾捐〃) (`easy` `鍙屾寚閽坄) * [鍒犻櫎鎺掑簭閾捐〃涓殑閲嶅鍏冪礌](#鍒犻櫎鎺掑簭閾捐〃涓殑閲嶅鍏冪礌) (`easy` `鍙屾寚閽坄) * [鍥炴枃閾捐〃](#鍥炴枃閾捐〃) (`easy` `鍙嶈浆閾捐〃`) @@ -12,10 +13,127 @@ * [涓ゆ暟鐩稿姞](#涓ゆ暟鐩稿姞) (`medium` `鏁板`) * [鍒犻櫎閾捐〃鐨勫掓暟绗琋涓妭鐐筣(#鍒犻櫎閾捐〃鐨勫掓暟绗琋涓妭鐐) (`medium`) * [澶嶅埗甯﹂殢鏈烘寚閽堢殑閾捐〃](#澶嶅埗甯﹂殢鏈烘寚閽堢殑閾捐〃) (`medium`) + * [k涓竴缁勭炕杞摼琛╙(#k涓竴缁勭炕杞摼琛) (`hard`) # 閾捐〃绫绘荤粨 + +## k涓竴缁勭炕杞摼琛 + +[LeetCode涓枃](https://leetcode.cn/problems/reverse-nodes-in-k-group/description/) + +瑙ｇ瓟锛氱炕杞摼琛ㄧ殑杩涢樁鐗堟瘡缈昏浆涓缁勶紝閮介渶瑕佸疄鏃剁淮鎶ゅ綋鍓嶅ご缁撶偣cur_head銆佸綋鍓嶅熬缁撶偣cur_tail鍜屼笅涓缁勫ご缁撶偣cur_head锛岄氳繃cur銆乶ext銆乸re涓変釜鍙橀噺瀹炵幇姣忕粍鐨勭炕杞 + +```c++ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ +class Solution { +public: + ListNode* reverseKGroup(ListNode* head, int k) { + ListNode *next_head = head, *cur = head, *pre = nullptr, *next = nullptr, *cur_head = head, *cur_tail = nullptr; + int cnt = 1; + while (cnt < k && cur_head && cur_head->next) { + cur_head = cur_head->next; + cnt++; + } + next_head = cur_head->next; + ListNode node(0, nullptr), *dummy = &node; + dummy->next = cur_head; + while (cur) { + if (cur_tail) { + cur_tail->next = cur_head; + } + cur_tail = cur; + while (pre != cur_head) { + next = cur->next; + cur->next = pre; + pre = cur; + cur = next; + } + cur = next_head; + if (!cur) break; + cur_head = cur; + int cnt = 1; + while (cnt < k && cur_head && cur_head->next) { + cur_head = cur_head->next; + cnt++; + } + if (cnt < k) { + cur_tail->next = cur; + break; + } + next_head = cur_head->next; + pre = nullptr; + next = nullptr; + } + return node.next; + } +}; +``` + +## 鍙嶈浆閾捐〃II + +[LeetCode涓枃](https://leetcode.cn/problems/reverse-linked-list-ii/) + +```c++ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ +class Solution { +public: + ListNode* reverseBetween(ListNode* head, int left, int right) { + ListNode *l_pre = nullptr, *r_next = nullptr, *l_p, *r_p; + ListNode* p = head; + int idx = 1; + while (p) { + if (idx == left) { + l_p = p; + } + if (idx + 1 == left) { + l_pre = p; + } + if (idx == right) { + r_p = p; + r_next = p->next; + break; + } + p = p->next; + idx++; + } + if (!l_p || !r_p) return head; + ListNode *pre = r_next, *cur = l_p, *next = nullptr; + while (pre != r_p) { + next = cur->next; + cur->next = pre; + pre = cur; + cur = next; + } + if (l_pre) { + l_pre->next = pre; + return head; + } + return pre; + } +}; +``` + + ## 鍙嶈浆閾捐〃 [LeetCode涓枃](https://leetcode-cn.com/problems/reverse-linked-list/) @@ -39,6 +157,8 @@ * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ /** * Definition for singly-linked list. @@ -68,6 +188,31 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def reverseList(self, head: ListNode) -> ListNode: + pre = None + cur = head + nex = None + while cur: + nex = cur.next + cur.next = pre + + pre = cur + cur = nex + return pre +``` + + + #### 鏂规硶2锛歞ummy缁撶偣 璁句竴涓猟ummy缁撶偣(`澶寸粨鐐筦)锛屽畠鐨刵ext鎸囬拡濮嬬粓鎸囧悜閾捐〃棣栬妭鐐广傝cur鎸囬拡鎸囧悜褰撳墠鑺傜偣锛宼emp浣滀负涓存椂鎸囬拡鎸囧悜褰撳墠鑺傜偣鐨勪笅涓涓妭鐐广傞偅涔堢炕杞殑杩囩▼灏辨槸锛 @@ -80,6 +225,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ /** * Definition for singly-linked list. @@ -110,9 +257,34 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def reverseList(self, head: ListNode) -> ListNode: + pre = None + cur = head + nex = None + while cur: + nex = cur.next + cur.next = pre + + pre = cur + cur = nex + return pre +``` + + + #### 鏂规硶3锛氶掑綊 -璁剧k+1灞傞掑綊杩斿洖澶勭悊绗琸灞傜粨鐐筴鏃讹紝k浠ュ悗鐨勮妭鐐归兘宸茬粡鍙嶈浆銆傞偅涔堝浜庤妭鐐筴锛岄渶瑕佷慨鏀圭粨鐐筴+1鐨刵ext鎸囧悜鑺傜偣锛屼互鍙婅妭鐐筴鐨刵ext鎸囧悜鑺傜偣 +璁剧k+1灞傞掑綊杩斿洖澶勭悊绗琸灞傜粨鐐筴鏃讹紝k浠ュ悗鐨勮妭鐐归兘宸茬粡鍙嶈浆銆傞偅涔堝浜庤妭鐐筴锛岄渶瑕佷慨鏀圭粨鐐筴+1鐨刵ext鎸囧悜鑺傜偣k锛屼互鍙婅妭鐐筴鐨刵ext鎸囧悜绌 ```c++ node(1) -> node(2) -> node(3) -> ... -> node(k) -> node(k+1) <- ... <- node(n-1) <- node(n) @@ -126,6 +298,8 @@ node(k)->next = nullptr; * 鏃堕棿澶嶆潅搴︼細O(n) * 绌洪棿澶嶆潅搴︼細O(n) (`鐢变簬n灞傞掑綊锛岃屾瘡灞傞掑綊鍑芥暟璋冪敤鐨勬爤甯т細鍒涘缓灞閮ㄦ寚閽坱mp`) +**C++浠ｇ爜** + ```c++ /** * Definition for singly-linked list. @@ -151,6 +325,30 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def reverseList(self, head: ListNode) -> ListNode: + if not head or not head.next: + return head + tmp = head + head = self.reverseList(tmp.next) + + tmp.next.next = tmp + tmp.next = None + + return head + + +``` + ## 鍚堝苟涓や釜鏈夊簭閾捐〃 @@ -162,6 +360,7 @@ public: 灏嗕袱涓湁搴忛摼琛ㄥ悎骞朵负涓涓柊鐨勬湁搴忛摼琛ㄥ苟杩斿洖銆傛柊閾捐〃鏄氳繃鎷兼帴缁欏畾鐨勪袱涓摼琛ㄧ殑鎵鏈夎妭鐐圭粍鎴愮殑銆 **绀轰緥**锛 + ``` 杈撳叆锛1->2->4, 1->3->4 杈撳嚭锛1->1->2->3->4->4 @@ -178,6 +377,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*m+n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ /** * Definition for singly-linked list. @@ -218,6 +419,30 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: + if not l1: + return l2 + if not l2: + return l1 + if l1.val < l2.val: + res = l1 + res.next = self.mergeTwoLists(l1.next,l2) + else: + res = l2 + res.next = self.mergeTwoLists(l1,l2.next) + return res +``` + ## 鍒犻櫎鎺掑簭閾捐〃涓殑閲嶅鍏冪礌 @@ -250,6 +475,8 @@ public: * 鏃堕棿澶嶆潅搴︼細O(*n*) * 绌洪棿澶嶆潅搴︼細O(1) +**C++浠ｇ爜** + ```c++ /** * Definition for singly-linked list. @@ -286,6 +513,31 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def deleteDuplicates(self, head: ListNode) -> ListNode: + if not head: + return head + pre = head + cur = head.next + while cur: + if cur.val != pre.val: + pre.next = cur + pre = pre.next + cur = cur.next + + pre.next = None + return head +``` + ## 鍥炴枃閾捐〃 @@ -456,6 +708,43 @@ public: +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode(object): +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution(object): + def hasCycle(self, head): + """ + :type head: ListNode + :rtype: bool + """ + if not head: + return False + + if head.next: + p1 = head.next.next + p2 = head.next + else: + return False + + while p1 != p2 and p1 : + p1 = p1.next + if p1: + p1 = p1.next + p2 = p2.next + + if not p1: + return False + return True +``` + + + ## 鐜舰閾捐〃II [LeetCode涓枃](https://leetcode-cn.com/problems/linked-list-cycle-ii/) @@ -479,6 +768,7 @@ public: ![1](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist.png) **绀轰緥 2**锛 + ``` 杈撳叆锛歨ead = [1,2], pos = 0 杈撳嚭锛歵ail connects to node index 0 @@ -588,6 +878,7 @@ public: ``` **娉ㄦ剰**锛 + * 濡傛灉涓や釜閾捐〃娌℃湁浜ょ偣锛岃繑鍥 null. * 鍦ㄨ繑鍥炵粨鏋滃悗锛屼袱涓摼琛ㄤ粛椤讳繚鎸佸師鏈夌殑缁撴瀯銆 * 鍙亣瀹氭暣涓摼琛ㄧ粨鏋勪腑娌℃湁寰幆銆 @@ -663,6 +954,50 @@ public: }; ``` +**Python浠ｇ爜** + +```python +# Definition for singly-linked list. +# class ListNode(object): +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution(object): + def getIntersectionNode(self, headA, headB): + """ + :type head1, head1: ListNode + :rtype: ListNode + """ + n1 = n2 = 0 + p = headA + while p: + n1 += 1 + p = p.next + p = headB + + while p: + n2 += 1 + p = p.next + + p1 = p2 = None + if n1 > n2: + p1 = headA + p2 = headB + else: + p1 = headB + p2 = headA + + for i in range(abs(n1 - n2)): + p1 = p1.next + + while p1 and p2 and p1 != p2: + p1 = p1.next + p2 = p2.next + + return p1 +``` + ## 濂囧伓閾捐〃 @@ -1124,56 +1459,42 @@ public: > 鍙傝**鍓戞寚Offer 绗簩鐗** 闈㈣瘯棰22: 閾捐〃涓掓暟绗琸涓妭鐐 -* python浠ｇ爜 +* C++浠ｇ爜 -```python -# Definition for singly-linked list. -# class ListNode: -# def __init__(self, x): -# self.val = x -# self.next = None - -class Solution: - def removeNthFromEnd(self, head, n): - """ - :type head: ListNode - :type n: int - :rtype: ListNode - """ - if not head: - return None - - l = 0 - p = head - while p: - p = p.next - l += 1 - - if l < n: - return head - if l == 1: - return None - - """鐗规畩鎯呭喌锛氬垹闄ゆ湯灏惧厓绱""" - if n == 1: - p = head - while p.next.next: - p = p.next - #p.val = p.next.val - p.next = p.next.next - return head - - p1 = p2 = head - cnt = 1 - while p1.next and p2.next: - if cnt >= n: - p1 = p1.next - cnt += 1 - p2 = p2.next - - p1.val = p1.next.val - p1.next = p1.next.next - return head +```c++ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ +class Solution { +public: + ListNode* removeNthFromEnd(ListNode* head, int n) { + if (!head) return head; + ListNode node(0), *pre = &node; + pre->next = head; + ListNode *slow = pre, *fast = pre; + for (int i = 1; i <= n; ++i) { + if (fast) { + fast = fast->next; + } else { + break; + } + } + if (!fast) return nullptr; + while (slow->next && fast->next) { + fast = fast->next; + slow = slow->next; + } + slow->next = slow->next->next; + return node.next; + } +}; ``` @@ -1188,7 +1509,7 @@ class Solution: 瑕佹眰杩斿洖杩欎釜閾捐〃鐨勬繁搴︽嫹璐濄 -### 瑙ｇ瓟 +### 瑙ｆ硶1 > 鍙傝**鍓戞寚Offer 绗簩鐗** 闈㈣瘯棰35锛氬鏉傞摼琛ㄧ殑澶嶅埗 @@ -1256,3 +1577,47 @@ public: } }; ``` +### 瑙ｆ硶2 + +鍝堝笇琛 + +```c++ +/* +// Definition for a Node. +class Node { +public: + int val; + Node* next; + Node* random; + + Node(int _val) { + val = _val; + next = NULL; + random = NULL; + } +}; +*/ + +class Solution { +public: + Node* copyRandomList(Node* head) { + unordered_map mp; + Node* cur = head; + Node node(0); + Node* dummy = &node; + while (cur) { + Node* tmp = new Node(cur->val); + dummy->next = tmp; + dummy = dummy->next; + mp.insert({cur, tmp}); + cur = cur->next; + } + cur = head; + while (cur) { + mp[cur]->random = mp[cur->random]; + cur = cur->next; + } + return node.next; + } +}; +``` diff --git a/README.md b/README.md index fb625e7..4fcbf5f 100644 --- a/README.md +++ b/README.md @@ -15,10 +15,16 @@ * [鍫哴(https://github.com/xcg1995/Code/blob/master/LeetCode/鍫.md) * [绾挎鏍慮(https://github.com/xcg1995/Code/blob/master/LeetCode/绾挎鏍.md) * [瀛楀吀鏍慮(https://github.com/xcg1995/Code/blob/master/LeetCode/瀛楀吀鏍.md) + * [鍗曡皟鏍圿(https://github.com/xcg1995/Code/blob/master/LeetCode/鍗曡皟鏍.md) + * [鍗曡皟闃熷垪]() + * [鍓嶇紑鍜宂(https://github.com/Miller-Xie/Code/blob/master/LeetCode/鍓嶇紑鍜.md) * **绠楁硶** * [浜屽垎鏌ユ壘](https://github.com/xcg1995/Code/blob/master/LeetCode/浜屽垎鏌ユ壘.md) * [鎺掑簭](https://github.com/xcg1995/Code/blob/master/LeetCode/鎺掑簭.md) + * [閫掑綊](https://github.com/Miller-Xie/Code/blob/master/LeetCode/%E9%80%92%E5%BD%92.md) * [鍔ㄦ佽鍒抅(https://github.com/xcg1995/Code/blob/master/LeetCode/鍔ㄦ佽鍒.md) + * [鍒嗘不](https://github.com/Miller-Xie/Code/blob/master/LeetCode/%E5%88%86%E6%B2%BB.md) + * [璁板繂鍖栨悳绱(https://github.com/Miller-Xie/Code/blob/master/LeetCode/%E8%AE%B0%E5%BF%86%E5%8C%96%E6%90%9C%E7%B4%A2.md) * [璐績](https://github.com/xcg1995/Code/blob/master/LeetCode/璐績.md) * [鍥炴函](https://github.com/xcg1995/Code/blob/master/LeetCode/鍥炴函.md) * [浣嶈繍绠梋(https://github.com/Making-It/Code/blob/master/LeetCode/浣嶈繍绠.md) @@ -29,5 +35,3 @@ * [mysql](https://github.com/xcg1995/Code/blob/master/LeetCode/鏁版嵁搴.md) - - diff --git "a/\345\211\221\346\214\207Offer\351\242\230\350\247\243/\345\211\221\346\214\207Offer.md" "b/\345\211\221\346\214\207Offer\351\242\230\350\247\243/\345\211\221\346\214\207Offer.md" index dfc766a..85e5fc2 100644 --- "a/\345\211\221\346\214\207Offer\351\242\230\350\247\243/\345\211\221\346\214\207Offer.md" +++ "b/\345\211\221\346\214\207Offer\351\242\230\350\247\243/\345\211\221\346\214\207Offer.md" @@ -1,10 +1,8 @@ * **鍓戞寚Offer棰樿В** - * 闈㈣瘯棰1锛歔璧嬪艰繍绠楃鍑芥暟](#璧嬪艰繍绠楃鍑芥暟) - * 闈㈣瘯棰2锛歔瀹炵幇Singleton妯″紡](#瀹炵幇Singleton妯″紡) * 闈㈣瘯棰3锛歔鏁扮粍涓噸澶嶇殑鏁板瓧](#鏁扮粍涓噸澶嶇殑鏁板瓧) * 闈㈣瘯棰4锛歔浜岀淮鏁扮粍鐨勬煡鎵綸(#浜岀淮鏁扮粍鐨勬煡鎵) * 闈㈣瘯棰5锛歔鏇挎崲绌烘牸](#鏇挎崲绌烘牸) - * 闈㈣瘯棰6锛歔浠庡ご鍒板熬鎵撳嵃閾捐〃](#浠庡ご鍒板熬鎵撳嵃閾捐〃) + * 闈㈣瘯棰6锛歔浠庡熬鍒板ご鎵撳嵃閾捐〃](#浠庡熬鍒板ご鎵撳嵃閾捐〃) * 闈㈣瘯棰7锛歔閲嶅缓浜屽弶鏍慮(#閲嶅缓浜屽弶鏍) * 闈㈣瘯棰8锛歔浜屽弶鏍戠殑涓嬩竴涓妭鐐筣(#浜屽弶鏍戠殑涓嬩竴涓妭鐐) * 闈㈣瘯棰9锛歔鐢ㄤ袱涓爤瀹炵幇闃熷垪](#鐢ㄤ袱涓爤瀹炵幇闃熷垪) @@ -67,22 +65,714 @@ * 闈㈣瘯棰66锛歔鏋勫缓涔樼Н鏁扮粍](#鏋勫缓涔樼Н鏁扮粍) # 鍓戞寚Offer棰樿В -## 璧嬪艰繍绠楃鍑芥暟 -## 瀹炵幇Singleton妯″紡 ## 鏁扮粍涓噸澶嶇殑鏁板瓧 + +[Nowcoder](https://www.nowcoder.com/practice/623a5ac0ea5b4e5f95552655361ae0a8?tpId=13&tqId=11203&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +### 棰樼洰鎻忚堪 + +鍦ㄤ竴涓暱搴︿负n鐨勬暟缁勯噷鐨勬墍鏈夋暟瀛楅兘鍦0鍒皀-1鐨勮寖鍥村唴銆 鏁扮粍涓煇浜涙暟瀛楁槸閲嶅鐨勶紝浣嗕笉鐭ラ亾鏈夊嚑涓暟瀛楁槸閲嶅鐨勩備篃涓嶇煡閬撴瘡涓暟瀛楅噸澶嶅嚑娆°傝鎵惧嚭鏁扮粍涓换鎰忎竴涓噸澶嶇殑鏁板瓧銆 渚嬪锛屽鏋滆緭鍏ラ暱搴︿负7鐨勬暟缁剓2,3,1,0,2,5,3}锛岄偅涔堝搴旂殑杈撳嚭鏄涓涓噸澶嶇殑鏁板瓧2銆 + +### 瑙ｇ瓟 + +閬嶅巻鏁扮粍锛屽垽鏂綋鍓嶅厓绱燻numbers[i]`鏄惁鍜屼綅缃甡i`鐩哥瓑锛 + +1. 濡傛灉`numbers[i] == i`锛屽垯`numbers[i]`浣嶄簬瀹冭嚜宸辩殑浣嶇疆锛宍++i`閬嶅巻涓嬩竴涓厓绱狅紱 +2. 鍚﹀垯锛屾壘鍒颁綅缃槸`numbers[i]`浣嶇疆鐨勫厓绱燻numbers[numbers[i]]`锛 + - 濡傛灉`numbers[numbers[i]] == numbers[i]`,鍒欐壘鍒伴噸澶嶅厓绱燻numbers[i]` + - 鍚﹀垯锛屼氦鎹numbers[numbers[i]]`鍜宍numbers[i]` + 閲嶅`鎯呭喌2`鐨勮繃绋嬶紝鐩村埌`numbers[i] == i`鏃讹紝鎵ц`鎯呭喌1`銆 + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O(*n*) +- 绌洪棿澶嶆潅搴︼細O(1) + +```c++ +class Solution { +public: + // Parameters: + // numbers: an array of integers + // length: the length of array numbers + // duplication: (Output) the duplicated number in the array number + // Return value: true if the input is valid, and there are some duplications in the array number + // otherwise false + bool duplicate(int numbers[], int length, int* duplication) { + if(length == 0) + return false; + + for(int i=0;i) + +### 棰樼洰鎻忚堪 + +鍦ㄤ竴涓簩缁存暟缁勪腑锛堟瘡涓竴缁存暟缁勭殑闀垮害鐩稿悓锛夛紝姣忎竴琛岄兘鎸夌収浠庡乏鍒板彸閫掑鐨勯『搴忔帓搴忥紝姣忎竴鍒楅兘鎸夌収浠庝笂鍒颁笅閫掑鐨勯『搴忔帓搴忋傝瀹屾垚涓涓嚱鏁帮紝杈撳叆杩欐牱鐨勪竴涓簩缁存暟缁勫拰涓涓暣鏁帮紝鍒ゆ柇鏁扮粍涓槸鍚﹀惈鏈夎鏁存暟銆 + +### 瑙ｇ瓟 + +鍙傝僉eetCode棰樿В [鎼滅储浜岀淮鐭╅樀II](https://github.com/Making-It/Code/blob/master/LeetCode/鏁扮粍.md#鎼滅储浜岀淮鐭╅樀II) + + + ## 鏇挎崲绌烘牸 -## 浠庡ご鍒板熬鎵撳嵃閾捐〃 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + +璇峰疄鐜颁竴涓嚱鏁帮紝灏嗕竴涓瓧绗︿覆涓殑姣忎釜绌烘牸鏇挎崲鎴愨%20鈥濄備緥濡傦紝褰撳瓧绗︿覆涓篧e Are Happy.鍒欑粡杩囨浛鎹箣鍚庣殑瀛楃涓蹭负We%20Are%20Happy銆 + +### 瑙ｇ瓟 + +涓や釜棣栧厛缁熻瀛楃涓蹭腑鐨勭┖鏍兼暟`cnt`锛岃鍘熷瓧绗︿覆鐨勯暱搴︿负`len`锛岄偅涔堟浛鎹箣鍚庡瓧绗︿覆闀垮害涓篳len + cnt * 2`锛岀劧鍚庡畾涔変袱涓寚閽坄index1`鍜宍index2`锛屽垰寮濮媊index1`鍜宍index2`鎸囧悜鍘熷瓧绗︿覆鍜屾柊瀛楃涓叉湯灏撅紝鐒跺悗鍚戝墠鍙嶅悜绉诲姩鎸囬拡锛岄愪釜灏哷index1`浣嶇疆鐨勫瓧绗﹁祴鍊肩粰`index2`浣嶇疆锛屽鏋渀index1`浣嶇疆閬囧埌绌烘牸锛屽垯鍦╜index2`浣嶇疆寮濮嬩箣鍓嶇殑涓変釜浣嶇疆璧嬪间负"%20"锛屽悓鏃禶index2`鍚戝墠绉诲姩3涓綅缃紝閲嶅浠ヤ笂杩囩▼锛岀洿鍒癭index1`鍒拌揪瀛楃涓茬涓涓瓧绗︽垨鑰卄index2 == index1`涓烘銆 + +**娉ㄦ剰**锛氬瓧绗︿覆鍙嶅悜澶嶅埗锛岄伩鍏嶅唴瀛橀噸鍙狅紒 + +**C++浠ｇ爜** + +* 鏃堕棿澶嶆潅搴︼細O(*n*) +* 绌洪棿澶嶆潅搴︼細O(1) + +```c++ +class Solution { +public: + void replaceSpace(char *str,int length) { + if(length <= 0 || !str) + return; + + int cnt=0; + for(int i=0;i= 0 && index2 > index1) + { + if(str[index1] != ' ') + { + str[index2--] = str[index1--]; + } + else{ + str[index2--] = '0'; + str[index2--] = '2'; + str[index2--] = '%'; + index1--; + } + } + + } +}; +``` + + + +**Python浠ｇ爜** + +```python +# -*- coding:utf-8 -*- +class Solution: + # s 婧愬瓧绗︿覆 + def replaceSpace(self, s): + # write code here + res = '' + for ch in s: + if ch != ' ': + res += ch + else: + res += '%20' + + return res +``` + + + +## 浠庡熬鍒板ご鎵撳嵃閾捐〃 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + +杈撳叆涓涓摼琛紝鎸夐摼琛ㄥ间粠灏惧埌澶寸殑椤哄簭杩斿洖涓涓狝rrayList銆 + +### 瑙ｇ瓟 + +#### 鏂规硶1 + +濡傛灉鍏佽鍘熷湴淇敼閾捐〃锛岃浆鎹负**鍙嶈浆閾捐〃**闂锛岃瑙乕鍙嶈浆閾捐〃](https://github.com/Making-It/Code/blob/master/LeetCode/閾捐〃.md#鍙嶈浆閾捐〃) + +* 鏃堕棿澶嶆潅搴︼細O(*n*) +* 绌洪棿澶嶆潅搴︼細O(1) + +#### 鏂规硶2 + +濡傛灉涓嶅厑璁稿師鍦颁慨鏀归摼琛紝閭ｄ箞鍙互鍒╃敤鏍堝悗杩涘厛鍑虹殑鐗圭偣锛岄亶鍘嗛摼琛紝閫愪釜灏嗛摼琛ㄥ厓绱犳斁鍏ユ爤涓紝鐒跺悗渚濇寮瑰嚭鏍堥《鍏冪礌骞舵墦鍗般 + +**C++浠ｇ爜** + +* 鏃堕棿澶嶆潅搴︼細O(*n*) +* 绌洪棿澶嶆潅搴︼細O(*n*) + +```c++ +/** +* struct ListNode { +* int val; +* struct ListNode *next; +* ListNode(int x) : +* val(x), next(NULL) { +* } +* }; +*/ +class Solution { +public: + vector printListFromTailToHead(ListNode* head) { + vector res; + if(!head) + return res; + + stack sta; + ListNode* p = head; + while(p) + { + sta.push(p->val); + p = p->next; + } + while(!sta.empty()) + { + int a = sta.top(); + sta.pop(); + res.push_back(a); + } + + return res; + } +}; +``` + + + +**Python浠ｇ爜** + +```python +# -*- coding:utf-8 -*- +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + # 杩斿洖浠庡熬閮ㄥ埌澶撮儴鐨勫垪琛ㄥ煎簭鍒楋紝渚嬪[1,2,3] + def printListFromTailToHead(self, listNode): + # write code here + sta = [] + p = listNode + while p: + sta.append(p.val) + p = p.next + + res = [] + while len(sta) > 0: + res.append(sta[-1]) + sta.pop() + + return res +``` + + + ## 閲嶅缓浜屽弶鏍 + +[NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +### 棰樼洰鎻忚堪 + +杈撳叆鏌愪簩鍙夋爲鐨勫墠搴忛亶鍘嗗拰涓簭閬嶅巻鐨勭粨鏋滐紝璇烽噸寤哄嚭璇ヤ簩鍙夋爲銆傚亣璁捐緭鍏ョ殑鍓嶅簭閬嶅巻鍜屼腑搴忛亶鍘嗙殑缁撴灉涓兘涓嶅惈閲嶅鐨勬暟瀛椼備緥濡傝緭鍏ュ墠搴忛亶鍘嗗簭鍒梴1,2,4,7,3,5,6,8}鍜屼腑搴忛亶鍘嗗簭鍒梴4,7,2,1,5,3,8,6}锛屽垯閲嶅缓浜屽弶鏍戝苟杩斿洖銆 + +### 瑙ｇ瓟 + +璇﹁LeetCode棰樿В [浠庡墠搴忎笌涓簭閬嶅巻搴忓垪鏋勯犱簩鍙夋爲](https://github.com/Making-It/Code/blob/master/LeetCode/浜屽弶鏍.md#浠庡墠搴忎笌涓簭閬嶅巻搴忓垪鏋勯犱簩鍙夋爲) + + + ## 浜屽弶鏍戠殑涓嬩竴涓妭鐐 + +[NowCoder](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +### 棰樼洰鎻忚堪 + +缁欏畾涓涓簩鍙夋爲鍜屽叾涓殑涓涓粨鐐癸紝璇锋壘鍑轰腑搴忛亶鍘嗛『搴忕殑涓嬩竴涓粨鐐瑰苟涓旇繑鍥炪傛敞鎰忥紝鏍戜腑鐨勭粨鐐逛笉浠呭寘鍚乏鍙冲瓙缁撶偣锛屽悓鏃跺寘鍚寚鍚戠埗缁撶偣鐨勬寚閽堛 + +### 瑙ｇ瓟 + +鍒嗗嚑绉嶆儏鍐佃冭檻锛 + +* 濡傛灉鑺傜偣`pNode`鏈夊彸瀛愭爲锛岄偅涔堟壘鍒癭pNode`鍙冲瓙鏍戠殑鏈宸﹁妭鐐瑰氨鏄笅涓涓妭鐐 +* 濡傛灉鑺傜偣`pNode`娌℃湁鍙冲瓙鏍戯紝鍒嗕袱绉嶆儏鍐碉細 + * 濡傛灉`pNode`鐨勭埗鑺傜偣涓虹┖锛岃繑鍥炵┖鍊糮None` + * 濡傛灉`pNode`鏄畠鐨勭埗鑺傜偣鐨勫乏瀛愯妭鐐癸紝閭ｄ箞涓嬩竴涓妭鐐规槸瀹冪殑鐖惰妭鐐 + * 濡傛灉`pNode`鏄畠鐨勭埗鑺傜偣鐨勫彸瀛愯妭鐐癸紝閭ｄ箞浠庡畠鐨勭埗鑺傜偣涓鐩村線涓婃壘锛岀洿鍒板綋鍓嶈妭鐐圭殑鐖惰妭鐐逛负绌烘垨鑰呭畠鏄埗鑺傜偣鐨勫乏瀛愯妭鐐逛负姝紝姝ゆ椂鐨勭埗鑺傜偣灏辨槸涓嬩竴涓妭鐐 + +**C++浠ｇ爜** + +```c++ +/* +struct TreeLinkNode { + int val; + struct TreeLinkNode *left; + struct TreeLinkNode *right; + struct TreeLinkNode *next; + TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) { + + } +}; +*/ +class Solution { +public: + TreeLinkNode* GetNext(TreeLinkNode* pNode) + { + TreeLinkNode* res = nullptr; + if(pNode->right) + { + res = pNode->right; + while(res->left) + { + res = res->left; + } + } + else{ + if(!pNode->next) return nullptr; + if(pNode == pNode->next->left) + res = pNode->next; + else{ + res = pNode->next; + while(res->next && res == res->next->right) + { + res = res->next; + } + res = res->next; + } + } + + return res; + } +}; +``` + +**Python浠ｇ爜** + +```python +# -*- coding:utf-8 -*- +# class TreeLinkNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None +# self.next = None +class Solution: + def GetNext(self, pNode): + # write code here + res = None + if pNode.right is not None: + res = pNode.right + while res.left is not None: + res = res.left + else: + if not pNode.next: + return None + if pNode.next and pNode == pNode.next.left: + res = pNode.next + else: + res = pNode.next + while res.next and res == res.next.right: + res = res.next + res = res.next + + return res +``` + + + ## 鐢ㄤ袱涓爤瀹炵幇闃熷垪 + +[NowCoder](https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +### 棰樼洰鎻忚堪 + +鐢ㄤ袱涓爤鏉ュ疄鐜颁竴涓槦鍒楋紝瀹屾垚闃熷垪鐨凱ush鍜孭op鎿嶄綔銆 闃熷垪涓殑鍏冪礌涓篿nt绫诲瀷銆 + +### 瑙ｇ瓟 + +缁撳悎鏍堢粨鏋勫厛杩涘悗鍑轰互鍙婇槦鍒楃粨鏋勫厛杩涘厛鍑虹殑鐗圭偣锛 + +* 褰揱push`鎿嶄綔鏃讹紝鐩存帴灏嗗厓绱犲姞鍒版爤1涓 +* 鑰屽綋`pop`鏃讹紝棣栧厛妫鏌ユ爤2锛 + * 濡傛灉鏍2鏈夊厓绱狅紝鐩存帴寮瑰嚭鏍2鐨勬爤椤跺厓绱 + * 濡傛灉鏍2涓虹┖锛屽垯閫愪釜灏嗘爤1鐨勫厓绱犲脊鍑哄苟鍔犲叆鍒版爤2涓紝鐩村埌鏍1涓虹┖锛屾渶鍚庡脊鍑烘爤2鐨勬爤椤跺厓绱犲嵆鍙 + +**C++浠ｇ爜** + +* 鏃堕棿澶嶆潅搴︼細`push`涓篛(1)锛宍pop`涓篛(*n*) +* 绌洪棿澶嶆潅搴︼細O(*n*) + +```c++ +class Solution +{ +public: + void push(int node) { + stack1.push(node); + } + + int pop() { + if(stack2.empty()) + { + if(!stack1.empty()) + { + while(!stack1.empty()) + { + int a=stack1.top(); + stack1.pop(); + stack2.push(a); + } + } + else + return 0; + } + int res=stack2.top(); + stack2.pop(); + return res; + } + +private: + stack stack1; + stack stack2; +}; +``` + +**Python浠ｇ爜** + +```python +# -*- coding:utf-8 -*- +class Solution: + def __init__(self): + self.sta1 = [] + self.sta2 = [] + def push(self, node): + # write code here + self.sta1.append(node) + def pop(self): + # return xx + if len(self.sta2) == 0: + if len(self.sta1) == 0: + return None + else: + while len(self.sta1) > 0: + self.sta2.append(self.sta1.pop()) + return self.sta2.pop() +``` + + + ## 瑁存尝閭ｅ鏁板垪 + +[NowCoder](https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking) + +### 棰樼洰鎻忚堪 + +澶у閮界煡閬撴枑娉㈤偅濂戞暟鍒楋紝鐜板湪瑕佹眰杈撳叆涓涓暣鏁皀锛岃浣犺緭鍑烘枑娉㈤偅濂戞暟鍒楃殑绗琻椤癸紙浠0寮濮嬶紝绗0椤逛负0锛夈 + +n<=39 + +### 瑙ｇ瓟 + +#### 鏂规硶1锛氶掑綊 + +浼氳繘琛屽緢澶氶噸澶嶈绠楋紝闇瑕佷紭鍖 + +* 鏃堕棿澶嶆潅搴︼細O(*2n*) +* 绌洪棿澶嶆潅搴︼細O(*n*) + +#### 鏂规硶2锛氳凯浠 + +寰幆浠ｆ浛閫掑綊锛屼紭鍖栧埌绾挎х殑鏃堕棿澶嶆潅搴 + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O(*n*) +- 绌洪棿澶嶆潅搴︼細O(*1*) + +```c++ +class Solution { +public: + int Fibonacci(int n) { + if(n <= 0) + return 0; + if(n == 1 || n == 2) + return 1; + + int pre = 1; + int last = 1; + int cur; + for(int i = 2;i < n;i++) + { + cur = pre + last; + + pre = last; + last = cur; + } + return cur; + } +}; +``` + +**Python浠ｇ爜** + +```python +# -*- coding:utf-8 -*- +class Solution: + def Fibonacci(self, n): + # write code here + if n == 0: + return 0 + if n == 1: + return 1 + pre,cur = 0,1 + for i in range(2,n+1): + nex = pre + cur + pre = cur + cur = nex + return nex +``` + + + ## 鏃嬭浆鏁扮粍鐨勬渶灏忔暟瀛 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 鐭╅樀涓殑璺緞 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 鏈哄櫒浜虹殑杩愬姩鑼冨洿 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 鍓怀瀛 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 浜岃繘鍒朵腑1鐨勪釜鏁 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 鏁板肩殑鏁存暟娆℃柟 + +[NowCoder]() + +### 棰樼洰鎻忚堪 + + + +### 瑙ｇ瓟 + + + +**C++浠ｇ爜** + +- 鏃堕棿澶嶆潅搴︼細O() +- 绌洪棿澶嶆潅搴︼細O() + +```c++ + +``` + +**Python浠ｇ爜** + +```python + +``` + + + ## 鎵撳嵃浠1鍒版渶澶х殑n浣嶆暟 ## 鍒犻櫎閾捐〃鐨勮妭鐐 ## 姝ｅ垯琛ㄨ揪寮忓尮閰