├── .gitignore ├── LICENSE ├── README.md ├── base ├── backtrack │ ├── backtrack.go │ ├── challenge │ │ ├── combinationSum.go │ │ ├── letterCombinations.go │ │ ├── partition.go │ │ └── restoreIpAddresses.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── permute.go │ │ ├── permuteUnique.go │ │ ├── subsets.go │ │ └── subsetsWithDup.go ├── binary │ ├── main │ │ └── main.go │ └── solution │ │ ├── countBits.go │ │ ├── hammingWeight.go │ │ ├── rangeBitwiseAnd.go │ │ ├── reverseBits.go │ │ ├── singleNumber.go │ │ ├── singleNumber2.go │ │ └── singleNumber3.go ├── binarySearch │ ├── binarySearch.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── SearchRange.go │ │ ├── findMin.go │ │ ├── findMin2.go │ │ ├── firstBadVersion.go │ │ ├── search-in-rotated-sorted-array.go │ │ ├── search-in-rotated-sorted-array2.go │ │ ├── search.go │ │ ├── searchInsert.go │ │ ├── searchMatrix.go │ │ └── unsolved-maximumWhiteTiles.go ├── binarySearchTree │ ├── main │ │ └── main.go │ └── solution │ │ ├── buildTree.go │ │ ├── buildTree2.go │ │ ├── deleteNode.go │ │ ├── insertIntoBST.go │ │ ├── isBalanced.go │ │ └── isValidBST.go ├── binaryTree │ ├── BinaryTree.go │ ├── InOrderTraversal.go │ ├── LevelOrderbfs.go │ ├── PostOrderTraversal.go │ ├── PreOrder.go │ ├── Predfs.go │ ├── Predivide.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── bfs │ │ ├── LerverOrderReverse.go │ │ └── Z-traversal-level-order.go │ │ ├── binary-search │ │ ├── IsBinaryTree.go │ │ └── insert-into-a-binary-search-tree.go │ │ ├── merge │ │ ├── IsBinaryTree2.go │ │ ├── LowerCommonAncestor.go │ │ ├── MaxDepthTree.go │ │ ├── MaxDepthTree2-BalacedTree.go │ │ └── MaxPathSum.go │ │ └── reserveTree.go ├── discretization │ └── main │ │ └── main.go ├── dp │ ├── main │ │ └── main.go │ └── solution │ │ ├── coinandbag │ │ ├── backPack.go │ │ ├── backPackII.go │ │ └── coinChange.go │ │ ├── matrix_dp │ │ ├── minPathSum.go │ │ ├── uniquePaths.go │ │ └── uniquePathsWithObstacles.go │ │ ├── maxProfit.go │ │ ├── minimumTotal.go │ │ ├── sequence │ │ ├── LIS │ │ │ └── 1671.py │ │ ├── canJump.go │ │ ├── canjump2.go │ │ ├── climbStairs.go │ │ ├── lengthOfLIS.go │ │ ├── minCut.go │ │ └── wordBreak.go │ │ └── two_sequennce │ │ ├── longestCommonSubsequence.go │ │ └── minDistance.go ├── geometry │ └── main │ │ └── main.go ├── kmp │ ├── kmpmoudle.go │ └── main │ │ └── main.go ├── linkedList │ ├── LinkedList.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── DeleteDuplicates.go │ │ ├── DeleteDuplicates2.go │ │ ├── DetectCycle.go │ │ ├── MergeTwoLists.go │ │ ├── Partition.go │ │ ├── ReorderList.go │ │ ├── ReverseList.go │ │ ├── ReverseList2.go │ │ ├── SortList.go │ │ ├── copyRandomList.go │ │ ├── hasCycle.go │ │ └── isPalindrome.go ├── numberTheory │ ├── main │ │ └── main.go │ ├── md │ │ └── number.md │ └── quickpow.go ├── queue │ ├── main │ │ └── main.go │ └── solution │ │ ├── myQueue-levelorder.go │ │ ├── myQueue.go │ │ └── updateMatrix.go ├── recursion │ ├── main │ │ └── main.go │ └── solution │ │ ├── fib.go │ │ ├── generateTrees.go │ │ ├── reverseString.go │ │ └── swapPairs.go ├── segmentTree │ ├── main │ │ └── main.go │ ├── segmentTreeMoudle.go │ └── solution │ │ └── 2022-6-6-Book.go ├── shortestpath │ ├── bellma-ford │ │ └── bellman-ford.go │ ├── shortestpath.go │ └── spfa │ │ └── spfa.go ├── slidingwindow │ ├── main │ │ └── main.go │ └── solution │ │ ├── findAnagrams.go │ │ ├── lengthOfLongestSubstring.go │ │ └── minWindow.go ├── sort │ ├── MergeSort.go │ ├── QuickSelect.go │ ├── QuickSort.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── heapSort.go │ │ ├── mergeSort.go │ │ └── quickSort.go ├── sql │ ├── 1.sql │ ├── 10.sql │ ├── 11.sql │ ├── 12.sql │ ├── 13.sql │ ├── 14.sql │ ├── 15.sql │ ├── 16-1148.sql │ ├── 17-197.sql │ ├── 18-607.sql │ ├── 19-1141.sql │ ├── 2.sql │ ├── 20-1693.sql │ ├── 21-1729.sql │ ├── 22-586.sql │ ├── 23-511.sql │ ├── 24-1890.sql │ ├── 25-1741.sql │ ├── 26-1393.sql │ ├── 27-1407.sql │ ├── 28-1158.sql │ ├── 29-182.sql │ ├── 3.sql │ ├── 30-1050.sql │ ├── 31-1587.sql │ ├── 32-1084.sql │ ├── 4.sql │ ├── 5.sql │ ├── 6.sql │ ├── 7.sql │ ├── 8.sql │ └── 9.sql ├── stack │ ├── graphNode.go │ ├── main │ │ └── main.go │ └── solution │ │ ├── cloneGraph-dfs.go │ │ ├── decodeString.go │ │ ├── evalStack.go │ │ ├── largestRectangleArea.go │ │ ├── minStack.go │ │ └── numIslands.go ├── trie │ ├── trie │ │ └── main.go │ └── trieXor │ │ └── main.go └── unionFind │ └── moudle.go ├── everydaytea ├── 00_cfinput.txt ├── 00_tmpl.py ├── 00_tmpl │ └── 00_tmpl.go ├── 2022-09 │ ├── 9-21.py │ ├── 9-22.py │ ├── 9-26.py │ ├── 9-27.py │ ├── 9-28.py │ ├── 9-28 │ │ └── 9-28.go │ ├── 9-29.py │ ├── 9-30.py │ ├── 9_20.py │ ├── CF522D.py │ └── CF522D │ │ └── CF522D.go └── 2023-02 │ ├── 02-09.py │ ├── 02-10-cf.py │ └── 02-17-cf.py ├── images └── header_min.png ├── leetcode ├── everyday │ ├── 2022 │ │ ├── 2022-05 │ │ │ ├── 5-10-unsolved-canMouseWin.go │ │ │ ├── 5-16-inorderSuccessor.go │ │ │ ├── 5-17-isAlienSorted.go │ │ │ ├── 5-18-findKthNumber.go │ │ │ ├── 5-19-minMoves2.go │ │ │ ├── 5-20-findRightInterval.go │ │ │ ├── 5-21-repeatedNTimes.go │ │ │ ├── 5-22-canIWin.go │ │ │ ├── 5-23-cutOffTree.go │ │ │ ├── 5-24-isUnivalTree.go │ │ │ ├── 5-25-findSubstringInWraproundString.go │ │ │ ├── 5-26-fallingSquares.go │ │ │ ├── 5-27-findClosest.go │ │ │ ├── 5-28-removeOuterParentheses.go │ │ │ ├── 5-29-validIPAddress.go │ │ │ ├── 5-30-sumRootToLeaf.go │ │ │ ├── 5-31-alienOrder.go │ │ │ ├── diStringMatch.go │ │ │ ├── minDeletionSize.go │ │ │ ├── oneEditAway.go │ │ │ └── serializeanddeserializeTree.go │ │ ├── 2022-06 │ │ │ ├── 6-11-minFlipsMonoIncr.go │ │ │ ├── 6-12-findAndReplacePattern.go │ │ │ ├── 6-13-heightChecker.go │ │ │ ├── 6-14-findDiagonalOrder.go │ │ │ ├── 6-15-smallestDistancePair.go │ │ │ ├── 6-16-findPairs.go │ │ │ ├── 6-17-duplicateZeros.go │ │ │ ├── 6-18-insert.go │ │ │ ├── 6-19-findFrequentTreeSum.go │ │ │ ├── 6-20-RangeModule.go │ │ │ ├── 6-21-defangIPaddr.go │ │ │ ├── 6-22-findBottomLeftValue.go │ │ │ ├── 6-23-findSubstring.go │ │ │ ├── 6-24-largestValues.go │ │ │ ├── 6-26-Pick.go │ │ │ ├── 6-27-findLUSlength.go │ │ │ ├── 6-28-wiggleSort.go │ │ │ ├── 6-29-encodedecode.go │ │ │ ├── 6-30-numPrimeArrangements.go │ │ │ ├── binarysearch │ │ │ │ └── 6-7-minEatingSpeed.go │ │ │ ├── binarytree │ │ │ │ └── 6-2-deleteNode.go │ │ │ ├── dfs │ │ │ │ └── 6-1-makesquare.go │ │ │ ├── dp │ │ │ │ └── 6-10-countPalindromicSubsequences │ │ │ │ │ ├── 6-10-CountPalindromicSubsequences.md │ │ │ │ │ └── 6-10-countPalindromicSubsequences.go │ │ │ ├── number │ │ │ │ ├── 6-3-consecutiveNumbersSum.go │ │ │ │ ├── 6-5-RandPoint.go │ │ │ │ ├── 6-8-isBoomerang.go │ │ │ │ └── 6-9-Pick.go │ │ │ ├── segmentTree │ │ │ │ ├── 6-6-Book.go │ │ │ │ └── 6-6-book-moudle.go │ │ │ └── unknow │ │ │ │ └── 6-4-numUniqueEmails.go │ │ ├── 2022-07 │ │ │ ├── 2022-7-23.go │ │ │ ├── 2022-7-24.go │ │ │ ├── 2022-7-25.go │ │ │ ├── 2022-7-26.go │ │ │ ├── 2022-7-27.go │ │ │ ├── 2022-7-28.go │ │ │ ├── 2022-7-29.go │ │ │ ├── 2022-7-30.go │ │ │ ├── 7-1-diffWaysToCompute.go │ │ │ ├── 7-11-MagicDictionary.go │ │ │ ├── 7-12-oddCells.go │ │ │ ├── 7-13-asteroidCollision.go │ │ │ ├── 7-14-WordFilter.go │ │ │ ├── 7-15-intersect-unresolved.go │ │ │ ├── 7-16-arrayNesting.go │ │ │ ├── 7-18-containVirus.go │ │ │ ├── 7-19-MyCalendarTwo.go │ │ │ ├── 7-2-minRefuelStops.go │ │ │ ├── 7-20-shiftGrid.go │ │ │ ├── 7-21-pruneTree.go │ │ │ ├── 7-22-intersectionSizeTwo.go │ │ │ ├── 7-3-nextGreaterElement.go │ │ │ ├── 7-4-minimumAbsDifference.go │ │ │ ├── 7-5-2-MyCalendar.go │ │ │ ├── 7-5-MyCalendar.go │ │ │ ├── 7-6-evaluate-未解决.go │ │ │ ├── 7-7-replaceWords.go │ │ │ └── 7-8-minCostToMoveChips.go │ │ ├── 2022-08 │ │ │ ├── 2022-8-10.go │ │ │ ├── 2022-8-11.go │ │ │ ├── 2022-8-12.go │ │ │ ├── 2022-8-14.go │ │ │ ├── 2022-8-15.go │ │ │ ├── 2022-8-16.go │ │ │ ├── 2022-8-17.go │ │ │ ├── 2022-8-18.go │ │ │ ├── 2022-8-19.go │ │ │ ├── 2022-8-2.go │ │ │ ├── 2022-8-22.go │ │ │ ├── 2022-8-23.go │ │ │ ├── 2022-8-25.go │ │ │ ├── 2022-8-3.go │ │ │ ├── 2022-8-30.go │ │ │ ├── 2022-8-31.go │ │ │ ├── 2022-8-4.go │ │ │ ├── 2022-8-5.go │ │ │ ├── 2022-8-6.go │ │ │ ├── 2022-8-8.go │ │ │ └── 2022-8-9.go │ │ ├── 2022-09 │ │ │ ├── 2022-9-12.go │ │ │ ├── 2022-9-13.go │ │ │ ├── 2022-9-15.go │ │ │ ├── 2022-9-2.go │ │ │ ├── 2022-9-5.go │ │ │ ├── 2022-9-6.go │ │ │ ├── 2022-9-8.go │ │ │ └── 2022-9-9.go │ │ ├── 2022-10 │ │ │ └── 2022-10-08.py │ │ └── 2022-11 │ │ │ ├── 2022-11-10.py │ │ │ ├── 2022-11-11.py │ │ │ ├── 2022-11-14.py │ │ │ ├── 2022-11-15.py │ │ │ ├── 2022-11-16.py │ │ │ ├── 2022-11-17.py │ │ │ ├── 2022-11-18.py │ │ │ ├── 2022-11-22.py │ │ │ ├── 2022-11-24.py │ │ │ ├── 2022-11-25.py │ │ │ └── 2022-11-30.py │ ├── 2023 │ │ ├── 2023-01 │ │ │ ├── 01-03.py │ │ │ ├── 01-04.py │ │ │ ├── 01-05.go │ │ │ ├── 01-05.py │ │ │ ├── 01-06.go │ │ │ ├── 01-09.go │ │ │ ├── 01-10.py │ │ │ └── 01-12.go │ │ ├── 2023-02 │ │ │ ├── 2023-02-08.py │ │ │ ├── 2023-02-09.py │ │ │ ├── 2023-02-10-1223.py │ │ │ ├── 2023-02-14.py │ │ │ ├── 2023-02-17.py │ │ │ ├── 2023-02-21.py │ │ │ ├── 2023-02-23.py │ │ │ └── 2023-02-27.py │ │ ├── 2023-03 │ │ │ ├── 0303.py │ │ │ ├── 0308.py │ │ │ ├── 0310.py │ │ │ ├── 0314.py │ │ │ ├── 0315.py │ │ │ ├── 0316.py │ │ │ ├── 0317.py │ │ │ ├── 0322.py │ │ │ ├── 0323.py │ │ │ ├── 0324.py │ │ │ └── 0329.py │ │ ├── 2023-04 │ │ │ ├── 04-06.py │ │ │ ├── 04-10.py │ │ │ ├── 04-13.py │ │ │ ├── 04-17.py │ │ │ ├── 04-18.py │ │ │ ├── 04-19.py │ │ │ ├── 04-20.py │ │ │ ├── 04-23.py │ │ │ ├── 04-24.py │ │ │ ├── 04-28.py │ │ │ └── test.js │ │ ├── 2023-05 │ │ │ ├── 05-08.py │ │ │ ├── 05-16.py │ │ │ ├── 05-18.py │ │ │ ├── 05-19.py │ │ │ ├── 05-22.py │ │ │ ├── 05-25.py │ │ │ └── 05-31.py │ │ ├── 2023-06 │ │ │ └── 06-16.py │ │ ├── 2023-09 │ │ │ └── 09-07.py │ │ └── 2023-12 │ │ │ └── 12-5.py │ ├── 2025 │ │ └── 2025-01 │ │ │ ├── 01-01.py │ │ │ ├── 01-02.py │ │ │ └── 01-06.py │ └── main.go ├── lcp │ ├── main.go │ └── solution │ │ ├── 1.go │ │ ├── 2.go │ │ ├── 3.go │ │ ├── 4-二分图最大匹配模版.go │ │ └── 5.go ├── offer │ ├── main.go │ ├── offerii │ │ ├── 10-i.go │ │ ├── 10-ii.go │ │ ├── 11.go │ │ ├── 13.go │ │ ├── 14-i.go │ │ ├── 14-ii.go │ │ ├── 15.go │ │ ├── 16.go │ │ ├── 17.go │ │ ├── 18.go │ │ ├── 19.go │ │ ├── 20.go │ │ ├── 21.go │ │ ├── 3.go │ │ ├── 31.go │ │ ├── 4.go │ │ ├── 5.go │ │ ├── 6.go │ │ ├── 7.go │ │ ├── 9.go │ │ └── main.go │ └── offer专项突击 │ │ ├── 1-30 │ │ ├── 1.go │ │ ├── 10.go │ │ ├── 11.go │ │ ├── 12.go │ │ ├── 13.go │ │ ├── 14.go │ │ ├── 15.go │ │ ├── 16.go │ │ ├── 17.go │ │ ├── 18.go │ │ ├── 19.go │ │ ├── 2.go │ │ ├── 20.go │ │ ├── 21.go │ │ ├── 22.go │ │ ├── 23.go │ │ ├── 24.go │ │ ├── 25.go │ │ ├── 26.go │ │ ├── 27.go │ │ ├── 28.go │ │ ├── 3.go │ │ ├── 30.go │ │ ├── 4.go │ │ ├── 5.go │ │ ├── 6.go │ │ ├── 7.go │ │ ├── 8.go │ │ └── 9.go │ │ ├── 31-60 │ │ ├── 31.go │ │ ├── 32.go │ │ ├── 33.go │ │ ├── 34.go │ │ ├── 35.go │ │ ├── 36.go │ │ ├── 37.go │ │ ├── 38.go │ │ ├── 39.go │ │ ├── 40.go │ │ ├── 41.go │ │ ├── 42.go │ │ ├── 43.go │ │ ├── 44.go │ │ ├── 45.go │ │ ├── 46.go │ │ ├── 47.go │ │ ├── 48.go │ │ ├── 49.go │ │ ├── 50.go │ │ ├── 51.go │ │ ├── 52.go │ │ ├── 53.go │ │ ├── 54.go │ │ ├── 55.go │ │ ├── 56.go │ │ ├── 57.go │ │ ├── 58.go │ │ ├── 59.go │ │ └── 60.go │ │ ├── 61-78 │ │ ├── 61.go │ │ ├── 62.go │ │ ├── 63.go │ │ ├── 64.go │ │ ├── 65.go │ │ ├── 66.go │ │ ├── 67.go │ │ ├── 68.go │ │ ├── 69.go │ │ ├── 70.go │ │ ├── 71.go │ │ ├── 72.go │ │ ├── 73.go │ │ ├── 74.go │ │ ├── 75.go │ │ ├── 76.go │ │ ├── 77.go │ │ └── 78.go │ │ ├── dfs 79-87 │ │ ├── 79.go │ │ ├── 80.go │ │ ├── 81.go │ │ ├── 82.go │ │ ├── 83.go │ │ ├── 84.go │ │ ├── 85.go │ │ ├── 86.go │ │ └── 87.go │ │ ├── dp 88-104 │ │ ├── 100.go │ │ ├── 101.go │ │ ├── 102.go │ │ ├── 103.go │ │ ├── 104.go │ │ ├── 88.go │ │ ├── 89.go │ │ ├── 90.go │ │ ├── 91.go │ │ ├── 92.go │ │ ├── 93.go │ │ ├── 94.go │ │ ├── 95.go │ │ ├── 96.go │ │ ├── 97.go │ │ ├── 98.go │ │ └── 99.go │ │ └── graph 105-119 │ │ ├── 105.go │ │ ├── 106.go │ │ ├── 107.go │ │ ├── 108.go │ │ ├── 109.go │ │ ├── 110.go │ │ ├── 111.go │ │ ├── 112.go │ │ ├── 113.go │ │ ├── 114.go │ │ ├── 115.go │ │ ├── 116.go │ │ ├── 117.go │ │ ├── 118.go │ │ └── 119.go ├── other │ ├── main.go │ ├── meituan │ │ ├── 1.go │ │ ├── 2.go │ │ ├── 3.go │ │ ├── 4.go │ │ └── 5.go │ └── tusen │ │ ├── 1 │ │ ├── 1.go │ │ ├── 2.go │ │ └── 3.go │ │ ├── 2 │ │ ├── 1.go │ │ ├── 2.go │ │ └── 3.go │ │ ├── 3 │ │ ├── 1.go │ │ └── 2.go │ │ ├── 4 │ │ ├── 1.go │ │ ├── 2.go │ │ └── 3-unsloved.go │ │ ├── 5 │ │ ├── 1.go │ │ ├── 2.go │ │ └── 3.go │ │ └── 6 │ │ ├── 1.go │ │ ├── 2.go │ │ └── 3.go ├── questionbank │ ├── 1-100 │ │ ├── 37.py │ │ ├── 40.go │ │ ├── 41.go │ │ ├── 41.py │ │ ├── 42.go │ │ ├── 43.go │ │ ├── 44.py │ │ ├── 48.go │ │ ├── 49.go │ │ ├── 50.go │ │ ├── 51.py │ │ ├── 52.py │ │ ├── 54.go │ │ ├── 56.go │ │ ├── 57.go │ │ ├── 59.go │ │ ├── 60.py │ │ ├── 61.go │ │ ├── 65.py │ │ ├── 71.go │ │ ├── 73.go │ │ ├── 75.go │ │ ├── 77.go │ │ ├── 79.go │ │ ├── 80.go │ │ ├── 89.go │ │ ├── 91.go │ │ ├── 94.go │ │ ├── 95.go │ │ ├── 96.go │ │ └── 97.go │ ├── 101-200 │ │ ├── 144.go │ │ ├── 145.go │ │ ├── 181.sql │ │ ├── 190.go │ │ └── 191.go │ ├── 1600-1700 │ │ └── 1675.py │ ├── 2000-3000 │ │ └── 2305.py │ ├── 201-300 │ │ ├── 202.go │ │ └── 290.go │ ├── 300-400 │ │ ├── 338.go │ │ ├── 363.go │ │ ├── 387.go │ │ └── 389.go │ ├── 401-500 │ │ ├── 401.go │ │ ├── 404.go │ │ └── 405.go │ ├── main.go │ └── 面试题 │ │ └── 17.14.go ├── rank │ ├── 1700-1800 │ │ ├── 1011.go │ │ ├── 1014.go │ │ ├── 1016.go │ │ ├── 1024.go │ │ ├── 1027.go │ │ ├── 1028.go │ │ ├── 1042.go │ │ ├── 1054.go │ │ ├── 1072.go │ │ ├── 1079.go │ │ ├── 1111.go │ │ ├── 1129.go │ │ ├── 1139.go │ │ ├── 1145.go │ │ ├── 1146.go │ │ ├── 1156.go │ │ ├── 1171.go │ │ ├── 1186.go │ │ ├── 1191.go │ │ ├── 1220.go │ │ ├── 1238.go │ │ ├── 1239.go │ │ ├── 1262.go │ │ ├── 1292.go │ │ ├── 1297.go │ │ ├── 1312.go │ │ ├── 1359.go │ │ ├── 1372.go │ │ ├── 1391.go │ │ ├── 1401.go │ │ ├── 1424.go │ │ ├── 1497.go │ │ ├── 1510.go │ │ ├── 1530.go │ │ ├── 1541.go │ │ ├── 1567.go │ │ ├── 1593.go │ │ ├── 1600.go │ │ ├── 1638.go │ │ ├── 1653.go │ │ ├── 1706.go │ │ ├── 1711.go │ │ ├── 1765.go │ │ ├── 1774.go │ │ ├── 1781.go │ │ ├── 1801.go │ │ ├── 1814.go │ │ ├── 1824.go │ │ ├── 1834.go │ │ ├── 1849.go │ │ ├── 1895.go │ │ ├── 1911.go │ │ ├── 1914.go │ │ ├── 1954.go │ │ ├── 1974.go │ │ ├── 2017.go │ │ ├── 2048.go │ │ ├── 2070.go │ │ ├── 2075.go │ │ ├── 2080.go │ │ ├── 2087.go │ │ ├── 2100.go │ │ ├── 2121.go │ │ ├── 2134.go │ │ ├── 2140.go │ │ ├── 2166.go │ │ ├── 2171.go │ │ ├── 2192.go │ │ ├── 2202.go │ │ ├── 2261.go │ │ ├── 2321.go │ │ ├── 2359.go │ │ ├── 2369.go │ │ ├── 764.go │ │ ├── 768.go │ │ ├── 787.go │ │ ├── 816.go │ │ ├── 826.go │ │ ├── 842.go │ │ ├── 851.go │ │ ├── 875.go │ │ ├── 886.go │ │ ├── 889.go │ │ ├── 894.go │ │ ├── 901.go │ │ ├── 918.go │ │ ├── 923.go │ │ ├── 939.go │ │ ├── 948.go │ │ ├── 958.go │ │ ├── 966.go │ │ ├── 971.go │ │ ├── 979.go │ │ └── 983.go │ └── 1800-1900 │ │ └── 823.py └── weekcontest │ ├── 350 │ ├── 1.py │ ├── 2.py │ ├── 2172.py │ └── 4.py │ ├── 351 │ ├── 1.py │ ├── 2.py │ ├── 3.py │ └── 4.py │ ├── 2022-7-17 │ ├── 1.go │ ├── 2.go │ ├── 3.go │ └── 4.go │ ├── 2022-7-24 │ ├── 1.go │ ├── 2.go │ ├── 3.go │ ├── 4.go │ └── main.go │ ├── b107 │ ├── 1.py │ ├── 2.py │ ├── 3.py │ └── 4.py │ └── main │ ├── 1.go │ ├── 2.go │ ├── 3.go │ ├── 4.go │ ├── main.go │ └── moudle.go ├── original ├── main │ └── main.go └── solution │ ├── concert │ └── main.go │ ├── lc.py │ ├── main.go │ ├── oj │ └── main.go │ ├── traval │ └── main.go │ ├── 插班生 │ └── main.go │ └── 最长公共子串 │ └── main.go ├── test.js └── test.ts /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | .DS_Store 3 | .vscode 4 | .idea -------------------------------------------------------------------------------- /base/backtrack/backtrack.go: -------------------------------------------------------------------------------- 1 | package backtrack 2 | 3 | // 背景 4 | // 回溯法（backtrack）常用于遍历列表所有子集，是 DFS 深度搜索一种，一般用于全排列，穷尽所有可能， 5 | // 遍历的过程实际上是一个决策树的遍历过程。时间复杂度一般 O(N!)，它不像动态规划存在重叠子问题可以优化， 6 | // 回溯算法就是纯暴力穷举，复杂度一般都很高。 7 | // 模板 8 | // result = [] 9 | // func backtrack(选择列表,路径): 10 | // if 满足结束条件: 11 | // result.add(路径) 12 | // return 13 | // for 选择 in 选择列表: 14 | // 做选择 15 | // backtrack(选择列表,路径) 16 | // 撤销选择 17 | // 核心就是从选择列表里做一个选择，然后一直递归往下搜索答案，如果遇到路径不通，就返回来撤销这次选择。 18 | -------------------------------------------------------------------------------- /base/backtrack/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | //challenge.LetterCombinations("23") 7 | //a := make([]challenge.Ans, 1) 8 | //a[0].Cnt++ 9 | //print(a[0].Cnt) 10 | a := make([]int, 1) 11 | a = []int{12,3,4} 12 | for i, num := range a { 13 | fmt.Println(i, num) 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /base/backtrack/solution/subsets.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // https://leetcode.cn/problems/subsets/ 4 | 5 | func Subsets(nums []int) [][]int { 6 | res := make([][]int, 0) 7 | if len(nums) == 0 { 8 | return res 9 | } 10 | lst := make([]int, 0) 11 | dfs(lst, nums, 0, &res) 12 | return res 13 | } 14 | 15 | func dfs(lst, nums []int, p int, res *[][]int) { 16 | *res = append(*res, lst) 17 | for i := p; i < len(nums); i++ { 18 | lst = append(lst, nums[i]) 19 | dfs(lst, nums, i+1, res) 20 | lst = lst[:len(lst)-1] 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /base/binary/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | func main() { 6 | a := 10 7 | print(strconv.Itoa(a)) 8 | } 9 | -------------------------------------------------------------------------------- /base/binary/solution/countBits.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。 4 | func countBits(num int) []int { 5 | res := make([]int, num+1) 6 | for i := 0; i <= num; i++ { 7 | res[0] = count(i) 8 | } 9 | return res 10 | } 11 | 12 | func count(num int) int { 13 | res := 0 14 | for num != 0 { 15 | num &= num - 1 16 | res++ 17 | } 18 | return res 19 | } 20 | -------------------------------------------------------------------------------- /base/binary/solution/hammingWeight.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。 4 | // 计算1的个数 5 | func hammingWeight(num uint32) int { 6 | res := 0 7 | for num != 0 { 8 | // 消除最后一位1 9 | num = num & (num - 1) 10 | res++ 11 | } 12 | return res 13 | } 14 | -------------------------------------------------------------------------------- /base/binary/solution/rangeBitwiseAnd.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | func rangeBitwiseAnd(left int, right int) int { 4 | var cnt int 5 | for left != right { 6 | left >>= 1 7 | right >>= 1 8 | cnt++ 9 | } 10 | return left << cnt 11 | } 12 | -------------------------------------------------------------------------------- /base/binary/solution/reverseBits.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 颠倒给定的 32 位无符号整数的二进制位。 4 | func reverseBits(num uint32) uint32 { 5 | var res uint32 6 | pow := 31 7 | for num != 0 { 8 | res += (num & 1) << pow 9 | num >>= 1 10 | pow-- 11 | } 12 | return res 13 | } 14 | -------------------------------------------------------------------------------- /base/binary/solution/singleNumber.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 4 | func singleNumber(nums []int) int { 5 | var res int 6 | for i := 0; i < len(nums); i++ { 7 | res = res ^ nums[i] 8 | } 9 | return res 10 | } 11 | -------------------------------------------------------------------------------- /base/binary/solution/singleNumber2.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。 4 | // 计算每一位上的1，然后计算%3之后的1就是只出现1次的元素的位值 5 | func singleNumber2(nums []int) int { 6 | var res int 7 | for i := 0; i < 64; i++ { 8 | sum := 0 9 | for j := 0; j < len(nums); j++ { 10 | // 左移动之后最后一位是1 11 | sum += (nums[j] >> i) & 1 12 | } 13 | res |= (sum % 3) << i 14 | } 15 | return res 16 | } 17 | -------------------------------------------------------------------------------- /base/binary/solution/singleNumber3.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。 4 | // [2,3,4,5,4,5] 5 | func singleNumber3(nums []int) []int { 6 | var res int 7 | for i := 0; i < len(nums); i++ { 8 | res = res ^ nums[i] 9 | } 10 | // res = a ^ b 11 | // 找到最接近找的位置 12 | r := []int{res, res} 13 | // 根据最后一位1的位置进行进行区分 14 | // 获取最后一个1 15 | diff := (res & (res - 1)) ^ res 16 | for i := 0; i < len(nums); i++ { 17 | if diff&nums[i] == 0 { 18 | r[0] = r[0] ^ nums[i] 19 | } else { 20 | r[1] = r[1] ^ nums[i] 21 | } 22 | } 23 | return r 24 | } 25 | -------------------------------------------------------------------------------- /base/binarySearch/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /base/binarySearch/solution/findMin.go: -------------------------------------------------------------------------------- 1 | package solution 2 | // https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/ 3 | // 假设按照升序排序的数组在预先未知的某个点上进行了旋转 4 | // ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 请找出其中最小的元素。 5 | // [7,0,1,2,4,5,6] 6 | func findMin(nums []int) int { 7 | // 把最后一个作为target 8 | if len(nums) == 0 { 9 | return -1 10 | } 11 | l := 0 12 | r := len(nums) - 1 13 | for l+1 < r { 14 | mid := l + (r-l)/2 15 | if nums[mid] <= nums[r] { 16 | r = mid 17 | } else { 18 | l = mid 19 | } 20 | } 21 | if nums[l] > nums[r] { 22 | return nums[r] 23 | } 24 | return nums[l] 25 | } 26 | -------------------------------------------------------------------------------- /base/binarySearch/solution/findMin2.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 与1的区别是元素可能存在重复元素 4 | func findMin2(nums []int) int { 5 | // 把最后一个作为target 6 | if len(nums) == 0 { 7 | return -1 8 | } 9 | l := 0 10 | r := len(nums) - 1 11 | for l+1 < r { 12 | for l < r && nums[l] == nums[l+1] { 13 | l++ 14 | } 15 | for l < r && nums[r] == nums[r-1] { 16 | r-- 17 | } 18 | mid := l + (r-l)/2 19 | if nums[mid] <= nums[r] { 20 | r = mid 21 | } else { 22 | l = mid 23 | } 24 | } 25 | if nums[l] > nums[r] { 26 | return nums[r] 27 | } 28 | return nums[l] 29 | } 30 | -------------------------------------------------------------------------------- /base/binarySearch/solution/search.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // https://leetcode.cn/problems/search-in-rotated-sorted-array/ 4 | // 假设按照升序排序的数组在预先未知的某个点上进行了旋转。 5 | // ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 6 | // 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。 你可以假设数组中不存在重复的元素。 7 | -------------------------------------------------------------------------------- /base/binarySearch/solution/searchInsert.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。 4 | // 如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 5 | func searchInsert(nums []int, target int) int { 6 | if len(nums) == 0 { 7 | return 0 8 | } 9 | l := 0 10 | r := len(nums) - 1 11 | for l+1 < r { 12 | mid := l + (r-l)/2 13 | if nums[mid] < target { 14 | l = mid 15 | } else if nums[mid] > target { 16 | r = mid 17 | } else { 18 | return mid 19 | } 20 | } 21 | if nums[l] >= target { 22 | return l 23 | } else if nums[r] >= target { 24 | return r 25 | } else { 26 | return r + 1 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /base/binarySearchTree/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /base/binarySearchTree/solution/buildTree2.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 中+后 左中右 左右中 4 | func buildTree2(inorder []int, postorder []int) *TreeNode { 5 | var dfs func(pl, pr, ol, or int) *TreeNode 6 | dfs = func(pl, pr, ol, or int) *TreeNode { 7 | if pl > pr || ol > or { 8 | return nil 9 | } 10 | root := &TreeNode{Val: postorder[or]} 11 | if ol == or { 12 | return root 13 | } 14 | idx := pl 15 | for ; idx < len(inorder) && postorder[or] != inorder[idx]; idx++ { 16 | } 17 | lc := idx - 1 - pl + 1 18 | root.Left = dfs(pl, idx-1, ol, ol+lc-1) 19 | root.Right = dfs(idx+1, pr, ol+lc, or-1) 20 | return root 21 | } 22 | return dfs(0, len(inorder)-1, 0, len(postorder)-1) 23 | } 24 | -------------------------------------------------------------------------------- /base/binarySearchTree/solution/insertIntoBST.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | func insertIntoBST(root *binaryTree.Node, val int) *binaryTree.Node { 6 | if root == nil { 7 | return &binaryTree.Node{Val: val} 8 | } 9 | if root.Val < val { 10 | root.Right = insertIntoBST(root.Right, val) 11 | } else { 12 | root.Left = insertIntoBST(root.Left, val) 13 | } 14 | return root 15 | } 16 | -------------------------------------------------------------------------------- /base/binarySearchTree/solution/isBalanced.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import ( 4 | "algorithm-go/base/binaryTree" 5 | "math" 6 | ) 7 | 8 | // https://leetcode.cn/problems/balanced-binary-tree/ 9 | 10 | type R struct { 11 | valid bool 12 | h int 13 | } 14 | 15 | func isBalanced(root *binaryTree.Node) bool { 16 | return helperB(root).valid 17 | } 18 | func helperB(root *binaryTree.Node) (res R) { 19 | if root == nil { 20 | res.valid = true 21 | res.h = 0 22 | return 23 | } 24 | left := helperB(root.Left) 25 | right := helperB(root.Right) 26 | if left.valid && right.valid && math.Abs(float64(left.h)-float64(right.h)) <= 1 { 27 | res.valid = true 28 | } 29 | res.h = max(left.h, right.h) + 1 30 | return 31 | } 32 | -------------------------------------------------------------------------------- /base/binaryTree/BinaryTree.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | type Node struct { 4 | Left, Right *Node 5 | Val int 6 | } 7 | -------------------------------------------------------------------------------- /base/binaryTree/InOrderTraversal.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | func InOrder(root *Node) []int { 4 | if root == nil { 5 | return nil 6 | } 7 | res := make([]int, 0) 8 | stack := make([]*Node, 0) 9 | for root != nil || len(stack) != 0 { 10 | for root != nil { 11 | stack = append(stack, root) 12 | root = root.Left 13 | } 14 | 15 | node := stack[len(stack)-1] 16 | stack = stack[:len(stack)-1] 17 | res = append(res, node.Val) 18 | root = node.Right 19 | } 20 | return res 21 | } 22 | 23 | // Morris 空间复杂下降到1 24 | func Morris(root *Node) { 25 | 26 | } 27 | -------------------------------------------------------------------------------- /base/binaryTree/LevelOrderbfs.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | func LevelOrder(root *Node) [][]int { 4 | res := make([][]int, 0) 5 | queue := make([]*Node, 0) 6 | 7 | if root == nil { 8 | return res 9 | } 10 | queue = append(queue, root) 11 | for len(queue) > 0 { 12 | node := queue[0] 13 | queue = queue[1:] 14 | list := make([]int, 0) 15 | list = append(list, node.Val) 16 | if node.Left != nil { 17 | queue = append(queue, node.Left) 18 | } 19 | if node.Right != nil { 20 | queue = append(queue, node.Right) 21 | } 22 | res = append(res, list) 23 | } 24 | return res 25 | } 26 | -------------------------------------------------------------------------------- /base/binaryTree/PostOrderTraversal.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | // 深度搜索，从下到上，分治 4 | // 左右中 5 | func PostOrder(root *Node) []int { 6 | if root == nil { 7 | return nil 8 | } 9 | res := make([]int, 0) 10 | stack := make([]*Node, 0) 11 | var lastVisit *Node 12 | for root != nil || len(stack) != 0 { 13 | for root != nil { 14 | stack = append(stack, root) 15 | root = root.Left 16 | } 17 | node := stack[len(stack)-1] 18 | if node.Right == nil || node.Right == lastVisit { 19 | res = append(res, node.Val) 20 | stack = stack[:len(stack)-1] 21 | lastVisit = node 22 | } else { 23 | root = node.Right 24 | } 25 | } 26 | return res 27 | } 28 | -------------------------------------------------------------------------------- /base/binaryTree/PreOrder.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | // print proOrder num 4 | func PreOrder(root *Node) []int { 5 | if root == nil { 6 | return make([]int, 0) 7 | } 8 | res := make([]int, 0) 9 | stack := make([]*Node, 0) 10 | for root != nil || len(stack) != 0 { 11 | for root != nil { 12 | res = append(res, root.Val) 13 | stack = append(stack, root) 14 | root = root.Left 15 | } 16 | node := stack[len(stack)-1] 17 | stack = stack[:len(stack)-1] 18 | root = node.Right 19 | } 20 | return res 21 | } 22 | -------------------------------------------------------------------------------- /base/binaryTree/Predfs.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | // 深度搜索从上到下 4 | func PreDfs(root *Node) []int { 5 | res := make([]int, 0) 6 | dfs(root, &res) 7 | return res 8 | } 9 | 10 | func dfs(root *Node, res *[]int) { 11 | if root == nil { 12 | return 13 | } 14 | *res = append(*res, root.Val) 15 | dfs(root.Left, res) 16 | dfs(root.Right, res) 17 | } 18 | -------------------------------------------------------------------------------- /base/binaryTree/Predivide.go: -------------------------------------------------------------------------------- 1 | package binaryTree 2 | 3 | // 深度搜索，从下到上 4 | func PreDivide(root *Node) []int { 5 | res := make([]int, 0) 6 | res = divide(root) 7 | return res 8 | } 9 | 10 | func divide(root *Node) []int { 11 | res := make([]int, 0) 12 | if root == nil { 13 | return res 14 | } 15 | left := divide(root.Left) 16 | right := divide(root.Right) 17 | 18 | res = append(res, root.Val) 19 | res = append(res, left...) 20 | res = append(res, right...) 21 | return res 22 | } 23 | -------------------------------------------------------------------------------- /base/binaryTree/solution/bfs/LerverOrderReverse.go: -------------------------------------------------------------------------------- 1 | package bfs 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // 从底向上遍历 6 | func LevelOrderReverse(root *binaryTree.Node) [][]int { 7 | res := make([][]int, 0) 8 | res = binaryTree.LevelOrder(root) 9 | reverse(res) 10 | return res 11 | } 12 | 13 | func reverse(num [][]int) { 14 | for i, j := 0, len(num)-1; i < j; i, j = i+1, j-1 { 15 | num[i], num[j] = num[j], num[i] 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /base/binaryTree/solution/binary-search/insert-into-a-binary-search-tree.go: -------------------------------------------------------------------------------- 1 | package binary_search 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 6 | // https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/ 7 | 8 | func InsertTree(root *binaryTree.Node, val int) *binaryTree.Node { 9 | if root == nil { 10 | node := &binaryTree.Node{ 11 | Val: val, 12 | } 13 | root = node 14 | return root 15 | } 16 | if root.Val > val { 17 | root.Left = InsertTree(root.Left, val) 18 | } else { 19 | root.Right = InsertTree(root.Right, val) 20 | } 21 | return root 22 | } 23 | -------------------------------------------------------------------------------- /base/binaryTree/solution/merge/LowerCommonAncestor.go: -------------------------------------------------------------------------------- 1 | package merge 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | func LowerCommAncestor(root, p, q *binaryTree.Node) *binaryTree.Node { 6 | if root == nil { 7 | return root 8 | } 9 | if root == p || root == q { 10 | return root 11 | } 12 | left := LowerCommAncestor(root.Left, p, q) 13 | right := LowerCommAncestor(root.Right, p, q) 14 | 15 | if left != nil && right != nil { 16 | return root 17 | } 18 | if left != nil { 19 | return left 20 | } 21 | 22 | if right != nil { 23 | return right 24 | } 25 | return nil 26 | } 27 | -------------------------------------------------------------------------------- /base/binaryTree/solution/merge/MaxDepthTree.go: -------------------------------------------------------------------------------- 1 | package merge 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // 分治法 6 | func MaxDepth(root *binaryTree.Node) int { 7 | if root == nil { 8 | return 0 9 | } 10 | left := MaxDepth(root.Left) 11 | right := MaxDepth(root.Right) 12 | 13 | if left > right { 14 | return left + 1 15 | } 16 | 17 | return right + 1 18 | } 19 | -------------------------------------------------------------------------------- /base/binaryTree/solution/merge/MaxDepthTree2-BalacedTree.go: -------------------------------------------------------------------------------- 1 | package merge 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | func IsBalanced(root *binaryTree.Node) bool { 6 | if root == nil { 7 | return true 8 | } 9 | if maxDepth(root) == -1 { 10 | return false 11 | } 12 | return true 13 | } 14 | 15 | // 分治 16 | func maxDepth(root *binaryTree.Node) int { 17 | if root == nil { 18 | return 0 19 | } 20 | left := maxDepth(root.Left) 21 | right := maxDepth(root.Right) 22 | 23 | if left == -1 || right == -1 || left-right > 1 || right-left > 1 { 24 | return -1 25 | } 26 | if left > right { 27 | return left + 1 28 | } 29 | return right + 1 30 | } 31 | -------------------------------------------------------------------------------- /base/discretization/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 离散化待填坑 4 | func main() { 5 | res := [][]int{{1, 2}} 6 | for i, v := range res { 7 | println(i, v[1]) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /base/dp/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | s := "aab" 5 | print(s[len(s)-1]) 6 | } 7 | -------------------------------------------------------------------------------- /base/dp/solution/coinandbag/backPackII.go: -------------------------------------------------------------------------------- 1 | package coinandbag 2 | 3 | // https://www.lintcode.com/problem/125/ 4 | // 有 n 个物品和一个大小为 m 的背包. 5 | // 给定数组 A 表示每个物品的大小和数组 V 表示每个物品的价值. 问最多能装入背包的总价值是多大? 6 | // 前i个物品在j大小的背包里能放的最大价值 7 | func backPackII(m int, A []int, V []int) int { 8 | dp := make([][]int, len(A)+1) 9 | for i := 0; i < len(dp); i++ { 10 | dp[i] = make([]int, m+1) 11 | } 12 | for i := 1; i <= len(A); i++ { 13 | for j := 1; j <= m; j++ { 14 | if j-A[i-1] < 0 { 15 | dp[i][j] = dp[i-1][j] 16 | } else { 17 | // 在不放该物品前的最大价值和放物品后加上该物品的价值之间取最大值 18 | dp[i][j] = max(dp[i-1][j], dp[i-1][j-A[i-1]]+V[i-1]) 19 | } 20 | } 21 | } 22 | return dp[len(A)][m] 23 | } 24 | -------------------------------------------------------------------------------- /base/dp/solution/coinandbag/coinChange.go: -------------------------------------------------------------------------------- 1 | package coinandbag 2 | 3 | // https://leetcode.cn/problems/coin-change/ 4 | // dp 设置amount最少需要多少硬币 5 | func coinChange(coins []int, amount int) int { 6 | dp := make([]int, amount+1) 7 | for i := 0; i <= amount; i++ { 8 | dp[i] = amount + 1 9 | } 10 | dp[0] = 0 11 | for i := 0; i < len(coins); i++ { 12 | for j := 1; j <= amount; j++ { 13 | // 如果j比当前硬币数额大，减去之后的dp+1就是现在的数额 14 | if j-coins[i] >= 0 { 15 | dp[j] = min(dp[j], dp[j-coins[i]]+1) 16 | } 17 | } 18 | } 19 | if dp[amount] > amount { 20 | return -1 21 | } 22 | return dp[amount] 23 | } 24 | func min(a, b int) int { 25 | if a < b { 26 | return a 27 | } else { 28 | return b 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /base/dp/solution/matrix_dp/minPathSum.go: -------------------------------------------------------------------------------- 1 | package matrix_dp 2 | 3 | func minPathSum(grid [][]int) int { 4 | if len(grid) == 0 || len(grid[0]) == 0 { 5 | return 0 6 | } 7 | for i := 0; i < len(grid); i++ { 8 | for j := 0; j < len(grid[i]); j++ { 9 | if j-1 < 0 && i-1 >= 0 { 10 | grid[i][j] = grid[i-1][j] + grid[i][j] 11 | } else if j-1 >= 0 && i-1 < 0 { 12 | grid[i][j] = grid[i][j-1] + grid[i][j] 13 | } else if j-1 >= 0 && i-1 >= 0 { 14 | grid[i][j] = min(grid[i][j-1], grid[i-1][j]) + grid[i][j] 15 | } 16 | } 17 | } 18 | return grid[len(grid)-1][len(grid[0])-1] 19 | } 20 | 21 | func min(a, b int) int { 22 | if a < b { 23 | return a 24 | } else { 25 | return b 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /base/dp/solution/matrix_dp/uniquePaths.go: -------------------------------------------------------------------------------- 1 | package matrix_dp 2 | 3 | // 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 4 | // 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 5 | // 问总共有多少条不同的路径？ 6 | 7 | func uniquePaths(m int, n int) int { 8 | res := make([][]int, m) 9 | for i := 0; i < m; i++ { 10 | for j := 0; j < n; j++ { 11 | if res[i] == nil { 12 | res[i] = make([]int, n) 13 | } 14 | res[i][j] = 1 15 | } 16 | } 17 | for i := 1; i < m; i++ { 18 | for j := 1; j < n; j++ { 19 | res[i][j] = res[i-1][j] + res[i][j-1] 20 | } 21 | } 22 | return res[m-1][n-1] 23 | } 24 | -------------------------------------------------------------------------------- /base/dp/solution/maxProfit.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "math" 4 | 5 | func maxProfit(prices []int) int { 6 | minprice := math.MaxInt 7 | maxprofit := 0 8 | for i := 0; i < len(prices); i++ { 9 | if prices[i] < minprice { 10 | minprice = prices[i] 11 | } else if prices[i]-minprice > maxprofit { 12 | maxprofit = prices[i] - minprice 13 | } 14 | } 15 | return maxprofit 16 | } 17 | -------------------------------------------------------------------------------- /base/dp/solution/sequence/canJump.go: -------------------------------------------------------------------------------- 1 | package sequence 2 | 3 | // 给定一个非负整数数组，你最初位于数组的第一个位置。 4 | // 数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置. 5 | func canJump(nums []int) bool { 6 | if len(nums) == 0 { 7 | return true 8 | } 9 | r := make([]bool, len(nums)) 10 | r[0] = true 11 | for i := 1; i < len(nums); i++ { 12 | for j := 0; j < i; j++ { 13 | if r[j] == true && nums[j]+j >= i { 14 | r[i] = true 15 | } 16 | } 17 | } 18 | return r[len(nums)-1] 19 | } 20 | -------------------------------------------------------------------------------- /base/dp/solution/sequence/canjump2.go: -------------------------------------------------------------------------------- 1 | package sequence 2 | 3 | // https://leetcode.cn/problems/jump-game-ii/ 4 | // 给你一个非负整数数组 nums ，你最初位于数组的第一个位置。 5 | // 数组中的每个元素代表你在该位置可以跳跃的最大长度。 6 | // 你的目标是使用最少的跳跃次数到达数组的最后一个位置。 7 | // 假设你总是可以到达数组的最后一个位置。 8 | 9 | func jump(nums []int) int { 10 | if len(nums) == 0 { 11 | return 0 12 | } 13 | r := make([]int, len(nums)) 14 | for i := 0; i < len(nums); i++ { 15 | // 先设置成最大步数 16 | r[i] = i 17 | for j := 0; j < i; j++ { 18 | if nums[j]+j >= i { 19 | r[i] = min(r[j]+1, r[i]) 20 | } 21 | } 22 | } 23 | return r[len(nums)-1] 24 | } 25 | 26 | func min(a, b int) int { 27 | if a < b { 28 | return a 29 | } else { 30 | return b 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /base/dp/solution/sequence/climbStairs.go: -------------------------------------------------------------------------------- 1 | package sequence 2 | 3 | // 假设你正在爬楼梯。需要 n 阶你才能到达楼顶 4 | // https://leetcode.cn/problems/climbing-stairs/ 5 | func climbStairs(n int) int { 6 | if n == 1 || n == 0 { 7 | return 1 8 | } 9 | f := make([]int, n+1) 10 | f[1] = 1 11 | f[2] = 2 12 | for i := 3; i <= n; i++ { 13 | f[i] = f[i-1] + f[i-2] 14 | } 15 | return f[n] 16 | } 17 | -------------------------------------------------------------------------------- /base/geometry/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 等待填坑 4 | func main() { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /base/kmp/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "algorithm-go/base/kmp" 4 | 5 | func main() { 6 | a := "ABABABCAA" 7 | b := "ABABC" 8 | next := kmp.GetNext(b) 9 | kmp.Kmp(next, b, a) 10 | } 11 | -------------------------------------------------------------------------------- /base/linkedList/LinkedList.go: -------------------------------------------------------------------------------- 1 | package linkedList 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | type Node struct { 10 | Val int 11 | Next *Node 12 | Random *Node 13 | } 14 | -------------------------------------------------------------------------------- /base/linkedList/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "algorithm-go/base/linkedList" 5 | "algorithm-go/base/linkedList/solution" 6 | ) 7 | 8 | func main() { 9 | head := &linkedList.ListNode{Val: 1} 10 | head.Next = &linkedList.ListNode{Val: 4} 11 | head.Next.Next = &linkedList.ListNode{Val: 3} 12 | head.Next.Next.Next = &linkedList.ListNode{Val: 0} 13 | head.Next.Next.Next.Next = &linkedList.ListNode{Val: 5} 14 | head.Next.Next.Next.Next.Next = &linkedList.ListNode{Val: 2} 15 | 16 | pre := solution.ReorderList(head) 17 | for pre != nil { 18 | println(pre.Val) 19 | pre = pre.Next 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /base/linkedList/solution/DeleteDuplicates.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/linkedList" 4 | 5 | func deleteDuplicates(head *linkedList.ListNode) *linkedList.ListNode { 6 | if head == nil { 7 | return head 8 | } 9 | node := head 10 | for head != nil { 11 | // 存在[1,1,1]这种情况 12 | for head.Next != nil && head.Next.Val == head.Val { 13 | head.Next = head.Next.Next 14 | } 15 | head = head.Next 16 | } 17 | return node 18 | } 19 | -------------------------------------------------------------------------------- /base/linkedList/solution/DetectCycle.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/linkedList" 4 | 5 | // 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null 6 | func detectCycle(head *linkedList.ListNode) *linkedList.ListNode { 7 | if head == nil { 8 | return head 9 | } 10 | fast := head.Next 11 | slow := head 12 | for fast != nil && fast.Next != nil { 13 | // 如果相遇回到起点 14 | // slow得走一格 15 | // b+a+f-1+a = 2f+2a => b-1=f 16 | if fast == slow { 17 | fast = head 18 | slow = slow.Next 19 | for fast != slow { 20 | slow = slow.Next 21 | fast = fast.Next 22 | } 23 | return slow 24 | } 25 | fast = fast.Next.Next 26 | slow = slow.Next 27 | } 28 | 29 | return nil 30 | } 31 | -------------------------------------------------------------------------------- /base/linkedList/solution/MergeTwoLists.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/linkedList" 4 | 5 | // 合成两个有序链表 6 | func MergeTwoLists(l1 *linkedList.ListNode, l2 *linkedList.ListNode) *linkedList.ListNode { 7 | dummy := &linkedList.ListNode{Val: 0} 8 | res := dummy 9 | for l1 != nil && l2 != nil { 10 | if l1.Val < l2.Val { 11 | dummy.Next = l1 12 | dummy = dummy.Next 13 | l1 = l1.Next 14 | } else { 15 | dummy.Next = l2 16 | dummy = dummy.Next 17 | l2 = l2.Next 18 | } 19 | } 20 | for l1 != nil { 21 | dummy.Next = l1 22 | dummy = dummy.Next 23 | l1 = l1.Next 24 | } 25 | for l2 != nil { 26 | dummy.Next = l2 27 | dummy = dummy.Next 28 | l2 = l2.Next 29 | } 30 | return res.Next 31 | } 32 | -------------------------------------------------------------------------------- /base/linkedList/solution/ReverseList.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/linkedList" 4 | 5 | func ReverseList(head *linkedList.ListNode) *linkedList.ListNode { 6 | var prev *linkedList.ListNode 7 | if head == nil { 8 | return head 9 | } 10 | for head != nil { 11 | tmp := head.Next 12 | head.Next = prev 13 | prev = head 14 | head = tmp 15 | } 16 | return prev 17 | } 18 | -------------------------------------------------------------------------------- /base/linkedList/solution/hasCycle.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/linkedList" 4 | 5 | func hasCycle(head *linkedList.ListNode) bool { 6 | if head == nil { 7 | return false 8 | } 9 | slow := head 10 | fast := head.Next 11 | for fast != nil && fast.Next != nil { 12 | if slow == fast { 13 | return true 14 | } 15 | slow = slow.Next 16 | fast = fast.Next.Next 17 | } 18 | return false 19 | } 20 | -------------------------------------------------------------------------------- /base/numberTheory/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 填坑等待 4 | func main() { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /base/queue/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "algorithm-go/base/queue/solution" 4 | 5 | func main() { 6 | //s := "3[a]2[bc]" 7 | //res := everyday.DecodeString(s) 8 | //println(res) 9 | s := [][]int{{0, 0, 0}, {0, 1, 0}, {1, 1, 1}} 10 | mat := solution.UpdateMatrix(s) 11 | for _, v := range mat { 12 | for _, v1 := range v { 13 | print(v1, " ") 14 | } 15 | println() 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /base/recursion/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | //s := "hdsiaixsbcia" 5 | //everyday.ReverseString([]byte(s)) 6 | 7 | edge := make([]int, 4) 8 | //_, ok := m[2] 9 | print(edge[0]) 10 | 11 | } 12 | -------------------------------------------------------------------------------- /base/recursion/solution/fib.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // https://leetcode.cn/problems/fibonacci-number/ 4 | func fib(N int) int { 5 | return dfs(N) 6 | } 7 | 8 | var m map[int]int = make(map[int]int) 9 | 10 | func dfs(n int) int { 11 | if n < 2 { 12 | return n 13 | } 14 | // 读取缓存 15 | if m[n] != 0 { 16 | return m[n] 17 | } 18 | ans := dfs(n-2) + dfs(n-1) 19 | // 缓存已经计算过的值 20 | m[n] = ans 21 | return ans 22 | } 23 | -------------------------------------------------------------------------------- /base/recursion/solution/generateTrees.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // https://leetcode.cn/problems/unique-binary-search-trees-ii/ 6 | // 给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树。 7 | // 可以按 任意顺序 返回答案。 8 | 9 | // 等回溯 10 | func generateTrees(n int) []*binaryTree.Node { 11 | return nil 12 | } 13 | -------------------------------------------------------------------------------- /base/recursion/solution/reverseString.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "fmt" 4 | 5 | func ReverseString(s []byte) { 6 | res := make([]byte, len(s)) 7 | str := string(s) 8 | reverse(str, 0, res) 9 | fmt.Println(string(res)) 10 | } 11 | 12 | func reverse(s string, i int, res []byte) { 13 | if i == len(s) { 14 | return 15 | } 16 | reverse(s, i+1, res) 17 | res = append(res, s[i]) 18 | //res[len(s)-i-1] = s[i] 19 | } 20 | -------------------------------------------------------------------------------- /base/recursion/solution/swapPairs.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import ( 4 | "algorithm-go/base/linkedList" 5 | ) 6 | 7 | // https://leetcode.cn/problems/swap-nodes-in-pairs/ 8 | // 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。 9 | // 你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。 10 | func swapPairs(head *linkedList.ListNode) *linkedList.ListNode { 11 | var swap func(head *linkedList.ListNode) *linkedList.ListNode 12 | swap = func(head *linkedList.ListNode) *linkedList.ListNode { 13 | if head == nil || head.Next == nil { 14 | return nil 15 | } 16 | nextHead := head.Next.Next 17 | next := head.Next 18 | next.Next = head 19 | head.Next = swap(nextHead) 20 | return next 21 | } 22 | return swap(head) 23 | } 24 | -------------------------------------------------------------------------------- /base/segmentTree/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/falling-squares/ 4 | // 2022-5-26-lc-everyday 5 | // func fallingSquares(positions [][]int) []int { 6 | 7 | // } 8 | func main() { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /base/slidingwindow/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "algorithm-go/base/slidingwindow/solution" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | s := "abcabcbb" 10 | res := solution.LengthOfLongestSubstring(s) 11 | fmt.Println(res) 12 | } 13 | -------------------------------------------------------------------------------- /base/slidingwindow/solution/lengthOfLongestSubstring.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/longest-substring-without-repeating-characters/ 6 | // 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。 7 | 8 | func LengthOfLongestSubstring(s string) int { 9 | left, right := 0, 0 10 | ans := math.MinInt64 11 | win := map[byte]int{} 12 | var c byte 13 | for right < len(s) { 14 | c = s[right] 15 | right++ 16 | win[c]++ 17 | 18 | for win[c] > 1 { 19 | c = s[left] 20 | left++ 21 | win[c]-- 22 | } 23 | ans = max(ans, right-left) 24 | } 25 | return ans 26 | } 27 | 28 | func max(a, b int) int { 29 | if a > b { 30 | return a 31 | } else { 32 | return b 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /base/sort/QuickSelect.go: -------------------------------------------------------------------------------- 1 | package sort 2 | 3 | import "math/rand" 4 | 5 | func QuickSelect(nums []int, start, end int, tidx int) { 6 | p := rand.Intn(end-start+1) + start 7 | nums[p], nums[end] = nums[end], nums[p] 8 | p = nums[end] 9 | i, j := start, start 10 | for j < end { 11 | if nums[j] < p { 12 | nums[i], nums[j] = nums[j], nums[i] 13 | i++ 14 | j++ 15 | } else { 16 | j++ 17 | } 18 | } 19 | nums[i], nums[end] = nums[end], nums[i] 20 | if i > tidx { 21 | QuickSelect(nums, start, i-1, tidx) 22 | } else if i < tidx { 23 | QuickSelect(nums, i+1, end, tidx) 24 | } else { 25 | return 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /base/sort/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | type test struct { 5 | tmap map[string]map[string]string 6 | } 7 | func main() { 8 | // nums := []int{9, 2, 5, 4, 8, 2} 9 | // nums = solution.HeapSort(nums) 10 | // for _, val := range nums { 11 | // println(val) 12 | // } 13 | t := test{} 14 | key := "234" 15 | t.tmap = map[string]map[string]string{} 16 | t.tmap[key] = map[string]string{"2":"3"} 17 | fmt.Print(t) 18 | } 19 | -------------------------------------------------------------------------------- /base/sort/solution/heapSort.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | // 升序排列 4 | func HeapSort(nums []int) []int { 5 | if len(nums) == 0 { 6 | return nums 7 | } 8 | // 排一个最大堆, 找出最大的节点 9 | sink(nums, len(nums)) 10 | for i := len(nums) - 1; i >= 0; i-- { 11 | nums[0], nums[i] = nums[i], nums[0] 12 | sink(nums, i) 13 | } 14 | return nums 15 | } 16 | 17 | // 第一个非叶子节点是n/2-1 18 | func sink(nums []int, len int) { 19 | for i := len/2 - 1; i >= 0; i-- { 20 | left := 2*i + 1 21 | if left < len && nums[left] > nums[i] { 22 | nums[i], nums[left] = nums[left], nums[i] 23 | } 24 | right := 2*i + 2 25 | if right < len && nums[right] > nums[i] { 26 | nums[i], nums[right] = nums[right], nums[i] 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /base/sort/solution/mergeSort.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | func MergeSort(nums []int) []int { 4 | if len(nums) <= 1 { 5 | return nums 6 | } 7 | 8 | mid := len(nums) / 2 9 | left := MergeSort(nums[:mid]) 10 | right := MergeSort(nums[mid:]) 11 | res := merge(left, right) 12 | return res 13 | } 14 | 15 | func merge(l1, l2 []int) []int { 16 | m := len(l1) 17 | n := len(l2) 18 | res := make([]int, 0) 19 | var i, j int 20 | for i < m && j < n { 21 | if l1[i] < l2[j] { 22 | res = append(res, l1[i]) 23 | i++ 24 | } else { 25 | res = append(res, l2[j]) 26 | j++ 27 | } 28 | } 29 | res = append(res, l1[i:]...) 30 | res = append(res, l2[j:]...) 31 | return res 32 | } 33 | -------------------------------------------------------------------------------- /base/sort/solution/quickSort.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | func QuickSort(nums []int, start, end int) []int { 4 | quick := quickSort(nums, 0, len(nums)-1) 5 | return quick 6 | } 7 | 8 | func quickSort(nums []int, start, end int) []int { 9 | if start < end { 10 | p := partition(nums, start, end) 11 | quickSort(nums, start, p-1) 12 | quickSort(nums, p+1, end) 13 | } 14 | return nums 15 | } 16 | 17 | func partition(nums []int, start, end int) int { 18 | p := nums[end] 19 | var i int // 标记比p小的值的idx 20 | for j := start; j < end; j++ { 21 | if nums[j] < p { 22 | nums[i], nums[j] = nums[j], nums[i] 23 | i++ 24 | } 25 | } 26 | nums[i], nums[end] = nums[end], nums[i] 27 | return i 28 | } 29 | -------------------------------------------------------------------------------- /base/sql/1.sql: -------------------------------------------------------------------------------- 1 | 2 | select name,population,gdp from world 3 | where area >= 3000000 4 | and population >= 25000000 -------------------------------------------------------------------------------- /base/sql/10.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | select * from Patients 4 | where conditions like "% DIAB1%" 5 | or conditions like "DIAB1%" -------------------------------------------------------------------------------- /base/sql/11.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select employee_id 5 | from 6 | ( 7 | select employee_id from Employees 8 | union all 9 | select employee_id from Salaries 10 | ) as t 11 | group by employee_id 12 | having count(employee_id) = 1 13 | order by employee_id -------------------------------------------------------------------------------- /base/sql/12.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | select id, 6 | case when p_id is null then 'Root' 7 | when id in (select distinct p_id from tree) then 'Inner' else 'Leaf' end as type 8 | from tree 9 | order by id -------------------------------------------------------------------------------- /base/sql/13.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | select 4 | ifnull( 5 | (select distinct salary from Employee order by salary desc limit 1 offset 1), null 6 | ) as SecondHighestSalary -------------------------------------------------------------------------------- /base/sql/14.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | select firstName,lastName,city, state 5 | from Person p1 6 | left join Address p2 on p1.personId = p2.personId -------------------------------------------------------------------------------- /base/sql/15.sql: -------------------------------------------------------------------------------- 1 | 2 | # 1581 3 | # Write your MySQL query statement below 4 | 5 | select customer_id, count(customer_id) count_no_trans 6 | from Visits v1 7 | left join Transactions t on v1.visit_id = t.visit_id 8 | where amount is null 9 | group by customer_id -------------------------------------------------------------------------------- /base/sql/16-1148.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select distinct author_id as id 5 | from Views 6 | where author_id = viewer_id 7 | order by id -------------------------------------------------------------------------------- /base/sql/17-197.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select Weather.id from Weather 5 | left join Weather w on DATEDIFF(Weather.recordDate, w.recordDate) = 1 6 | where Weather.Temperature > w.Temperature 7 | -------------------------------------------------------------------------------- /base/sql/18-607.sql: -------------------------------------------------------------------------------- 1 | 2 | SELECT 3 | s.name 4 | FROM 5 | salesperson s 6 | WHERE 7 | s.sales_id NOT IN (SELECT 8 | o.sales_id 9 | FROM 10 | orders o 11 | LEFT JOIN 12 | company c ON o.com_id = c.com_id 13 | WHERE 14 | c.name = 'RED') 15 | ; 16 | 17 | -------------------------------------------------------------------------------- /base/sql/19-1141.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | select activity_date as day, count(distinct user_id) as active_users 5 | from Activity 6 | where datediff("2019-07-27", activity_date) > 0 and datediff("2019-07-27", activity_date) < 30 7 | group by activity_date -------------------------------------------------------------------------------- /base/sql/2.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select product_id from Products where low_fats = 'Y' and recyclable = 'Y' -------------------------------------------------------------------------------- /base/sql/20-1693.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | select date_id, make_name, 6 | count(distinct lead_id) unique_leads, 7 | count(distinct partner_id) unique_partners 8 | from DailySales 9 | group by date_id, make_name -------------------------------------------------------------------------------- /base/sql/21-1729.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | 6 | select user_id, count(follower_id) followers_count 7 | from Followers 8 | group by user_id 9 | order by user_id -------------------------------------------------------------------------------- /base/sql/22-586.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select customer_number 5 | from Orders 6 | group by customer_number 7 | order by count(customer_number) desc 8 | limit 1 -------------------------------------------------------------------------------- /base/sql/23-511.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select player_id, min(event_date) as first_login 4 | from Activity 5 | group by player_id 6 | order by player_id -------------------------------------------------------------------------------- /base/sql/24-1890.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | 5 | select user_id, max(time_stamp) as last_stamp 6 | from Logins 7 | where datediff(time_stamp, "2020-1-1") >= 0 and datediff(time_stamp, "2021-1-1") < 0 8 | group by user_id; 9 | 10 | # Write your MySQL query statement below 11 | 12 | 13 | select user_id, max(time_stamp) as last_stamp 14 | from Logins 15 | where year(time_stamp) = 2020 16 | group by user_id; -------------------------------------------------------------------------------- /base/sql/25-1741.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT event_day AS day,emp_id AS emp_id,sum(out_time-in_time) AS total_time 4 | FROM Employees 5 | GROUP BY event_day,emp_id; 6 | -------------------------------------------------------------------------------- /base/sql/26-1393.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | select stock_name, 6 | sum( 7 | case operation when 'Sell' 8 | then price else -price 9 | end 10 | ) as capital_gain_loss 11 | from Stocks 12 | group by stock_name; -------------------------------------------------------------------------------- /base/sql/27-1407.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | select u.name, if(sum(r.distance) is NUll, 0, sum(r.distance)) as travelled_distance 6 | from Users u 7 | left join Rides r on r.user_id = u.id 8 | group by user_id 9 | order by travelled_distance desc, name asc -------------------------------------------------------------------------------- /base/sql/28-1158.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | 5 | select user_id as buyer_id, join_date, 6 | (case when order_id is null 7 | then 0 else count(*) end) as orders_in_2019 8 | from Users u 9 | left join Orders o on u.user_id = o.buyer_id 10 | and year(order_date) = 2019 11 | group by user_id 12 | -------------------------------------------------------------------------------- /base/sql/29-182.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select Email from Person 4 | group by Email 5 | having count(Email) > 1 -------------------------------------------------------------------------------- /base/sql/3.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | # 与null值作比较需要单独列出来 4 | select name from customer where referee_id != 2 or referee_id is Null -------------------------------------------------------------------------------- /base/sql/30-1050.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select actor_id, director_id 4 | from ActorDirector 5 | group by actor_id, director_id 6 | having count(*) >=3 -------------------------------------------------------------------------------- /base/sql/31-1587.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select u.name as NAME, sum( 5 | amount 6 | ) as BALANCE 7 | from Users u, Transactions t 8 | where u.account = t.account 9 | group by u.account 10 | having sum(amount) > 10000 -------------------------------------------------------------------------------- /base/sql/32-1084.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select p.product_id, p.product_name 4 | from Product p, Sales s 5 | where p.product_id = s.product_id 6 | group by p.product_id 7 | having min(s.sale_date) >= "2019-01-01" and max(s.sale_date) <= "2019-03-31" -------------------------------------------------------------------------------- /base/sql/4.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | select name from customers left join orders 5 | on customers.id = orders.customerId where isnull(CustomerId) -------------------------------------------------------------------------------- /base/sql/5.sql: -------------------------------------------------------------------------------- 1 | 2 | select employee_id, if(employee_id % 2 =1 and left(name,1)!='M', salary, 0) as bonus 3 | from Employees 4 | order by employee_id; 5 | 6 | # case when then else end 7 | select employee_id, 8 | case 9 | when employee_id%2=1 and left(name,1)!='M' then salary else 0 10 | end as bonus 11 | from Employees 12 | order by employee_id 13 | 14 | -------------------------------------------------------------------------------- /base/sql/6.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Write your MySQL query statement below 4 | 5 | update Salary set sex = if(sex='m', 'f', 'm') -------------------------------------------------------------------------------- /base/sql/7.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | DELETE p1 from Person p1, Person p2 4 | where p1.email = p2.email and p1.id > p2.id; 5 | 6 | # Please write a DELETE statement and DO NOT write a SELECT statement. 7 | # Write your MySQL query statement below 8 | 9 | DELETE p1 from Person p1 10 | left outer join Person p2 11 | on p1.email = p2.email 12 | where p1.id > p2.id -------------------------------------------------------------------------------- /base/sql/8.sql: -------------------------------------------------------------------------------- 1 | 2 | 3 | select user_id, concat(upper(left(name,1)), lower(substr(name,2))) as name from Users 4 | order by user_id -------------------------------------------------------------------------------- /base/sql/9.sql: -------------------------------------------------------------------------------- 1 | 2 | select sell_date, 3 | count(distinct product) as num_sold, 4 | group_concat(distinct(product) separator ",") as products 5 | from Activities 6 | group by sell_date 7 | order by sell_date 8 | -------------------------------------------------------------------------------- /base/stack/graphNode.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | type Node struct { 4 | Val int 5 | Neighbors []*Node 6 | } 7 | -------------------------------------------------------------------------------- /base/stack/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /everydaytea/00_cfinput.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 4 5 7 6 7 5 4 4 6 4 3 | 输出 4 | 1 1 1 2 -1 1 1 3 1 1 5 | -------------------------------------------------------------------------------- /everydaytea/00_tmpl/00_tmpl.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | . "fmt" 6 | "io" 7 | "os" 8 | ) 9 | 10 | type seg []struct { 11 | l, r, v int 12 | } 13 | 14 | func solve(_r io.Reader, _w io.Writer) { 15 | in := bufio.NewReader(_r) 16 | out := bufio.NewWriter(_w) 17 | defer out.Flush() 18 | var n int 19 | Fscan(in, &n) 20 | 21 | } 22 | 23 | func main() { 24 | // open, _ := os.Open("/Users/zhang-wangz/Desktop/algorithm/tea_0x3f/00_cfinput.txt") 25 | // solve(open, os.Stdout) 26 | // defer open.Close() 27 | solve(os.Stdin, os.Stdout) 28 | } 29 | -------------------------------------------------------------------------------- /images/header_min.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/images/header_min.png -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/5-10-unsolved-canMouseWin.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | // https://leetcode.cn/problems/cat-and-mouse-ii/ 4 | // dfs + dp 5 | func canMouseWin(grid []string, catJump int, mouseJump int) bool { 6 | return false 7 | } 8 | 9 | func dfs(grid []string, catJump int, mouseJump int) { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/5-19-minMoves2.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii/ 6 | // 给你一个长度为 n 的整数数组 nums ，返回使所有数组元素相等需要的最少移动数。 7 | // 在一步操作中，你可以使数组中的一个元素加 1 或者减 1 。 8 | func minMoves2(nums []int) int { 9 | sort.Ints(nums) 10 | l := 0 11 | r := len(nums) - 1 12 | mid := l + (r-l)/2 13 | target := nums[mid] 14 | cnt := 0 15 | for i := 0; i < len(nums); i++ { 16 | cnt += abs(nums[i], target) 17 | } 18 | return cnt 19 | } 20 | 21 | func abs(a, b int) int { 22 | if a > b { 23 | return a - b 24 | } else { 25 | return b - a 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/5-21-repeatedNTimes.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/n-repeated-element-in-size-2n-array/ 6 | // 给你一个整数数组 nums ，该数组具有以下属性： 7 | // 8 | // nums.length == 2 * n. 9 | // nums 包含 n + 1 个 不同的 元素 10 | // nums 中恰有一个元素重复 n 次 11 | // 找出并返回重复了 n 次的那个元素。 12 | 13 | func repeatedNTimes(nums []int) int { 14 | sort.Ints(nums) 15 | mid := (len(nums) - 1) / 2 16 | if mid-1 >= 0 && nums[mid-1] == nums[mid] { 17 | return nums[mid] 18 | } else { 19 | return nums[mid+1] 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/5-24-isUnivalTree.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // https://leetcode.cn/problems/univalued-binary-tree/ 6 | 7 | func isUnivalTree(root *binaryTree.Node) bool { 8 | if root == nil { 9 | return true 10 | } 11 | val := root.Val 12 | return helperisUnivalTree(root, val) 13 | } 14 | 15 | func helperisUnivalTree(root *binaryTree.Node, val interface{}) bool { 16 | if root == nil { 17 | return true 18 | } else if root.Val != val { 19 | return false 20 | } 21 | return helperisUnivalTree(root.Left, val) && helperisUnivalTree(root.Right, val) 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/5-27-findClosest.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | // https://leetcode.cn/problems/find-closest-lcci/ 4 | // 有个内含单词的超大文本文件，给定任意两个不同的单词，找出在这个文件中这两个单词的最短距离(相隔单词数)。 5 | // 如果寻找过程在这个文件中会重复多次，而每次寻找的单词不同，你能对此优化吗? 6 | 7 | // 如果重复多次，维护words单词中的下标列表，然后双指针进行比较 8 | func findClosest(words []string, word1 string, word2 string) int { 9 | i, j := -1, -1 10 | minD := 1 << 31 11 | for idx, v := range words { 12 | if v == word1 { 13 | i = idx 14 | } else if v == word2 { 15 | j = idx 16 | } 17 | if i != -1 && j != -1 { 18 | minD = min(minD, abs(i, j)) 19 | } 20 | } 21 | return minD 22 | } 23 | func min(a, b int) int { 24 | if a < b { 25 | return a 26 | } else { 27 | return b 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/diStringMatch.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | // 由范围 [0,n] 内所有整数组成的 n + 1 个整数的排列序列可以表示为长度为 n 的字符串 s ，其中: 4 | // 5 | // 如果 perm[i] < perm[i + 1] ，那么 s[i] == 'I' 6 | // 如果 perm[i] > perm[i + 1] ，那么 s[i] == 'D' 7 | // 给定一个字符串 s ，重构排列 perm 并返回它。如果有多个有效排列perm，则返回其中 任何一个 。 8 | 9 | func diStringMatch(s string) []int { 10 | if s == " " { 11 | return []int{} 12 | } 13 | res := make([]int, 0) 14 | n := len(s) 15 | left := 0 16 | right := n 17 | for i := 0; i < n; i++ { 18 | if s[i] == 'I' { 19 | res = append(res, left) 20 | left++ 21 | } else { 22 | res = append(res, right) 23 | right-- 24 | } 25 | } 26 | res = append(res, left) 27 | return res 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-05/minDeletionSize.go: -------------------------------------------------------------------------------- 1 | package _022_05 2 | 3 | // 给你由 n 个小写字母字符串组成的数组 strs，其中每个字符串长度相等。 4 | // 这些字符串可以每个一行，排成一个网格。例如，strs = ["abc", "bce", "cae"] 可以排列为： 5 | // abc bce cae 6 | // 你需要找出并删除 不是按字典序升序排列的 列。 7 | // 在上面的例子（下标从 0 开始）中，列 0（'a', 'b', 'c'）和列 2（'c', 'e', 'e'）都是按升序排列的， 8 | // 而列 1（'b', 'c', 'a'）不是，所以要删除列 1 。 9 | // 返回你需要删除的列数。 10 | 11 | func minDeletionSize(strs []string) int { 12 | if len(strs) == 0 { 13 | return 0 14 | } 15 | cnt := 0 16 | m, n := len(strs), len(strs[0]) 17 | for i := 0; i < n; i++ { 18 | for j := 0; j < m-1; j++ { 19 | if strs[j][i] > strs[j+1][i] { 20 | cnt++ 21 | break 22 | } 23 | } 24 | } 25 | return cnt 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-06/6-17-duplicateZeros.go: -------------------------------------------------------------------------------- 1 | package _022_06 2 | 3 | // https://leetcode.cn/problems/duplicate-zeros/ 4 | // 给你一个长度固定的整数数组arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。 5 | 6 | // 注意：请不要在超过该数组长度的位置写入元素。 7 | 8 | // 要求：请对输入的数组就地进行上述修改，不要从函数返回任何东西。 9 | 10 | // 模拟栈 11 | func DuplicateZeros(arr []int) { 12 | stack := make([]int, 0) 13 | n := len(arr) 14 | for i := 0; i < n; i++ { 15 | if arr[i] == 0 { 16 | stack = append(stack, 0) 17 | } 18 | stack = append(stack, arr[i]) 19 | if len(stack) == n { 20 | break 21 | } 22 | } 23 | for i := n - 1; i >= 0; i-- { 24 | arr[i] = stack[i] 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-06/6-21-defangIPaddr.go: -------------------------------------------------------------------------------- 1 | package _022_06 2 | 3 | import "strings" 4 | 5 | // https://leetcode.cn/problems/defanging-an-ip-address/ 6 | // 给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。 7 | // 8 | // 所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。 9 | func defangIPaddr(address string) string { 10 | res := strings.Replace(address, ".", "[.]", len(address)) 11 | return res 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-06/6-22-findBottomLeftValue.go: -------------------------------------------------------------------------------- 1 | package _022_06 2 | 3 | import "algorithm-go/base/binaryTree" 4 | 5 | // https://leetcode.cn/problems/find-bottom-left-tree-value/ 6 | // 给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。 7 | // 8 | // 假设二叉树中至少有一个节点。 9 | // 写个层次遍历 10 | func findBottomLeftValue(root *binaryTree.Node) int { 11 | queue := make([]*binaryTree.Node, 0) 12 | queue = append(queue, root) 13 | var ans int 14 | for len(queue) != 0 { 15 | node := queue[0] 16 | queue = queue[1:] 17 | if node.Right != nil { 18 | queue = append(queue, node.Right) 19 | } 20 | if node.Left != nil { 21 | queue = append(queue, node.Left) 22 | } 23 | ans = node.Val 24 | } 25 | return ans 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-06/number/6-8-isBoomerang.go: -------------------------------------------------------------------------------- 1 | package number 2 | 3 | // https://leetcode.cn/problems/valid-boomerang/ 4 | // 给定一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点， 5 | // 如果这些点构成一个 回旋镖 则返回 true 。 6 | // 回旋镖 定义为一组三个点，这些点 各不相同 且 不在一条直线上 。 7 | 8 | func isBoomerang(points [][]int) bool { 9 | k1 := []int{points[0][0] - points[1][0], points[0][1] - points[1][1]} 10 | k2 := []int{points[1][0] - points[2][0], points[1][1] - points[2][1]} 11 | return k2[0]*k1[1] != k1[0]*k2[1] 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/2022-7-24.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/distance-between-bus-stops/ 6 | 7 | func distanceBetweenBusStops(distance []int, start int, destination int) int { 8 | sum1, sum2 := 0, 0 9 | if start > destination { 10 | start, destination = destination, start 11 | } 12 | for i := range distance { 13 | if start <= i && i < destination { 14 | sum1 += distance[i] 15 | } else { 16 | sum2 += distance[i] 17 | } 18 | } 19 | return int(math.Min(float64(sum1), float64(sum2))) 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/2022-7-28.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | import "sort" 4 | 5 | func arrayRankTransform(arr []int) []int { 6 | a := append([]int{}, arr...) 7 | sort.Ints(arr) 8 | n2i := map[int]int{} 9 | idx := 1 10 | for _, n := range arr { 11 | if _, ok := n2i[n]; !ok { 12 | n2i[n] = idx 13 | idx++ 14 | } 15 | } 16 | for i, n := range a { 17 | a[i] = n2i[n] 18 | } 19 | return a 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/2022-7-29.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | import "sort" 4 | 5 | func validSquare(p1 []int, p2 []int, p3 []int, p4 []int) bool { 6 | l := make([]int, 6) 7 | l[0] = countdis(p1, p2) 8 | l[1] = countdis(p1, p3) 9 | l[2] = countdis(p1, p4) 10 | l[3] = countdis(p2, p3) 11 | l[4] = countdis(p2, p4) 12 | l[5] = countdis(p3, p4) 13 | sort.Ints(l) 14 | return l[0] != 0 && l[0] == l[3] && l[4] == l[5] && l[0]*2 == l[5] 15 | } 16 | 17 | func countdis(p1, p2 []int) int { 18 | e1 := p1[0] - p2[0] 19 | e2 := p1[1] - p2[1] 20 | return e1*e1 + e2*e2 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-12-oddCells.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | //https://leetcode.cn/problems/cells-with-odd-values-in-a-matrix/ 4 | 5 | func oddCells(m int, n int, indices [][]int) int { 6 | r := map[int]int{} 7 | c := map[int]int{} 8 | for _, v := range indices { 9 | r[v[0]]++ 10 | c[v[1]]++ 11 | } 12 | ans := 0 13 | for i := 0; i < m; i++ { 14 | for j := 0; j < n; j++ { 15 | if (r[i]+c[j])&1 == 1 { 16 | ans++ 17 | } 18 | } 19 | } 20 | return ans 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-13-asteroidCollision.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | // https://leetcode.cn/problems/asteroid-collision/ 4 | // 栈模拟 5 | func asteroidCollision(asteroids []int) []int { 6 | stack := make([]int, 0) 7 | for _, aster := range asteroids { 8 | alive := true 9 | for alive && aster < 0 && len(stack) > 0 && stack[len(stack)-1] > 0 { 10 | alive = -aster > stack[len(stack)-1] 11 | if -aster >= stack[len(stack)-1] { 12 | stack = stack[:len(stack)-1] 13 | } 14 | } 15 | if alive { 16 | stack = append(stack, aster) 17 | } 18 | } 19 | return stack 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-16-arrayNesting.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | func arrayNesting(nums []int) (ans int) { 4 | n := len(nums) 5 | for i := range nums { 6 | cnt := 0 7 | for nums[i] < n { 8 | i, nums[i] = nums[i], n 9 | cnt++ 10 | } 11 | if cnt > ans { 12 | ans = cnt 13 | } 14 | } 15 | return 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-2-minRefuelStops.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | import "math" 4 | 5 | func minRefuelStops(target int, startFuel int, stations [][]int) int { 6 | // 加了i次油能够拥有的最大汽油数 7 | dp := make([]int, len(stations)+1) 8 | dp[0] = startFuel 9 | for i := 0; i < len(stations); i++ { 10 | for j := i; j >= 0; j-- { 11 | if dp[j] >= stations[i][0] { 12 | dp[j+1] = int(math.Max(float64(dp[j+1]), float64(dp[j]+stations[i][1]))) 13 | } 14 | } 15 | } 16 | for i := 0; i <= len(stations); i++ { 17 | if dp[i] >= target { 18 | return i 19 | } 20 | } 21 | return -1 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-20-shiftGrid.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | func shiftGrid(grid [][]int, k int) [][]int { 4 | m, n := len(grid), len(grid[0]) 5 | ans := make([][]int, m) 6 | for i := 0; i < m; i++ { 7 | ans[i] = make([]int, n) 8 | } 9 | for i := 0; i < m; i++ { 10 | for j := 0; j < n; j++ { 11 | le := i*n + j + k 12 | ans[le/n][le%n] = grid[i][j] 13 | } 14 | } 15 | return ans 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-07/7-8-minCostToMoveChips.go: -------------------------------------------------------------------------------- 1 | package _022_07 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position/ 6 | 7 | func minCostToMoveChips(position []int) int { 8 | odd, even := 0, 0 9 | for _, n := range position { 10 | if n&1 == 1 { 11 | odd++ 12 | } else { 13 | even++ 14 | } 15 | } 16 | return int(math.Min(float64(odd), float64(even))) 17 | } 18 | 19 | //func abs(a, b int) int { 20 | // if a > b { 21 | // return a - b 22 | // } else { 23 | // return b - a 24 | // } 25 | //} 26 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-12.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | func groupThePeople(groupSizes []int) (ans [][]int) { 4 | // hashmap 5 | m := map[int]int{} 6 | for i, v := range groupSizes { 7 | if val, ok := m[v]; !ok || len(ans[val]) == v { 8 | // 开始新一波 9 | m[v] = len(ans) 10 | ans = append(ans, []int{i}) 11 | } else { 12 | ans[val] = append(ans[val], i) 13 | } 14 | } 15 | return 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-14.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | func maxScore(s string) (ans int) { 8 | score := 1 - int(s[0]) + strings.Count(s[1:], "1") 9 | for _, c := range s[1 : len(s)-1] { 10 | if c == '0' { 11 | score++ 12 | } else { 13 | score-- 14 | } 15 | ans = max(ans, score) 16 | } 17 | return 18 | } 19 | 20 | //func max(a, b int) int { 21 | // if a > b { 22 | // return a 23 | // } else { 24 | // return b 25 | // } 26 | //} 27 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-16.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | type OrderedStream struct { 4 | stream []string 5 | ptr int 6 | } 7 | 8 | func Constructor(n int) OrderedStream { 9 | return OrderedStream{make([]string, n+1), 1} 10 | } 11 | 12 | func (this *OrderedStream) Insert(idKey int, value string) []string { 13 | this.stream[idKey] = value 14 | start := this.ptr 15 | for this.ptr < len(this.stream) && this.stream[this.ptr] != "" { 16 | this.ptr++ 17 | } 18 | return this.stream[start:this.ptr] 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-17.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | func deepestLeavesSum(root *TreeNode) (sum int) { 4 | height := -1 5 | var dfs func(curH int, node *TreeNode) 6 | dfs = func(curH int, node *TreeNode) { 7 | if node == nil { 8 | return 9 | } 10 | if curH > height { 11 | height = curH 12 | sum = node.Val 13 | } else if curH == height { 14 | sum += node.Val 15 | } 16 | dfs(curH+1, node.Left) 17 | dfs(curH+1, node.Right) 18 | } 19 | dfs(0, root) 20 | return sum 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-18.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | // 最大相等频率 4 | func maxEqualFreq(nums []int) (ans int) { 5 | maxFeq := 0 6 | feqs := map[int]int{} 7 | cnt := map[int]int{} 8 | for i, v := range nums { 9 | if cnt[v] > 0 { 10 | feqs[cnt[v]]-- 11 | } 12 | cnt[v]++ 13 | feqs[cnt[v]]++ 14 | maxFeq = max(maxFeq, cnt[v]) 15 | // 三种情况 16 | if maxFeq == 1 || 17 | maxFeq*feqs[maxFeq]+(maxFeq-1)*feqs[maxFeq-1] == i+1 && feqs[maxFeq] == 1 || 18 | maxFeq*feqs[maxFeq]+1 == i+1 && feqs[1] == 1 { 19 | ans = max(ans, i+1) 20 | } 21 | } 22 | return 23 | } 24 | func max(a, b int) int { 25 | if a > b { 26 | return a 27 | } else { 28 | return b 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-19.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | func busyStudent(startTime []int, endTime []int, queryTime int) int { 4 | cnt := 0 5 | for i := range startTime { 6 | if startTime[i] <= queryTime && queryTime <= endTime[i] { 7 | cnt++ 8 | } 9 | } 10 | return cnt 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-23.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | // 782 71周赛最后一题，太难了先收藏后面解决 4 | //func movesToChessboard(board [][]int) int { 5 | // 6 | //} 7 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-3.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | import "sort" 4 | 5 | func orderlyQueue(s string, k int) string { 6 | b := []byte(s) 7 | if k == 1 { 8 | for i := 0; i < len(b); i++ { 9 | if b = append(b[1:], b[0]); string(b) < s { 10 | s = string(b) 11 | } 12 | } 13 | return s 14 | } else { 15 | sort.Slice(b, func(i, j int) bool { 16 | return b[i] < b[j] 17 | }) 18 | return string(b) 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-30.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | /** 4 | * Definition for a binary tree node. 5 | * type TreeNode struct { 6 | * Val int 7 | * Left *TreeNode 8 | * Right *TreeNode 9 | * } 10 | */ 11 | func insertIntoMaxTree(root *TreeNode, val int) *TreeNode { 12 | if root == nil || root.Val < val { 13 | return &TreeNode{val, root, nil} 14 | } 15 | var p *TreeNode 16 | for cur := root; cur != nil; cur = cur.Right { 17 | if val > cur.Val { 18 | if p == nil { 19 | return &TreeNode{val, cur, nil} 20 | } 21 | p.Right = &TreeNode{val, cur, nil} 22 | return root 23 | } 24 | p = cur 25 | } 26 | p.Right = &TreeNode{Val: val} 27 | return root 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-31.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | func validateStackSequences(pushed []int, popped []int) bool { 4 | st := make([]int, 0) 5 | i, j := 0, 0 6 | for j < len(popped) { 7 | if i == len(pushed) { 8 | return false 9 | } 10 | st = append(st, pushed[i]) 11 | i++ 12 | for len(st) > 0 && st[len(st)-1] == popped[j] { 13 | st = st[:len(st)-1] 14 | j++ 15 | } 16 | } 17 | return true 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-4.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/minimum-subsequence-in-non-increasing-order/ 6 | func minSubsequence(nums []int) []int { 7 | sum := 0 8 | for _, num := range nums { 9 | sum += num 10 | } 11 | sort.Sort(sort.Reverse(sort.IntSlice(nums))) 12 | tot := 0 13 | for i, num := range nums { 14 | tot += num 15 | if tot > sum-tot { 16 | return nums[:i+1] 17 | } 18 | } 19 | return []int{} 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-6.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | import ( 4 | "sort" 5 | "strings" 6 | ) 7 | 8 | func makeLargestSpecial(s string) string { 9 | if len(s) <= 2 { 10 | return s 11 | } 12 | cnt := 0 13 | str := sort.StringSlice{} 14 | for left, cur := 0, 0; cur < len(s); cur++ { 15 | if s[cur] == '1' { 16 | cnt++ 17 | } else if cnt--; cnt == 0 { 18 | str = append(str, "1"+makeLargestSpecial(s[left+1:cur])+"0") 19 | left = cur + 1 20 | } 21 | } 22 | sort.Sort(sort.Reverse(str)) 23 | return strings.Join(str, "") 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-08/2022-8-9.go: -------------------------------------------------------------------------------- 1 | package _022_08 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/minimum-value-to-get-positive-step-by-step-sum/ 6 | 7 | func minStartValue(nums []int) int { 8 | tot := 0 9 | ml := 0 10 | for _, num := range nums { 11 | tot += num 12 | ml = int(math.Min(float64(ml), float64(tot))) 13 | } 14 | return 1 - ml 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-12.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // 1608 官方题解理解 6 | func specialArray(nums []int) int { 7 | // 倒序排列，从大到小 8 | sort.Sort(sort.Reverse(sort.IntSlice(nums))) 9 | // i-1>=i 说明目前有i个数字>=i（0到i-1） 10 | // 后面i==n时说明有n个数字大于等于n，退出循环 11 | // 另一个则是第i个数后面的数= i && (i == n || nums[i] < i) { 14 | return i 15 | } 16 | } 17 | return -1 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-13.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | func maximumSwap(num int) int { 6 | str := []byte(strconv.Itoa(num)) 7 | id1, id2, mx := -1, -1, len(str)-1 8 | for i := len(str) - 1; i >= 0; i-- { 9 | if str[i] > str[mx] { 10 | mx = i 11 | } else if str[i] < str[mx] { 12 | id1, id2 = i, mx 13 | } 14 | } 15 | if id1 == -1 { 16 | return num 17 | } 18 | str[id1], str[id2] = str[id2], str[id1] 19 | v, _ := strconv.Atoi(string(str)) 20 | return v 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-15.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 枚举 4 | func flipLights(n int, presses int) int { 5 | if n == 0 { 6 | return 1 7 | } 8 | vis := map[int]struct{}{} 9 | preArr := make([]int, 4) 10 | for i := 0; i < 1<<4; i++ { 11 | sum := 0 12 | for j := 0; j < 4; j++ { 13 | preArr[j] = (i >> j) & 1 14 | sum += preArr[j] 15 | } 16 | if sum%2 == presses%2 && sum <= presses { 17 | status := preArr[0] ^ preArr[2] ^ preArr[3] 18 | if n >= 2 { 19 | status |= (preArr[0] ^ preArr[1]) << 1 20 | } 21 | if n >= 3 { 22 | status |= (preArr[0] ^ preArr[2]) << 2 23 | } 24 | vis[status] = struct{}{} 25 | } 26 | } 27 | return len(vis) 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // dfs 6 | func findDuplicateSubtrees(root *TreeNode) (ans []*TreeNode) { 7 | repeat := map[*TreeNode]struct{}{} 8 | vis := map[string]*TreeNode{} 9 | var dfs func(node *TreeNode) string 10 | dfs = func(node *TreeNode) string { 11 | if node == nil { 12 | return "" 13 | } 14 | serial := fmt.Sprintf("%d(%s)(%s)", node.Val, dfs(node.Left), dfs(node.Right)) 15 | if n, ok := vis[serial]; ok { 16 | repeat[n] = struct{}{} 17 | } else { 18 | vis[serial] = node 19 | } 20 | return serial 21 | } 22 | dfs(root) 23 | for node := range repeat { 24 | ans = append(ans, node) 25 | } 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-6.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func uniqueLetterString(s string) (ans int) { 4 | idx := map[rune][]int{} 5 | for i, c := range s { 6 | idx[c] = append(idx[c], i) 7 | } 8 | for _, arr := range idx { 9 | arr = append(append([]int{-1}, arr...), len(s)) 10 | for i := 1; i < len(arr)-1; i++ { 11 | ans += (arr[i] - arr[i-1]) * (arr[i+1] - arr[i]) 12 | } 13 | } 14 | return 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-8.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 667 1-n的数字，成就k个不同的正数 4 | // 思维题 5 | // 前n-k个数据按照1，2,3,4...处理 6 | // 后面的数据按照1，n，2，n-1。。。处理 7 | // 相互结合即可 8 | func constructArray(n int, k int) (ans []int) { 9 | for i := 1; i < n-k; i++ { 10 | ans = append(ans, i) 11 | } 12 | for i, j := n-k, n; i <= j; i++ { 13 | ans = append(ans, i) 14 | if i != j { 15 | ans = append(ans, j) 16 | } 17 | j-- 18 | } 19 | return 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-09/2022-9-9.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1598 文件夹操作日志搜集器 4 | func minOperations(logs []string) int { 5 | ans := 0 6 | for _, l := range logs { 7 | if l == "./" { 8 | continue 9 | } 10 | if l != "../" { 11 | ans++ 12 | } else if ans > 0 { 13 | ans-- 14 | } 15 | } 16 | return ans 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-10/2022-10-08.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | # 给定两个大小相等的数组 nums1 和 nums2，nums1 3 | # 相对于 nums 的优势可以用满足 nums1[i] > nums2[i] 的索引 i 的数目来描述。 4 | # 返回 nums1 的任意排列，使其相对于 nums2 的优势最大化。 5 | 6 | class Solution: 7 | def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]: 8 | n = len(nums1) 9 | nums1.sort() 10 | idxs = sorted(range(n), key=lambda x: nums2[x]) 11 | ans = [0] * n 12 | l, r = 0, n-1 13 | for x in nums1: 14 | if x > nums2[idxs[l]]: 15 | ans[idxs[l]] = x 16 | l += 1 17 | else: 18 | ans[idxs[r]] = x 19 | r -= 1 20 | return ans -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-11.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def halvesAreAlike(self, s: str) -> bool: 3 | lst = ['a','e','i','o','u','A','E','I','O','U'] 4 | mid = len(s) // 2 5 | return sum(x in lst for x in s[0:mid]) == sum(x in lst for x in s[mid:]) -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-15.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | class Solution: 4 | def maximumUnits(self, boxTypes: List[List[int]], truckSize: int) -> int: 5 | res = 0 6 | for num in sorted(boxTypes, key=lambda x:-x[1]): 7 | cnt, n = num 8 | if truckSize >= cnt: 9 | res += cnt * n 10 | truckSize -= cnt 11 | elif truckSize > 0 and truckSize < cnt: 12 | res += truckSize * n 13 | truckSize = 0 14 | if truckSize <= 0 : break 15 | return res 16 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-16.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | class Solution: 5 | def isIdealPermutation(self, nums: List[int]) -> bool: 6 | # 找是否存在非局部倒置即可 7 | n = len(nums) 8 | m_suffix = nums[-1] 9 | for i in range(n-2, 0, -1): 10 | if nums[i-1] > m_suffix: 11 | return False 12 | m_suffix = min(m_suffix, nums[i]) 13 | return True -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-18.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | class Solution: 5 | def sumSubseqWidths(self, nums: List[int]) -> int: 6 | mod = 10 ** 9 + 7 7 | n = len(nums) 8 | nums.sort() 9 | pow2 = [0] * n 10 | pow2[0] = 1 11 | for i in range(1,n): 12 | pow2[i] = pow2[i-1] * 2 % mod # 预处理2的幂次 13 | return sum((pow2[i] - pow2[-1-i]) * x 14 | for i, x in enumerate(nums)) % mod -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-22.py: -------------------------------------------------------------------------------- 1 | from math import lcm 2 | 3 | 4 | class Solution: 5 | def nthMagicalNumber(self, n: int, a: int, b: int) -> int: 6 | # fx = x//a + x // b + x // c 7 | mod = 10**9+7 8 | c = lcm(a,b) 9 | l, r = min(a,b), n*min(a,b) 10 | while l < r: 11 | mid = (l+r) // 2 12 | cnt = mid // a + mid // b - mid // c # 递增 13 | if cnt >= n: 14 | r = mid 15 | else: 16 | l = mid + 1 17 | return r % mod 18 | -------------------------------------------------------------------------------- /leetcode/everyday/2022/2022-11/2022-11-24.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | # 计数 5 | class Solution: 6 | def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int: 7 | def count(lower: int) -> int: 8 | res = cur = 0 9 | for x in nums: 10 | if x <= lower: 11 | # 每多一个数组就数字+1 12 | cur += 1 13 | else: 14 | cur = 0 15 | res += cur 16 | return res 17 | return count(right) - count(left-1) 18 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-01/01-03.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def areNumbersAscending(self, s: str) -> bool: 3 | pre = i = 0 4 | while i < len(s): 5 | if s[i].isdigit(): 6 | cur = 0 7 | while i < len(s) and s[i].isdigit(): 8 | cur = cur * 10 + int(s[i]) 9 | i += 1 10 | if cur <= pre: 11 | return False 12 | pre = cur 13 | else: 14 | i += 1 15 | return True -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-01/01-06.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func countEven(num int) (ans int) { 4 | y, x := num/10, num%10 5 | ans += y * 5 6 | ysum := 0 7 | for ; y > 0; y /= 10 { 8 | ysum += y % 10 9 | } 10 | // 需要减去 0，因为题目只需要正整数 11 | if ysum%2 == 1 { 12 | ans += (x+1)/2 - 1 13 | } else { 14 | ans += x/2 + 1 - 1 15 | } 16 | return 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-01/01-09.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 方法1是直接模拟 4 | // g^k(i)≡2^k*i ≡ i (mod(n−1)) 5 | // 推理 6 | // 即求 2^k ≡ 1 (mod(n-1)) 最小成立的值 7 | func reinitializePermutation(n int) int { 8 | if n == 2 { 9 | return 1 10 | } 11 | setp := 1 12 | pow2 := 2 13 | for pow2 != 1 { 14 | setp++ 15 | pow2 = pow2 * 2 % (n - 1) 16 | } 17 | return setp 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-01/01-10.py: -------------------------------------------------------------------------------- 1 | # 求解欧拉回路 / 欧拉通路的题目 753 2 | # https://leetcode.cn/problems/cracking-the-safe/solution/po-jie-bao-xian-xiang-by-leetcode-solution/ 3 | class Solution: 4 | def crackSafe(self, n: int, k: int) -> str: 5 | mod = 10 ** (n-1) 6 | ans = list() 7 | vis = set() 8 | def dfs(node): 9 | for i in range(k): 10 | v = node * 10 + i 11 | if v in vis: continue 12 | vis.add(v) 13 | dfs(v % mod) # 节点编号, 去除最高位 14 | ans.append(str(i)) # 保留最后一个数 15 | dfs(0) 16 | return "".join(ans) + "0" * (n-1) # 最后加上0的前缀0数量 -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-02/2023-02-21.py: -------------------------------------------------------------------------------- 1 | 2 | class Solution: 3 | # 跳跃游戏, 视频拼接 4 | def minTaps(self, n: int, ranges: List[int]) -> int: 5 | # 求当前节点能跳跃的最远距离 6 | right_most = [0] * (n+1) 7 | for i, r in enumerate(ranges): 8 | left = max(i-r, 0) 9 | right_most[left] = max(right_most[left], i + r) 10 | 11 | ans = 0 12 | cur = 0 13 | next = 0 14 | for i in range(n): # n已经是终点了，不需要考虑 15 | next = max(next, right_most[i]) 16 | if i == cur: 17 | if i == next: 18 | return -1 19 | cur = next 20 | ans += 1 21 | return ans 22 | 23 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-02/2023-02-27.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def movesToMakeZigzag(self, nums: List[int]) -> int: 3 | s = [0, 0] 4 | for i in range(len(nums)): 5 | left = nums[i-1] if i else inf 6 | right = nums[i+1] if i < len(nums)-1 else inf 7 | s[i % 2] += max(nums[i] - min(left, right) + 1, 0) 8 | return min(s) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0303.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # hashmap 3 | def getFolderNames(self, names: List[str]) -> List[str]: 4 | index = {} 5 | ans = [] 6 | for name in names: 7 | if name not in index: 8 | ans.append(name) 9 | index[name] = 1 10 | else: 11 | idx = index[name] 12 | while name+'('+str(idx)+')' in index: 13 | idx+=1 14 | t = name+'('+str(idx)+')' 15 | ans.append(t) 16 | index[name] = idx+1 17 | index[t] = 1 18 | return ans -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0308.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | class Solution: 5 | def maxValue(self, grid: List[List[int]]) -> int: 6 | m, n = len(grid), len(grid[0]) 7 | dp = [[0] * (n+1) for _ in range(m+1)] 8 | for i, row in enumerate(grid): 9 | for j, x in enumerate(row): 10 | dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]) + x 11 | return dp[m][n] -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0310.py: -------------------------------------------------------------------------------- 1 | # 1590. 使数组和能被 P 整除 2 | from itertools import accumulate 3 | from typing import List 4 | 5 | 6 | class Solution: 7 | def minSubarray(self, nums: List[int], p: int) -> int: 8 | s = list(accumulate(nums, initial=0)) 9 | x = s[-1] % p # 数组和 10 | if x == 0: return 0 11 | dis = {} 12 | ans = n = len(nums) 13 | for i, v in enumerate(s): 14 | dis[v % p] = i 15 | jv = (v-x) % p 16 | if jv in dis: 17 | ans = min(ans, i-dis[jv]) 18 | return ans if ans < n else -1 19 | 20 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0314.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def restoreMatrix(self, rowSum: List[int], colSum: List[int]) -> List[List[int]]: 3 | m, n = len(rowSum), len(colSum) 4 | mat = [[0] * n for _ in range(m)] 5 | for i, rs in enumerate(rowSum): 6 | for j, cs in enumerate(colSum): 7 | mat[i][j] = x = min(rs, cs) 8 | rs -= x 9 | colSum[j] -= x 10 | return mat -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0315.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # n2 摆烂 3 | def maximalNetworkRank(self, n: int, roads: List[List[int]]) -> int: 4 | grp = [[False] * n for _ in range(n)] 5 | degree = [0] * n 6 | for a,b in roads: 7 | degree[a] += 1 8 | degree[b] += 1 9 | grp[a][b] = True 10 | grp[b][a] = True 11 | ans = 0 12 | for i in range(n): 13 | for j in range(i+1, n): 14 | rank = degree[i] + degree[j] - grp[i][j] 15 | ans = max(ans, rank) 16 | return ans -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0316.py: -------------------------------------------------------------------------------- 1 | from typing import Counter, List 2 | 3 | # 子数组 等价替换原则 中位数 (小于的数=大于的数， 左小+右小=右大+右大，左小-左大=右大-右小) 4 | # 偶数的时候统计 右大-右小-1 5 | class Solution: 6 | def countSubarrays(self, nums: List[int], k: int) -> int: 7 | index = nums.index(k) 8 | cnt, x = Counter({0:1}), 0 9 | for i in range(index-1, -1, -1): 10 | x += 1 if nums[i] < k else -1 11 | cnt[x] += 1 12 | 13 | ans, x = cnt[0] + cnt[-1], 0 14 | for i in range(index+1, len(nums)): 15 | x += 1 if nums[i] > k else -1 16 | ans += cnt[x] + cnt[x-1] 17 | return ans -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0317.py: -------------------------------------------------------------------------------- 1 | # 排序 前缀和 二分搜索 2 | class Solution: 3 | def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]: 4 | f = list(accumulate(sorted(nums))) 5 | return [bisect_right(f, q) for q in queries] -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0322.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | class Solution: 5 | def bestTeamScore(self, scores: List[int], ages: List[int]) -> int: 6 | a = sorted(zip(scores, ages)) 7 | f = [0] * len(a) 8 | for i in range(len(a)): 9 | for j in range(i): 10 | if a[j][1] <= a[i][1]: 11 | f[i] = max(f[j], f[i]) # 如果分数<=的话， age也<= 12 | f[i] += a[i][0] 13 | return max(f) 14 | 15 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-03/0329.py: -------------------------------------------------------------------------------- 1 | from math import comb 2 | 3 | class Solution: 4 | def countVowelStrings2(self, n: int) -> int: 5 | # 关于我高中的知识，做力扣才搞懂这件事 6 | # n个球放到5个盒子里有几种放法，可以允许部分盒子里是空的，不放球 7 | # 挡板在两边是不能放的，不然盒子都凑在一起，相当于没分配，所以空位要-2 8 | # 相当于 m+n+1-2 = 5+n+1-2 = n+4, 选4个位置, 先借后还的思想 9 | return comb(n+4, 4) 10 | 11 | def countVowelStrings(self, n: int) -> int: 12 | dp = [1] * 5 13 | for _ in range(n-1): # 已经分配了一个球，所以只需要分配n-1个 14 | for j in range(1,5): # 同理，以'0'对应的'a'结尾只可能有一个，不需要管，所以从'b'结尾开始计算 15 | dp[j] += dp[j-1] 16 | return sum(dp) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-06.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def baseNeg2(self, n: int) -> str: 3 | if n == 0 or n == 1: 4 | return str(n) 5 | k = -2 6 | ans = [] 7 | while n != 0: 8 | d = n % abs(k) 9 | ans.append(str(d)) 10 | n -= d 11 | n //= -2 12 | return "".join(ans[::-1]) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-13.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def mostFrequentEven(self, nums: List[int]) -> int: 3 | cnt = Counter(nums) 4 | ans = inf 5 | for k, v in cnt.items(): 6 | if k & 1 == 0 and cnt[k] >= cnt[ans]: 7 | if cnt[k] == cnt[ans]: 8 | if k < ans: 9 | ans = k 10 | else: 11 | ans = k 12 | return -1 if ans == inf else ans -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-17.py: -------------------------------------------------------------------------------- 1 | DAYS_SUM = list(accumulate((31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31), initial=0)) 2 | 3 | def calc_days(date: str) -> int: 4 | return DAYS_SUM[int(date[:2]) - 1] + int(date[3:]) 5 | 6 | class Solution: 7 | def countDaysTogether(self, arriveAlice: str, leaveAlice: str, arriveBob: str, leaveBob: str) -> int: 8 | left = calc_days(max(arriveAlice, arriveBob)) # 直接比较字符串再计算 9 | right = calc_days(min(leaveAlice, leaveBob)) 10 | return max(right - left + 1, 0) # 答案不能为负数 11 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-19.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int: 3 | n = len(arr) 4 | dp = [0] * (n+1) # 前n个数组成的最大值(不含当前) 5 | for i in range(n+1): 6 | mx = 0 7 | j = i-1 8 | while i-j <= k and j>=0: 9 | mx = max(mx, arr[j]) 10 | dp[i] = max(dp[i], dp[j]+(i-j)*mx) 11 | j -= 1 12 | return dp[-1] -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-20.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # lis 3 | def makeArrayIncreasing(self, a: List[int], b: List[int]) -> int: 4 | b.sort() 5 | @cache 6 | def dfs(i, pre): 7 | if i < 0: return 0 8 | res = dfs(i-1, a[i]) if a[i] < pre else inf #不替换 9 | k = bisect_left(b, pre) - 1 10 | if k >= 0: 11 | res = min(res, dfs(i-1, b[k])+1) 12 | return res 13 | ans = dfs(len(a)-1, inf) 14 | return ans if ans < inf else -1 15 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-04/04-23.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minHeightShelves(self, books: List[List[int]], shelfWidth: int) -> int: 3 | n = len(books) 4 | # 从0-i的书能够构成的最小高度 5 | @cache 6 | def dfs(i): 7 | if i < 0: return 0 8 | res, left_w, max_h = inf, shelfWidth, 0 9 | for j in range(i, -1, -1): 10 | left_w -= books[j][0] 11 | if left_w < 0: break #放不下了就break，所有的结果已经在前面计算好了 12 | max_h = max(max_h, books[j][1]) #当前层放得下的话，继续放 13 | res = min(res, dfs(j-1)+max_h) #计算当前的最小 14 | return res 15 | return dfs(n-1) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-05/05-16.py: -------------------------------------------------------------------------------- 1 | from functools import cache 2 | 3 | 4 | class Solution: 5 | def minDifficulty(self, a: List[int], d: int) -> int: 6 | n = len(a) 7 | if n < d: 8 | return -1 9 | # 定义f(i, j)为i天完成前j个任务的最小难度 10 | @cache 11 | def dfs(i, j): 12 | if i == 1: 13 | return max(a[:j+1]) 14 | # if i == 0: 15 | # return -1 16 | res, mx = inf, 0 17 | for k in range(j, i-2, -1): 18 | mx = max(mx, a[k]) 19 | res = min(res, dfs(i-1, k-1)+mx) 20 | return res 21 | return dfs(d, n-1) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-05/05-19.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # 计数dp， 还有一种是回溯 3 | def numTilePossibilities(self, tiles: str) -> int: 4 | # f i,j 为前i种字符构造长为j的序列有多少种 5 | count = Counter(tiles).values() 6 | n, m = len(tiles), len(count) 7 | f = [[0]* (n+1) for _ in range(m+1)] 8 | f[0][0] = 1 9 | for i, cnt in enumerate(count, 1): 10 | for j in range(n+1): 11 | for k in range(min(j,cnt)+1): 12 | f[i][j] += f[i-1][j-k] * comb(j, k) 13 | return sum(f[m][1:]) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-05/05-22.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def sufficientSubset(self, root: Optional[TreeNode], limit: int) -> Optional[TreeNode]: 9 | limit -= root.val 10 | if root.left == root.right: 11 | return None if limit > 0 else root 12 | if root.right: root.right = self.sufficientSubset(root.right, limit) 13 | if root.left: root.left = self.sufficientSubset(root.left, limit) 14 | return root if root.left or root.right else None -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-05/05-25.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def oddString(self, words: List[str]) -> str: 3 | d = defaultdict(list) 4 | for s in words: 5 | t = tuple(ord(b)-ord(a) for a,b in pairwise(s)) 6 | d[t].append(s) 7 | return next(x[0] for x in d.values() if len(x) == 1) -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-05/05-31.py: -------------------------------------------------------------------------------- 1 | from functools import cache 2 | from typing import List 3 | 4 | 5 | class Solution: 6 | def mctFromLeafValues(self, arr: List[int]) -> int: 7 | @cache 8 | def dfs(i, j): 9 | if i == j: return 0 10 | return min(dfs(i,k) + dfs(k+1, j) + g[i][k]*g[k+1][j] for k in range(i,j)) 11 | 12 | n = len(arr) 13 | g = [[0] * n for _ in range(n)] 14 | for i in range(n-1, -1, -1): 15 | g[i][i] = arr[i] 16 | for j in range(i+1, n): 17 | g[i][j] = max(g[i][j-1], arr[j]) 18 | return dfs(0, n-1) 19 | -------------------------------------------------------------------------------- /leetcode/everyday/2023/2023-09/09-07.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from bisect import bisect_left 4 | from math import sqrt 5 | from typing import List 6 | 7 | 8 | class Solution: 9 | def repairCars(self, ranks: List[int], cars: int) -> int: 10 | def check(t: int) -> bool: 11 | return sum(int(sqrt(t // r)) for r in ranks) >= cars 12 | 13 | return bisect_left(range(ranks[0] * cars * cars), True, key=check) 14 | -------------------------------------------------------------------------------- /leetcode/everyday/2025/2025-01/01-01.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # @Time : 2025/1/2 14:20 3 | # @File : 01-01.py 4 | 5 | class Solution: 6 | def convertDateToBinary(self, date: str) -> str: 7 | data = date.split('-') 8 | return '-'.join(bin(int(c))[2:] for c in data) 9 | 10 | -------------------------------------------------------------------------------- /leetcode/everyday/2025/2025-01/01-06.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # @Time : 2025/1/6 11:02 3 | # @File : 01-06.py 4 | from collections import defaultdict 5 | from itertools import pairwise 6 | from typing import List 7 | 8 | 9 | # https://leetcode.cn/problems/maximum-consecutive-floors-without-special-floors/description/?envType=daily-question&envId=2025-01-06 10 | # 算特殊楼层避免oom或tle 11 | class Solution: 12 | def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int: 13 | special.sort() 14 | ans = max(special[0] - bottom, top - special[-1]) 15 | for x, y in pairwise(special): 16 | ans = max(ans, y - x - 1) 17 | return ans -------------------------------------------------------------------------------- /leetcode/everyday/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := make([]int, 0, 3) 7 | a = append(a, 2) 8 | a = append(a, 3) 9 | fmt.Println(a) 10 | } 11 | -------------------------------------------------------------------------------- /leetcode/lcp/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/lcp/solution/1.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | func game(guess []int, answer []int) int { 4 | cnt := 0 5 | for i := range guess { 6 | if guess[i] == answer[i] { 7 | cnt++ 8 | } 9 | } 10 | return cnt 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/lcp/solution/2.go: -------------------------------------------------------------------------------- 1 | package solution 2 | 3 | func fraction(cont []int) []int { 4 | size := len(cont) 5 | // 从后往前推 6 | fz := 1 7 | fm := cont[size-1] 8 | for i := size - 2; i >= 0; i-- { 9 | fz += cont[i] * fm 10 | g := GCD(fz, fm) 11 | fz /= g 12 | fm /= g 13 | fz, fm = fm, fz 14 | } 15 | return []int{fm, fz} 16 | } 17 | 18 | func GCD(a, b int) int { 19 | if a > b { 20 | a, b = b, a 21 | } 22 | if a == 0 { 23 | return b 24 | } 25 | return GCD(b%a, a) 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/10-i.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/fibonacci-number/ 4 | func fib(n int) int { 5 | mod := 1000000007 6 | f1 := 0 7 | f2 := 1 8 | if n == 0 { 9 | return 0 10 | } 11 | if n == 1 { 12 | return 1 13 | } 14 | for n-1 > 0 { 15 | f1, f2 = f2%mod, (f1+f2)%mod 16 | n-- 17 | } 18 | return f2 % mod 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/10-ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func numWays(n int) int { 4 | mod := 1000000007 5 | f1 := 1 6 | f2 := 1 7 | if n == 1 { 8 | return 1 9 | } 10 | if n == 0 { 11 | return 1 12 | } 13 | if n == 2 { 14 | return 2 15 | } 16 | for n-1 > 0 { 17 | f1, f2 = f2%mod, (f1+f2)%mod 18 | n-- 19 | } 20 | return f2 % mod 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/11.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minArray(nums []int) int { 4 | l, r := 0, len(nums)-1 5 | for l < r { 6 | for l < r && nums[l] == nums[l+1] { 7 | l++ 8 | } 9 | for l < r && nums[r] == nums[r-1] { 10 | r-- 11 | } 12 | mid := l + (r-l)>>1 13 | if nums[mid] <= nums[r] { 14 | r = mid 15 | } else { 16 | l = mid + 1 17 | } 18 | } 19 | return nums[l] 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/14-i.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // dp[i] 大于i的绳子切成段数能达到的最大乘积 4 | func cuttingRope(n int) int { 5 | dp := make([]int, n+1) 6 | dp[2] = 1 7 | for i := 3; i <= n; i++ { 8 | for j := 1; j < i; j++ { 9 | dp[i] = max(dp[i], max(j*(i-j), j*dp[i-j])) 10 | } 11 | } 12 | return dp[n] 13 | } 14 | 15 | func max(a, b int) int { 16 | if a > b { 17 | return a 18 | } else { 19 | return b 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/14-ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 因为这时测试用例过大，有大数越界的问题，所以不能通过dp求解 4 | // 需要通过数学方法求解 5 | func cuttingRope2(n int) int { 6 | mod := 1000000007 7 | if n < 4 { 8 | return n - 1 9 | } else if n == 4 { 10 | return 4 11 | } 12 | a := n / 3 13 | b := n % 3 14 | if b == 0 { 15 | return pow(3, a) % mod 16 | } else if b == 1 { 17 | return pow(3, a-1) * 4 % mod 18 | } else if b == 2 { 19 | return pow(3, a) * 2 % mod 20 | } 21 | return 0 22 | } 23 | 24 | func pow(b, a int) int { 25 | mod := 1000000007 26 | res := 1 27 | for a != 0 { 28 | if a%2 == 1 { 29 | res *= b 30 | res %= mod 31 | } 32 | b = b * b % mod 33 | a >>= 1 34 | } 35 | return res 36 | } 37 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/15.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func hammingWeight(num uint32) int { 4 | cnt := 0 5 | for num != 0 { 6 | num = num & (num - 1) 7 | cnt++ 8 | } 9 | return cnt 10 | } 11 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/16.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func myPow(x float64, n int) float64 { 4 | res := 1.0 5 | if n < 0 { 6 | n = -n 7 | x = 1 / x 8 | } 9 | for n != 0 { 10 | if n&1 == 1 { 11 | res *= float64(x) 12 | } 13 | x *= x 14 | n >>= 1 15 | } 16 | return res 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/17.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func printNumbers(n int) (ans []int) { 4 | max := 0 5 | for n != 0 { 6 | n-- 7 | max = max*10 + 9 8 | } 9 | for i := 1; i <= max; i++ { 10 | ans = append(ans, i) 11 | } 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/18.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // type ListNode struct { 4 | // Val int 5 | // Next *ListNode 6 | //} 7 | 8 | func deleteNode(head *ListNode, val int) *ListNode { 9 | tommy := &ListNode{} 10 | tommy.Next = head 11 | pre := tommy 12 | for head != nil { 13 | if head.Val == val { 14 | tommy.Next = head.Next 15 | } 16 | tommy = tommy.Next 17 | head = head.Next 18 | } 19 | return pre.Next 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/19.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isMatch(s string, p string) bool { 4 | return true 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/21.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func exchange(nums []int) []int { 4 | low, fast := 0, 0 5 | n := len(nums) 6 | for fast < n { 7 | if nums[fast]&1 == 1 { 8 | nums[fast], nums[low] = nums[low], nums[fast] 9 | low++ 10 | } 11 | fast++ 12 | } 13 | return nums 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/3.go: -------------------------------------------------------------------------------- 1 | package main 2 | // https://leetcode.cn/problems/find-the-duplicate-number/description/ 3 | func findRepeatNumber(nums []int) int { 4 | m := map[int]int{} 5 | for i := 0; i < len(nums); i++ { 6 | m[nums[i]]++ 7 | if m[nums[i]] == 2 { 8 | return nums[i] 9 | } 10 | } 11 | return -1 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/31.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/ 4 | func validateStackSequences(pushed []int, popped []int) bool { 5 | stack := make([]int, 0) 6 | cnt := 0 7 | if len(pushed) == 0 || len(popped) == 0 { 8 | return true 9 | } 10 | for i := 0; i < len(pushed); i++ { 11 | stack = append(stack, pushed[i]) 12 | for len(stack) != 0 && stack[len(stack)-1] == popped[cnt] { 13 | stack = stack[:len(stack)-1] 14 | cnt++ 15 | if cnt == len(popped) { 16 | return true 17 | } 18 | } 19 | } 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | // https://leetcode.cn/problems/search-a-2d-matrix-ii/ 3 | func findNumberIn2DArray(matrix [][]int, target int) bool { 4 | for _, row := range matrix { 5 | l, r := 0, len(row) 6 | for l < r { 7 | mid := l + (r-l)>>1 8 | if row[mid] == target { 9 | return true 10 | } else if row[mid] > target { 11 | r = mid 12 | } else { 13 | l = mid + 1 14 | } 15 | } 16 | } 17 | return false 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func replaceSpace(s string) string { 6 | sb := strings.Builder{} 7 | for i := 0; i < len(s); i++ { 8 | if s[i] == ' ' { 9 | sb.WriteString("%20") 10 | } else { 11 | sb.WriteByte(s[i]) 12 | } 13 | } 14 | return sb.String() 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/6.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func reversePrint(head *ListNode) []int { 9 | ans := make([]int, 0) 10 | for head != nil { 11 | ans = append(ans, head.Val) 12 | } 13 | for i, j := 0, len(ans)-1; i != j; i++ { 14 | ans[i], ans[j] = ans[j], ans[i] 15 | j-- 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/offer/offerii/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/10.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | // 给定一个整数数组和一个整数 k ，请找到该数组中和为 k 的连续子数组的个数。 4 | // 因为数据范围包括负数，所以不能用滑动窗口 5 | 6 | func subarraySum(nums []int, k int) int { 7 | cnt := 0 8 | presum := 0 9 | mp := map[int]int{ 10 | 0: 1, 11 | } 12 | for i := 0; i < len(nums); i++ { 13 | presum += nums[i] 14 | cnt += mp[presum-k] 15 | mp[presum] = mp[presum] + 1 16 | } 17 | return cnt 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/11.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/A1NYOS/ 6 | func findMaxLength(nums []int) int { 7 | // 存储第一次前缀和下标 8 | mp := map[int]int{0: -1} 9 | sum := 0 10 | ans := 0 11 | for i := 0; i < len(nums); i++ { 12 | num := nums[i] 13 | // 是1就+1，是0就-1 14 | sum += num & 1 15 | sum -= num ^ 1 16 | if v, ok := mp[sum]; ok { 17 | ans = int(math.Max(float64(ans), float64(i-v))) 18 | } else { 19 | mp[sum] = i 20 | } 21 | } 22 | return ans 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/12.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | // https://leetcode.cn/problems/tvdfij/ 4 | func pivotIndex(nums []int) int { 5 | sum := make([]int, len(nums)+1) 6 | sum[0] = 0 7 | for i := 1; i <= len(nums); i++ { 8 | sum[i] = sum[i-1] + nums[i-1] 9 | } 10 | cnt := -1 11 | for i := 0; i < len(sum); i++ { 12 | if i != len(nums) && sum[i] == sum[len(nums)]-sum[i]-nums[i] { 13 | cnt = i 14 | break 15 | } 16 | } 17 | return cnt 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/15.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | // https://leetcode.cn/problems/VabMRr/ 4 | func findAnagrams(s string, p string) []int { 5 | need := [26]int{} 6 | win := [26]int{} 7 | ans := make([]int, 0) 8 | if len(p) > len(s) { 9 | return ans 10 | } 11 | for i := 0; i < len(p); i++ { 12 | need[p[i]-'a']++ 13 | win[s[i]-'a']++ 14 | } 15 | if need == win { 16 | ans = append(ans, 0) 17 | } 18 | // 维护固定长度len(pattern) 19 | for i := len(p); i < len(s); i++ { 20 | win[s[i]-'a']++ 21 | win[s[i-len(p)]-'a']-- 22 | if need == win { 23 | ans = append(ans, i-len(p)+1) 24 | } 25 | } 26 | return ans 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/16.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | import "math" 4 | 5 | // https://leetcode.cn/problems/wtcaE1/ 6 | func lengthOfLongestSubstring(s string) int { 7 | mp := map[byte]int{} 8 | left := 0 9 | right := 0 10 | ml := 0 11 | if s == "" { 12 | return ml 13 | } 14 | for right < len(s) { 15 | t := s[right] 16 | mp[t]++ 17 | right++ 18 | for mp[t] > 1 { 19 | ml = int(math.Max(float64(ml), float64(right-left-1))) 20 | t := s[left] 21 | mp[t]-- 22 | left++ 23 | } 24 | } 25 | if right == len(s) && mp[s[len(s)-1]] == 1 { 26 | return int(math.Max(float64(ml), float64(right-left))) 27 | } 28 | return ml 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/19.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func ValidPalindrome(s string) bool { 4 | return validstring(0, len(s)-1, s, false) 5 | } 6 | func validstring(start, end int, s string, flag bool) bool { 7 | for start <= end { 8 | if s[start] == s[end] { 9 | start++ 10 | end-- 11 | } else { 12 | if flag { 13 | return false 14 | } else { 15 | return validstring(start+1, end, s, !flag) || validstring(start, end-1, s, !flag) 16 | } 17 | } 18 | } 19 | return true 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/21.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func removeNthFromEnd(head *ListNode, m int) *ListNode { 9 | tmp := head 10 | n := 0 11 | for tmp != nil { 12 | n++ 13 | tmp = tmp.Next 14 | } 15 | k := n - m + 1 16 | pre := &ListNode{} 17 | t := pre 18 | pre.Next = head 19 | cnt := 0 20 | for pre != nil && cnt != k-1 { 21 | pre = pre.Next 22 | cnt++ 23 | } 24 | if pre.Next != nil { 25 | pre.Next = pre.Next.Next 26 | } else { 27 | pre.Next = nil 28 | } 29 | return t.Next 30 | } 31 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/22.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func detectCycle(head *ListNode) *ListNode { 4 | if head == nil { 5 | return head 6 | } 7 | t := head 8 | slow := head 9 | fast := head.Next 10 | for fast != nil && fast.Next != nil { 11 | slow = slow.Next 12 | fast = fast.Next.Next 13 | if slow == fast { 14 | break 15 | } 16 | } 17 | if slow == fast { 18 | slow = slow.Next 19 | fast = t 20 | for slow != fast { 21 | slow = slow.Next 22 | fast = fast.Next 23 | } 24 | return slow 25 | } 26 | return nil 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/24.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func reverseList(head *ListNode) *ListNode { 4 | var pre *ListNode 5 | for head != nil { 6 | t := head.Next 7 | head.Next = pre 8 | pre = head 9 | head = t 10 | } 11 | return pre 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/27.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func isPalindrome(head *ListNode) bool { 4 | if head == nil { 5 | return true 6 | } 7 | pre := head 8 | slow := head 9 | fast := head.Next 10 | for fast != nil && fast.Next != nil { 11 | slow = slow.Next 12 | fast = fast.Next.Next 13 | } 14 | t := slow.Next 15 | slow.Next = nil 16 | t = reverse(t) 17 | for pre != nil && t != nil { 18 | if pre.Val == t.Val { 19 | pre = pre.Next 20 | t = t.Next 21 | } else { 22 | return false 23 | } 24 | } 25 | return true 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/3.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | //给定一个非负整数 n ，请计算 0 到 n 之间的每个数字的二进制表示中 1 的个数，并输出一个数组。 4 | 5 | func CountBits(n int) []int { 6 | ans := make([]int, 0) 7 | for i := 0; i <= n; i++ { 8 | cnt := 0 9 | num := i 10 | for num > 0 { 11 | num &= num - 1 12 | cnt++ 13 | } 14 | ans = append(ans, cnt) 15 | } 16 | return ans 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/4.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func singleNumber(nums []int) int { 4 | ans := 0 5 | for i := 0; i < 64; i++ { 6 | sum := 0 7 | for j := 0; j < len(nums); j++ { 8 | sum += (nums[j] >> i) & 1 9 | } 10 | ans = ans ^ (sum%3)< b { 24 | return a 25 | } else { 26 | return b 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/6.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func TwoSum(numbers []int, target int) []int { 4 | for i := 0; i < len(numbers); i++ { 5 | t := target - numbers[i] 6 | l, r := i+1, len(numbers) 7 | ans := -1 8 | for l < r { 9 | mid := l + (r-l)>>1 10 | if numbers[mid] > t { 11 | r = mid 12 | } else if numbers[mid] < t { 13 | l = mid + 1 14 | } else { 15 | ans = mid 16 | break 17 | } 18 | } 19 | if ans != -1 { 20 | return []int{i, ans} 21 | } 22 | } 23 | return []int{0, 0} 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/8.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | func minSubArrayLen(target int, nums []int) int { 4 | left := 0 5 | right := 0 6 | sum := 0 7 | minV := 1<<31 - 1 8 | for right < len(nums) { 9 | t := nums[right] 10 | right++ 11 | sum += t 12 | 13 | for sum >= target { 14 | minV = min(right-left, minV) 15 | t := nums[left] 16 | left++ 17 | sum -= t 18 | } 19 | } 20 | if minV == 1<<31-1 { 21 | return 0 22 | } 23 | return minV 24 | } 25 | 26 | func min(x, y int) int { 27 | if x < y { 28 | return x 29 | } 30 | return y 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/1-30/9.go: -------------------------------------------------------------------------------- 1 | package offer专项突击_1_30 2 | 3 | // 给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。 4 | 5 | // 每次增加的子数组的数量就是 当前子数组的长度 6 | func numSubarrayProductLessThanK(nums []int, k int) int { 7 | left := 0 8 | right := 0 9 | mul := 1 10 | ans := 0 11 | for right < len(nums) { 12 | t := nums[right] 13 | right++ 14 | mul *= t 15 | for mul >= k && left < right { 16 | t := nums[left] 17 | left++ 18 | mul /= t 19 | } 20 | ans += right - left 21 | } 22 | return ans 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/32.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func isAnagram(s string, t string) bool { 4 | if len(s) != len(t) || s == t { 5 | return false 6 | } 7 | cnt := map[rune]int{} 8 | for _, ch := range s { 9 | cnt[ch]++ 10 | } 11 | for _, ch := range t { 12 | cnt[ch]-- 13 | if cnt[ch] < 0 { 14 | return false 15 | } 16 | } 17 | return true 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/33.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func groupAnagrams(strs []string) [][]string { 4 | mp := map[[26]int][]string{} 5 | for i := 0; i < len(strs); i++ { 6 | cnt := [26]int{} 7 | for j := 0; j < len(strs[i]); j++ { 8 | cnt[strs[i][j]-'a']++ 9 | } 10 | mp[cnt] = append(mp[cnt], strs[i]) 11 | } 12 | ans := make([][]string, 0) 13 | for _, v := range mp { 14 | ans = append(ans, v) 15 | } 16 | return ans 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/34.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func isAlienSorted(words []string, order string) bool { 4 | morder := map[byte]int{} 5 | for i := 0; i < len(order); i++ { 6 | morder[order[i]] = i 7 | } 8 | out: 9 | for i := 0; i < len(words)-1; i++ { 10 | w0 := words[i] 11 | w1 := words[i+1] 12 | for j := 0; j < len(w0); j++ { 13 | if j < len(w1) && morder[w0[j]] > morder[w1[j]] { 14 | return false 15 | } else if j < len(w1) && morder[w0[j]] < morder[w1[j]] { 16 | continue out 17 | } else if j < len(w1) && morder[w0[j]] == morder[w1[j]] { 18 | continue 19 | } 20 | if j >= len(w1) { 21 | return false 22 | } 23 | } 24 | } 25 | return true 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/38.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func dailyTemperatures(temperatures []int) []int { 4 | stack := make([]int, 0) 5 | ans := make([]int, len(temperatures)) 6 | right := make([]int, len(temperatures)) 7 | for i := 0; i < len(temperatures); i++ { 8 | for len(stack) != 0 { 9 | top := temperatures[stack[len(stack)-1]] 10 | if top < temperatures[i] { 11 | stack = stack[:len(stack)-1] 12 | right[top] = i 13 | } else { 14 | break 15 | } 16 | } 17 | stack = append(stack, i) 18 | } 19 | for i := 0; i < len(temperatures); i++ { 20 | if right[i] != 0 { 21 | ans[i] = right[i] - i 22 | } else { 23 | ans[i] = 0 24 | } 25 | } 26 | return ans 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/41.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | type MovingAverage struct { 4 | right int 5 | size int 6 | nums []int 7 | sum int 8 | le int 9 | } 10 | 11 | /** Initialize your data structure here. */ 12 | func Constructor4(size int) MovingAverage { 13 | return MovingAverage{right: 0, size: size, nums: make([]int, 0)} 14 | } 15 | 16 | func (this *MovingAverage) Next(val int) float64 { 17 | if this.right < this.size { 18 | this.nums = append(this.nums, val) 19 | this.le++ 20 | this.right++ 21 | this.sum += val 22 | } else { 23 | this.nums = append(this.nums, val) 24 | this.sum -= this.nums[0] 25 | this.nums = this.nums[1:] 26 | } 27 | return float64(this.sum) / float64(this.le) 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/42.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | type RecentCounter struct { 4 | queue []int 5 | } 6 | 7 | func Constructor5() RecentCounter { 8 | return RecentCounter{ 9 | queue: make([]int, 0), 10 | } 11 | } 12 | 13 | func (this *RecentCounter) Ping(t int) int { 14 | left := t - 3000 15 | for len(this.queue) != 0 && this.queue[0] < left { 16 | this.queue = this.queue[1:] 17 | } 18 | this.queue = append(this.queue, t) 19 | return len(this.queue) 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/44.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | import "math" 4 | 5 | func largestValues(root *TreeNode) []int { 6 | ans := make([]int, 0) 7 | if root == nil { 8 | return ans 9 | } 10 | q := make([]*TreeNode, 0) 11 | q = append(q, root) 12 | for len(q) != 0 { 13 | le := len(q) 14 | max := -1 << 31 15 | for i := 0; i < le; i++ { 16 | node := q[0] 17 | max = int(math.Max(float64(max), float64(node.Val))) 18 | q = q[1:] 19 | if node.Left != nil { 20 | q = append(q, node.Left) 21 | } 22 | if node.Right != nil { 23 | q = append(q, node.Right) 24 | } 25 | } 26 | ans = append(ans, max) 27 | } 28 | return ans 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/45.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func findBottomLeftValue(root *TreeNode) int { 4 | curheight := 0 5 | val := -1 6 | var dfs = func(root *TreeNode, height int) {} 7 | dfs = func(root *TreeNode, height int) { 8 | if root == nil { 9 | return 10 | } 11 | height++ 12 | dfs(root.Left, height) 13 | dfs(root.Right, height) 14 | if curheight < height { 15 | curheight = height 16 | val = root.Val 17 | } 18 | } 19 | dfs(root, 0) 20 | return val 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/46.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func RightSideView(root *TreeNode) []int { 4 | ans := make([]int, 0) 5 | curhight := 0 6 | if root == nil { 7 | return ans 8 | } 9 | var dfs func(root *TreeNode, height int) 10 | dfs = func(root *TreeNode, height int) { 11 | if root == nil { 12 | return 13 | } 14 | height++ 15 | if curhight < height { 16 | curhight = height 17 | ans = append(ans, root.Val) 18 | } 19 | dfs(root.Right, height) 20 | dfs(root.Left, height) 21 | 22 | } 23 | dfs(root, 0) 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/49.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func sumNumbers(root *TreeNode) int { 4 | sum := 0 5 | var dfs func(root *TreeNode, s int) 6 | dfs = func(root *TreeNode, s int) { 7 | if root == nil { 8 | return 9 | } 10 | if root.Left == nil && root.Right == nil { 11 | sum = sum + s*10 + root.Val 12 | return 13 | } 14 | dfs(root.Left, s*10+root.Val) 15 | dfs(root.Right, s*10+root.Val) 16 | } 17 | dfs(root, 0) 18 | return sum 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/51.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | import "math" 4 | 5 | func MaxPathSum(root *TreeNode) int { 6 | if root == nil { 7 | return 0 8 | } 9 | ml := -1 << 63 10 | var dfs func(*TreeNode) int 11 | dfs = func(node *TreeNode) int { 12 | if node == nil { 13 | return 0 14 | } 15 | left := dfs(node.Left) 16 | right := dfs(node.Right) 17 | if left < 0 { 18 | left = 0 19 | } 20 | if right < 0 { 21 | right = 0 22 | } 23 | sum := left + right + node.Val 24 | ml = int(math.Max(float64(ml), float64(sum))) 25 | return node.Val + int(math.Max(float64(left), float64(right))) 26 | } 27 | dfs(root) 28 | return ml 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/53.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode { 4 | var st []*TreeNode 5 | var pre, cur *TreeNode = nil, root 6 | for len(st) > 0 || cur != nil { 7 | for cur != nil { 8 | st = append(st, cur) 9 | cur = cur.Left 10 | } 11 | cur = st[len(st)-1] 12 | st = st[:len(st)-1] 13 | if pre == p { 14 | return cur 15 | } 16 | pre = cur 17 | cur = cur.Right 18 | } 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/54.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | // 反中序 写一个非递归吧 4 | func convertBST(root *TreeNode) *TreeNode { 5 | if root == nil { 6 | return root 7 | } 8 | ans := root 9 | stack := []*TreeNode{} 10 | sum := 0 11 | for len(stack) != 0 || root != nil { 12 | for root != nil { 13 | stack = append(stack, root) 14 | root = root.Right 15 | } 16 | node := stack[len(stack)-1] 17 | stack = stack[:len(stack)-1] 18 | sum += node.Val 19 | node.Val = sum 20 | root = node.Left 21 | } 22 | return ans 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/56.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | func findTarget(root *TreeNode, k int) bool { 4 | set := map[int]struct{}{} 5 | var dfs func(*TreeNode, int) bool 6 | dfs = func(node *TreeNode, t int) bool { 7 | if node == nil { 8 | return false 9 | } 10 | if _, ok := set[t-node.Val]; ok { 11 | return true 12 | } 13 | set[node.Val] = struct{}{} 14 | return dfs(node.Left, t) || dfs(node.Right, t) 15 | } 16 | return dfs(root, k) 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/31-60/60.go: -------------------------------------------------------------------------------- 1 | package _1_60 2 | 3 | // 桶排序 4 | func topKFrequent(nums []int, k int) []int { 5 | mp := map[int]int{} 6 | for i := 0; i < len(nums); i++ { 7 | mp[nums[i]]++ 8 | } 9 | t := map[int][]int{} 10 | for k, v := range mp { 11 | t[v] = append(t[v], k) 12 | } 13 | // 模拟桶 14 | cnt := 0 15 | ans := make([]int, 0) 16 | out: 17 | for n := len(nums); n > 0; n-- { 18 | if _, ok := t[n]; ok { 19 | cnt += len(t[n]) 20 | ans = append(ans, t[n]...) 21 | if cnt == k { 22 | break out 23 | } 24 | } 25 | } 26 | return ans 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/63.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | import ( 4 | "math" 5 | "strings" 6 | ) 7 | 8 | // 将前缀插入字典数，然后根据每个词搜索字典数有没有符合的前缀，找到一个isEnd的就返回true 9 | // 然后replace同理，在isEnd前面并且存在的就添加进stringBuilder 10 | func replaceWords(dictionary []string, sentence string) string { 11 | tr := Trie{child: [26]*Trie{}, isEnd: false} 12 | strs := strings.Split(sentence, " ") 13 | for i := 0; i < len(strs); i++ { 14 | word := strs[i] 15 | tr.Insert(word) 16 | ml := math.MaxInt 17 | for _, prefix := range dictionary { 18 | if len(prefix) < ml && tr.StartsWith(prefix) { 19 | ml = len(prefix) 20 | strs[i] = prefix 21 | } 22 | } 23 | tr.remove(word) 24 | } 25 | return strings.Join(strs, " ") 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/68.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | // 给定一个排序的整数数组 nums 和一个整数目标值 target ，请在数组中找到 target ，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 4 | // 5 | //请必须使用时间复杂度为 O(log n) 的算法。 6 | // 7 | 8 | func searchInsert(nums []int, target int) int { 9 | l, r := 0, len(nums) 10 | for l < r { 11 | mid := l + (r-l)>>1 12 | if nums[mid] < target { 13 | l = mid + 1 14 | } else { 15 | r = mid 16 | } 17 | } 18 | return l 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/69.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | func peakIndexInMountainArray(arr []int) int { 4 | l, r := 0, len(arr)-1 5 | var ans int 6 | for l < r { 7 | mid := l + (r-l)<<1 8 | if arr[mid] > arr[mid+1] { 9 | ans = mid 10 | r = mid 11 | } else { 12 | l = mid + 1 13 | } 14 | } 15 | return ans 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/70.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | // 非规则数的左边，偶数与+1的值相等，奇数与-1的值相等 4 | func singleNonDuplicate(nums []int) int { 5 | l, r := 0, len(nums)-1 6 | // 右移的时候 7 | for l < r { 8 | mid := l + (r-l)>>1 9 | // mid为奇数的时候，mid^1为mid-1 10 | if nums[mid] == nums[mid^1] { 11 | l = mid + 1 12 | } else { 13 | r = mid 14 | } 15 | } 16 | return nums[l] 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/72.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | func mySqrt(x int) int { 4 | l, r := 0, x+1 5 | for l < r { 6 | mid := l + (r-l)>>1 7 | if mid*mid <= x { 8 | l = mid + 1 9 | } else { 10 | r = mid 11 | } 12 | } 13 | return l - 1 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/73.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | func minEatingSpeed(piles []int, h int) int { 4 | l, r := 1, 1000000001 5 | for l < r { 6 | mid := l + (r-l)>>1 7 | if eatBan(piles, mid) <= h { 8 | r = mid 9 | } else { 10 | l = mid + 1 11 | } 12 | } 13 | return l 14 | } 15 | 16 | // 求符合条件的最小速度 17 | func eatBan(piles []int, k int) int { 18 | h := 0 19 | for i := 0; i < len(piles); i++ { 20 | del := piles[i] / k 21 | if del == 0 { 22 | h += 1 23 | } else { 24 | h += del 25 | } 26 | if del != 0 && piles[i]%k != 0 { 27 | h += 1 28 | } 29 | } 30 | return h 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/74.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | import ( 4 | "math" 5 | "sort" 6 | ) 7 | 8 | func merge(intervals [][]int) [][]int { 9 | ans := make([][]int, 0) 10 | if len(intervals) == 0 { 11 | return ans 12 | } 13 | sort.Slice(intervals, func(i, j int) bool { 14 | return intervals[i][0] < intervals[j][0] 15 | }) 16 | for i := 0; i < len(intervals); i++ { 17 | l := intervals[i][0] 18 | r := intervals[i][1] 19 | if len(ans) == 0 || ans[len(ans)-1][1] < l { 20 | ans = append(ans, []int{l, r}) 21 | } else { 22 | ans[len(ans)-1][1] = int(math.Max(float64(ans[len(ans)-1][1]), float64(r))) 23 | } 24 | } 25 | return ans 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/61-78/78.go: -------------------------------------------------------------------------------- 1 | package _1_78 2 | 3 | func mergeKLists(lists []*ListNode) *ListNode { 4 | if len(lists) == 0 { 5 | return nil 6 | } 7 | if len(lists) == 1 { 8 | return lists[0] 9 | } 10 | mid := len(lists) / 2 11 | l := mergeKLists(lists[:mid]) 12 | r := mergeKLists(lists[mid:]) 13 | return mergeList(l, r) 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dfs 79-87/80.go: -------------------------------------------------------------------------------- 1 | package dfs_79_87 2 | 3 | func combine(n int, k int) (ans [][]int) { 4 | path := make([]int, 0) 5 | var dfs func(n int, startIdx int) 6 | dfs = func(n int, start int) { 7 | if len(path)+(n-start+1) < k { 8 | return 9 | } 10 | if len(path) == k { 11 | ans = append(ans, append([]int(nil), path...)) 12 | return 13 | } 14 | for i := start; i <= n; i++ { 15 | path = append(path, i) 16 | dfs(n, i+1) 17 | path = path[:len(path)-1] 18 | } 19 | return 20 | } 21 | dfs(n, 1) 22 | return 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dfs 79-87/81.go: -------------------------------------------------------------------------------- 1 | package dfs_79_87 2 | 3 | import "sort" 4 | 5 | func combinationSum(candidates []int, target int) (ans [][]int) { 6 | sort.Ints(candidates) 7 | path := make([]int, 0) 8 | var dfs func(int, int) 9 | dfs = func(sum int, idx int) { 10 | if idx == len(candidates) { 11 | return 12 | } 13 | if sum == target { 14 | ans = append(ans, append([]int(nil), path...)) 15 | } 16 | if sum > target { 17 | return 18 | } 19 | for i := idx; i < len(candidates); i++ { 20 | path = append(path, candidates[i]) 21 | sum += candidates[i] 22 | dfs(sum, i) 23 | sum -= candidates[i] 24 | path = path[:len(path)-1] 25 | } 26 | } 27 | dfs(0, 0) 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dfs 79-87/83.go: -------------------------------------------------------------------------------- 1 | package dfs_79_87 2 | 3 | func permute(nums []int) (ans [][]int) { 4 | path := make([]int, 0) 5 | used := make([]bool, len(nums)) 6 | var dfs func() 7 | dfs = func() { 8 | if len(path) == len(nums) { 9 | ans = append(ans, append([]int(nil), path...)) 10 | } 11 | for i := 0; i < len(nums); i++ { 12 | if used[i] { 13 | continue 14 | } 15 | used[i] = true 16 | path = append(path, nums[i]) 17 | dfs() 18 | path = path[:len(path)-1] 19 | used[i] = false 20 | } 21 | } 22 | dfs() 23 | return 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dfs 79-87/84.go: -------------------------------------------------------------------------------- 1 | package dfs_79_87 2 | 3 | import "sort" 4 | 5 | func permuteUnique(nums []int) (ans [][]int) { 6 | path := make([]int, 0) 7 | used := make([]bool, len(nums)) 8 | sort.Ints(nums) 9 | var dfs func() 10 | dfs = func() { 11 | if len(path) == len(nums) { 12 | ans = append(ans, append([]int(nil), path...)) 13 | } 14 | for i := 0; i < len(nums); i++ { 15 | if i-1 >= 0 && nums[i] == nums[i-1] && !used[i-1] { 16 | continue 17 | } 18 | if used[i] { 19 | continue 20 | } 21 | used[i] = true 22 | path = append(path, nums[i]) 23 | dfs() 24 | path = path[:len(path)-1] 25 | used[i] = false 26 | } 27 | } 28 | dfs() 29 | return 30 | } 31 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dfs 79-87/85.go: -------------------------------------------------------------------------------- 1 | package dfs_79_87 2 | 3 | // 解析 4 | // https://leetcode.cn/problems/IDBivT/solution/jian-dan-yi-dong-javac-pythonjs-pei-yang-mmhs/ 5 | // 抽象成树之后，左节点是(,右节点是) 6 | func generateParenthesis(n int) (ans []string) { 7 | var dfs func(int, int, string) 8 | dfs = func(left, right int, path string) { 9 | if left > n || right > left { 10 | return 11 | } 12 | if len(path) == n*2 { 13 | ans = append(ans, path) 14 | return 15 | } 16 | dfs(left+1, right, path+"(") 17 | dfs(left, right+1, path+")") 18 | } 19 | dfs(0, 0, "") 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/100.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func minimumTotal(triangle [][]int) int { 4 | if len(triangle) == 0 || len(triangle[0]) == 0 { 5 | return 0 6 | } 7 | res := make([][]int, len(triangle)) 8 | for f := range res { 9 | res[f] = make([]int, len(triangle[f])) 10 | for j := range res[f] { 11 | res[f][j] = triangle[f][j] 12 | } 13 | } 14 | for i := len(triangle) - 2; i >= 0; i-- { 15 | for j := 0; j < len(triangle[i]); j++ { 16 | res[i][j] = min(res[i+1][j], res[i+1][j+1]) + triangle[i][j] 17 | } 18 | } 19 | return res[0][0] 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/103.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func coinChange(coins []int, amount int) int { 4 | dp := make([]int, amount+1) 5 | for i := 0; i < len(dp); i++ { 6 | dp[i] = amount + 1 7 | } 8 | dp[0] = 0 9 | for i := 0; i < len(coins); i++ { 10 | for j := 1; j <= amount; j++ { 11 | if j >= coins[i] { 12 | dp[j] = min(dp[j], dp[j-coins[i]]+1) 13 | } 14 | } 15 | } 16 | if dp[amount] > amount { 17 | return -1 18 | } 19 | return dp[amount] 20 | } 21 | 22 | //func min(a, b int) int { 23 | // if a < b { 24 | // return a 25 | // } else { 26 | // return b 27 | // } 28 | //} 29 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/104.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func combinationSum4(nums []int, target int) int { 4 | dp := make([]int, target+1) 5 | // dp[i]表示选取元素等于i的方案数 6 | dp[0] = 1 7 | for i := 1; i <= target; i++ { 8 | for _, v := range nums { 9 | // 只要比i小都可以加进去 10 | if i >= v { 11 | dp[i] += dp[i-v] 12 | } 13 | } 14 | } 15 | return dp[target] 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/88.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func minCostClimbingStairs(cost []int) int { 4 | dp := make([]int, len(cost)+1) 5 | for i := 2; i <= len(cost); i++ { 6 | dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]) 7 | } 8 | return dp[len(cost)] 9 | } 10 | 11 | func minCostClimbingStairs2(cost []int) int { 12 | pre, cur := 0, 0 13 | for i := 2; i <= len(cost); i++ { 14 | pre, cur = cur, min(pre+cost[i-2], cur+cost[i-1]) 15 | } 16 | return cur 17 | } 18 | 19 | func min(a, b int) int { 20 | if a < b { 21 | return a 22 | } else { 23 | return b 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/89.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func rob(nums []int) int { 4 | pre := nums[0] 5 | if len(nums) == 1 { 6 | return pre 7 | } 8 | if len(nums) == 2 { 9 | return max(nums[0], nums[1]) 10 | } 11 | cur := max(nums[0], nums[1]) 12 | for i := 2; i < len(nums); i++ { 13 | next := max(nums[i]+pre, cur) 14 | pre = cur 15 | cur = next 16 | } 17 | return cur 18 | } 19 | 20 | func max(a, b int) int { 21 | if a < b { 22 | return b 23 | } else { 24 | return a 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/90.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func rob2(nums []int) int { 4 | n := len(nums) 5 | if n == 1 { 6 | return nums[0] 7 | } 8 | if n == 2 { 9 | return max(nums[0], nums[1]) 10 | } 11 | return max(_rob(nums[:n-1]), _rob(nums[1:])) 12 | } 13 | 14 | func _rob(nums []int) int { 15 | first, second := nums[0], max(nums[0], nums[1]) 16 | for i := 2; i < len(nums); i++ { 17 | first, second = second, max(first+nums[i], second) 18 | } 19 | return second 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/91.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | // https://leetcode.cn/problems/JEj789/ 4 | 5 | func minCost(costs [][]int) int { 6 | a := costs[0][0] 7 | b := costs[0][1] 8 | c := costs[0][2] 9 | for i := 1; i < len(costs); i++ { 10 | d := _min(b, c) + costs[i][0] 11 | e := _min(a, c) + costs[i][1] 12 | f := _min(a, b) + costs[i][2] 13 | a, b, c = d, e, f 14 | } 15 | return _min(a, _min(b, c)) 16 | } 17 | 18 | func _min(a, b int) int { 19 | if a < b { 20 | return a 21 | } else { 22 | return b 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/92.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | // https://leetcode.cn/problems/cyJERH/ 4 | 5 | func minFlipsMonoIncr(s string) int { 6 | n := len(s) 7 | a, b := 0, 0 8 | for i := 0; i < n; i++ { 9 | a1 := a + int(s[i]-'0') 10 | b1 := min(a, b) + (int(s[i]-'0') ^ 1) 11 | a, b = a1, b1 12 | } 13 | return min(a, b) 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/93.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func lenLongestFibSubseq(arr []int) (ans int) { 4 | n := len(arr) 5 | dp := make([][]int, n) 6 | for f := range dp { 7 | dp[f] = make([]int, n) 8 | } 9 | for i := 2; i < n; i++ { 10 | j, k := 0, i-1 11 | for j < k { 12 | if arr[j]+arr[k] == arr[i] { 13 | if dp[k][i] == 0 { 14 | dp[k][i] = 3 15 | } else { 16 | dp[k][i] = max(dp[k][i], dp[j][k]+1) 17 | } 18 | ans = max(ans, dp[k][i]) 19 | j++ 20 | k-- 21 | } else if arr[j]+arr[k] < arr[i] { 22 | j++ 23 | } else { 24 | k-- 25 | } 26 | } 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/94.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | // https://leetcode.cn/problems/omKAoA/ 4 | 5 | func minCut(s string) int { 6 | n := len(s) 7 | // 提前dp, 空间换时间 8 | mk := make([][]bool, n) 9 | for f := range mk { 10 | mk[f] = make([]bool, n) 11 | for j := range mk[f] { 12 | mk[f][j] = true 13 | } 14 | } 15 | for i := n - 1; i >= 0; i-- { 16 | for j := i + 1; j < n; j++ { 17 | mk[i][j] = s[i] == s[j] && mk[i+1][j-1] 18 | } 19 | } 20 | dp := make([]int, n+1) 21 | dp[0] = -1 22 | for i := 1; i <= len(s); i++ { 23 | dp[i] = i 24 | for j := 0; j < i; j++ { 25 | if mk[j][i-1] { 26 | dp[i] = min(dp[j]+1, dp[i]) 27 | } 28 | } 29 | } 30 | return dp[n] 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/95.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func longestCommonSubsequence(text1 string, text2 string) int { 4 | m, n := len(text1), len(text2) 5 | dp := make([][]int, m+1) 6 | for i := 0; i < len(dp); i++ { 7 | dp[i] = make([]int, n+1) 8 | } 9 | for i := 1; i <= m; i++ { 10 | for j := 1; j <= n; j++ { 11 | if text1[i-1] == text2[i-1] { 12 | dp[i][j] = dp[i-1][j-1] + 1 13 | } else { 14 | dp[i][j] = max(dp[i-1][j-1], max(dp[i-1][j], dp[i][j-1])) 15 | } 16 | } 17 | } 18 | return dp[m][n] 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/96.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | // i-1与i+j-1的值相等 4 | // j-1与i+j-1相等 5 | func isInterleave(s1 string, s2 string, s3 string) bool { 6 | m, n := len(s1), len(s2) 7 | if m+n != len(s3) { 8 | return false 9 | } 10 | dp := make([][]bool, m+1) 11 | for i := 0; i < len(dp); i++ { 12 | dp[i] = make([]bool, n+1) 13 | } 14 | dp[0][0] = true 15 | for i := 0; i <= m; i++ { 16 | for j := 0; j <= n; j++ { 17 | p := i + j - 1 18 | if i > 0 { 19 | dp[i][j] = dp[i][j] || dp[i-1][j] && s1[i-1] == s3[p] 20 | } 21 | if j > 0 { 22 | dp[i][j] = dp[i][j] || dp[i][j-1] && s2[j-1] == s3[p] 23 | } 24 | } 25 | } 26 | return dp[m][n] 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/97.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func numDistinct(s string, t string) int { 4 | m, n := len(s), len(t) 5 | if m < n { 6 | return 0 7 | } 8 | dp := make([][]int, m+1) 9 | for f := range dp { 10 | dp[f] = make([]int, n+1) 11 | dp[f][n] = 1 12 | } 13 | for i := m - 1; i >= 0; i-- { 14 | for j := n - 1; j >= 0; j-- { 15 | // 如果匹配 16 | if s[i] == t[j] { 17 | dp[i][j] = dp[i+1][j+1] + dp[i+1][j] 18 | } else { 19 | dp[i][j] = dp[i+1][j] 20 | } 21 | } 22 | } 23 | return dp[0][0] 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/98.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func uniquePaths(m int, n int) int { 4 | dp := make([][]int, m) 5 | for f := range dp { 6 | dp[f] = make([]int, n) 7 | } 8 | for i := 0; i < m; i++ { 9 | dp[i][0] = 1 10 | } 11 | for i := 0; i < n; i++ { 12 | dp[0][i] = 1 13 | } 14 | for i := 1; i < m; i++ { 15 | for j := 1; j < n; j++ { 16 | dp[i][j] = dp[i-1][j] + dp[i][j-1] 17 | } 18 | } 19 | return dp[m-1][n-1] 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/dp 88-104/99.go: -------------------------------------------------------------------------------- 1 | package dp_88_104 2 | 3 | func minPathSum(grid [][]int) int { 4 | dp := make([][]int, len(grid)) 5 | for i := 0; i < len(dp); i++ { 6 | dp[i] = make([]int, len(grid[0])) 7 | } 8 | dp[0][0] = grid[0][0] 9 | for i := 1; i < len(grid); i++ { 10 | dp[i][0] = dp[i-1][0] + grid[i][0] 11 | } 12 | for i := 1; i < len(grid[0]); i++ { 13 | dp[0][i] = dp[0][i-1] + grid[0][i] 14 | } 15 | for i := 1; i < len(grid); i++ { 16 | for j := 1; j < len(grid[i]); j++ { 17 | dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j] 18 | } 19 | } 20 | return dp[len(grid)-1][len(grid[0])-1] 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/graph 105-119/108.go: -------------------------------------------------------------------------------- 1 | package graph_105_119 2 | 3 | func ladderLength(beginWord string, endWord string, wordList []string) int { 4 | return 0 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/offer/offer专项突击/graph 105-119/110.go: -------------------------------------------------------------------------------- 1 | package graph_105_119 2 | 3 | func allPathsSourceTarget(graph [][]int) (ans [][]int) { 4 | path := []int{0} 5 | var dfs func(int) 6 | dfs = func(x int) { 7 | if x == len(graph)-1 { 8 | ans = append(ans, append([]int(nil), path...)) 9 | return 10 | } 11 | for _, y := range graph[x] { 12 | path = append(path, y) 13 | dfs(y) 14 | path = path[:len(path)-1] 15 | } 16 | } 17 | dfs(0) 18 | return 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/other/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /leetcode/other/meituan/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func maxProfit(prices []int) int { 6 | ans := 0 7 | ml := math.MaxInt 8 | for _, p := range prices { 9 | if p < ml { 10 | ml = p 11 | } 12 | ans = int(math.Max(float64(p-ml), float64(ans))) 13 | } 14 | return ans 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/other/meituan/3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func twoSum(nums []int, target int) []int { 4 | hashTable := map[int]int{} 5 | for i, x := range nums { 6 | if p, ok := hashTable[target-x]; ok { 7 | return []int{p, i} 8 | } 9 | hashTable[x] = i 10 | } 11 | return nil 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/other/meituan/5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func candy(ratings []int) (ans int) { 6 | n := len(ratings) 7 | left := make([]int, n) 8 | for i, c := range ratings { 9 | if i > 0 && c > ratings[i-1] { 10 | left[i] = left[i-1] + 1 11 | } else { 12 | left[i] = 1 13 | } 14 | } 15 | right := 0 16 | for i := n - 1; i >= 0; i-- { 17 | if i < n-1 && ratings[i] > ratings[i+1] { 18 | right++ 19 | } else { 20 | right = 1 21 | } 22 | ans += int(math.Max(float64(left[i]), float64(right))) 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/other/tusen/1/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func removeElement(nums []int, val int) int { 4 | j := 0 5 | for i := 0; i < len(nums); i++ { 6 | if nums[i] == val { 7 | nums[i], nums[j] = nums[j], nums[i] 8 | j++ 9 | } 10 | } 11 | return j 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/other/tusen/2/1.go: -------------------------------------------------------------------------------- 1 | package tusen2 2 | 3 | // 4 | //import ( 5 | // "fmt" 6 | // "unicode" 7 | //) 8 | // 9 | //func questionbank() { 10 | // var s string 11 | // fmt.Scanln(&s) 12 | // f := false 13 | // cnt := 0 14 | // for _, v := range s { 15 | // if unicode.IsDigit(rune(v)) { 16 | // if !f { 17 | // f = true 18 | // cnt++ 19 | // } 20 | // } else { 21 | // f = false 22 | // } 23 | // } 24 | // fmt.Println(cnt) 25 | //} 26 | -------------------------------------------------------------------------------- /leetcode/other/tusen/2/2.go: -------------------------------------------------------------------------------- 1 | package tusen2 2 | 3 | func findLUSlength(strs []string) int { 4 | isSub := func(s, t string) bool { 5 | if len(s) > len(t) { 6 | return false 7 | } 8 | sidx := 0 9 | for tidx := range t { 10 | if s[sidx] == t[tidx] { 11 | if sidx++; sidx == len(s) { 12 | return true 13 | } 14 | } 15 | } 16 | return false 17 | } 18 | n := len(strs) 19 | ans := -1 20 | out: 21 | for i := 0; i < n; i++ { 22 | for j := 0; j < n; j++ { 23 | if i != j && isSub(strs[i], strs[j]) { 24 | continue out 25 | } 26 | } 27 | if len(strs[i]) > ans { 28 | ans = len(strs[i]) 29 | } 30 | } 31 | return ans 32 | } 33 | -------------------------------------------------------------------------------- /leetcode/other/tusen/3/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isValidSudoku(board [][]byte) bool { 4 | var row, col [9][9]int 5 | var subBox [3][3][9]int 6 | for i := range board { 7 | for j := range board[i] { 8 | c := board[i][j] 9 | if c != '.' { 10 | idx := c - '1' 11 | row[i][idx]++ 12 | col[i][idx]++ 13 | subBox[i/3][j/3][idx]++ 14 | if row[i][idx] > 1 || col[j][idx] > 1 || subBox[i/3][j/3][idx] > 1 { 15 | return false 16 | } 17 | } 18 | } 19 | } 20 | return true 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/other/tusen/4/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func isUnivalTree(root *TreeNode) bool { 10 | val := root.Val 11 | var dfs func(root *TreeNode) bool 12 | dfs = func(root *TreeNode) bool { 13 | if root != nil && root.Val != val { 14 | return false 15 | } 16 | if root == nil { 17 | return true 18 | } 19 | return dfs(root.Left) && dfs(root.Right) 20 | } 21 | return dfs(root) 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/other/tusen/4/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findLength(nums1 []int, nums2 []int) int { 4 | m, n := len(nums1), len(nums2) 5 | dp := make([][]int, n+1) 6 | for i := range dp { 7 | dp[i] = make([]int, m+1) 8 | } 9 | ans := 0 10 | for i := n - 1; i >= 0; i-- { 11 | for j := m - 1; j >= 0; j-- { 12 | if nums1[i] == nums2[j] { 13 | dp[i][j] = dp[i+1][j+1] + 1 14 | } else { 15 | dp[i][j] = 0 16 | } 17 | ans = max(ans, dp[i][j]) 18 | } 19 | } 20 | return ans 21 | } 22 | 23 | func max(a, b int) int { 24 | if a > b { 25 | return a 26 | } else { 27 | return b 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/other/tusen/5/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/relative-sort-array/submissions/ 6 | 7 | func relativeSortArray(arr1 []int, arr2 []int) []int { 8 | rank := map[int]int{} 9 | for i, v := range arr2 { 10 | rank[v] = i 11 | } 12 | sort.Slice(arr1, func(i, j int) bool { 13 | x, y := arr1[i], arr1[j] 14 | rankX, hasX := rank[x] 15 | rankY, hasY := rank[y] 16 | if hasX && hasY { 17 | return rankX < rankY 18 | } 19 | if hasX || hasY { 20 | return hasX 21 | } 22 | return x < y 23 | }) 24 | return arr1 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/other/tusen/6/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/excel-sheet-column-number/ 4 | func titleToNumber(columnTitle string) (number int) { 5 | for i, multiple := len(columnTitle)-1, 1; i >= 0; i-- { 6 | k := columnTitle[i] - 'A' + 1 7 | number += int(k) * multiple 8 | multiple *= 26 9 | } 10 | return 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/other/tusen/6/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | type RangeFreqQuery struct{ pos [1e4 + 1]sort.IntSlice } 6 | 7 | func Constructor(arr []int) (q RangeFreqQuery) { 8 | for i, value := range arr { 9 | q.pos[value] = append(q.pos[value], i) // 统计 value 在 arr 中的所有下标位置 10 | } 11 | return 12 | } 13 | 14 | func (q *RangeFreqQuery) Query(left, right, value int) int { 15 | p := q.pos[value] // valaue 在 arr 中的所有下标位置 16 | return p[p.Search(left):].Search(right + 1) // 在下标位置上二分，求 [left,right] 之间的下标个数，即为 value 的频率 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/41.go: -------------------------------------------------------------------------------- 1 | package main 2 | func firstMissingPositive(nums []int) int { 3 | n := len(nums) 4 | for i, num := range nums { 5 | if num <= 0 { 6 | nums[i] = n + 1 7 | } 8 | } 9 | for _, num := range nums { 10 | num = abs(num) 11 | if num <= n { 12 | nums[num - 1] = -abs(nums[num-1]) 13 | } 14 | } 15 | for i, num := range nums { 16 | if num > 0 { 17 | return i + 1 18 | } 19 | } 20 | return n + 1 21 | } 22 | 23 | func abs(x int)int { 24 | if x < 0 { 25 | return -x 26 | }else { 27 | return x 28 | } 29 | } -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/48.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 先水平翻转，再对角线翻转，等于顺时针90度 4 | func rotate(matrix [][]int) { 5 | n := len(matrix) 6 | for i := 0; i < n/2; i++ { 7 | for j := 0; j < n; j++ { 8 | matrix[i][j], matrix[n-1-i][j] = matrix[n-1-j][j], matrix[i][j] 9 | } 10 | } 11 | 12 | for i := 0; i < n; i++ { 13 | for j := 0; j < i; j++ { 14 | matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/49.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func groupAnagrams(strs []string) [][]string { 6 | mp := map[string][]string{} 7 | for _, str := range strs { 8 | s := []byte(str) 9 | sort.Slice(s, func(i, j int) bool { return s[i] < s[j] }) 10 | sortedStr := string(s) 11 | mp[sortedStr] = append(mp[sortedStr], str) 12 | } 13 | ans := make([][]string, 0, len(mp)) 14 | for _, v := range mp { 15 | ans = append(ans, v) 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/50.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2 -2 4 | func myPow(x float64, n int) (ans float64) { 5 | ans = 1 6 | if n < 0 { 7 | n = -n 8 | x = 1 / x 9 | } 10 | for n != 0 { 11 | if n&1 == 1 { 12 | ans *= x 13 | } 14 | x = x * x 15 | n >>= 1 16 | } 17 | return 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/56.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func merge(intervals [][]int) (ans [][]int) { 6 | sort.Slice(intervals, func(i, j int) bool { 7 | return intervals[i][0] < intervals[j][0] 8 | }) 9 | n := len(intervals) 10 | for i := 0; i < n; i++ { 11 | left, right := intervals[i][0], intervals[i][1] 12 | for ; i+1 < n && right >= intervals[i+1][0]; i++ { 13 | r := intervals[i+1][1] 14 | if r > right { 15 | right = r 16 | } 17 | } 18 | ans = append(ans, []int{left, right}) 19 | } 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/59.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func generateMatrix(n int) (ans [][]int) { 4 | var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} 5 | ans = make([][]int, n) 6 | for i := range ans { 7 | ans[i] = make([]int, n) 8 | } 9 | tot := n * n 10 | vis := make([][]bool, n) 11 | for i := range vis { 12 | vis[i] = make([]bool, n) 13 | } 14 | x, y := 0, 0 15 | idx := 0 16 | cnt := 1 17 | for k := 0; k < tot; k++ { 18 | vis[x][y] = true 19 | ans[x][y] = cnt 20 | cnt++ 21 | i, j := x+dirs[idx][0], y+dirs[idx][1] 22 | if i < 0 || i >= n || j < 0 || j >= n || vis[i][j] { 23 | idx = (idx + 1) % 4 24 | } 25 | i, j = x+dirs[idx][0], y+dirs[idx][1] 26 | x, y = i, j 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/61.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // 弄成一个环 9 | func rotateRight(head *ListNode, k int) *ListNode { 10 | if head == nil || head.Next == nil || k == 0 { 11 | return head 12 | } 13 | n := 1 14 | it := head 15 | for it.Next != nil { 16 | it = it.Next 17 | n++ 18 | } 19 | add := n - k%n 20 | if add == n { 21 | return head 22 | } 23 | it.Next = head 24 | for add > 0 { 25 | it = it.Next 26 | add-- 27 | } 28 | res := it.Next 29 | it.Next = nil 30 | return res 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/65.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isNumber(self, s: str) -> bool: 3 | pass -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/71.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func simplifyPath(path string) string { 6 | stk := make([]string, 0) 7 | data := strings.Split(path, "/") 8 | for _, name := range data { 9 | if name == ".." { 10 | if len(stk) > 0 { 11 | stk = stk[:len(stk)-1] 12 | } 13 | } else if name != "" && name != "." { 14 | stk = append(stk, name) 15 | } 16 | } 17 | return "/" + strings.Join(stk, "/") 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/75.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/sort-colors/ 4 | // 3指针 5 | func sortColors(nums []int) { 6 | n := len(nums) 7 | l, r := 0, n-1 8 | i := 0 9 | for i <= r { 10 | if nums[i] == 0 { 11 | nums[l], nums[i] = nums[i], nums[l] 12 | l++ 13 | i++ 14 | } else if nums[i] == 1 { 15 | i++ 16 | } else if nums[i] == 2 { 17 | nums[i], nums[r] = nums[r], nums[i] 18 | r-- 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/77.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func combine(n int, k int) (ans [][]int) { 4 | path := []int{} 5 | var dfs func(int) 6 | dfs = func(start int) { 7 | if len(path) == k { 8 | ans = append(ans, append([]int(nil), path...)) 9 | } 10 | for i := start; i <= n; i++ { 11 | path = append(path, i) 12 | dfs(i + 1) 13 | path = path[:len(path)-1] 14 | } 15 | } 16 | dfs(1) 17 | return 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/80.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func removeDuplicate2(nums []int) int { 4 | n := len(nums) 5 | if n <= 2 { 6 | return n 7 | } 8 | slow, fast := 2, 2 9 | for fast < n { 10 | if nums[slow-2] != nums[fast] { 11 | nums[slow] = nums[fast] 12 | slow++ 13 | } 14 | fast++ 15 | } 16 | return slow 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/89.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func grayCode(n int) []int { 4 | ans := make([]int, 1< 0 && s[i-1] != '0' && int(s[i-1]-'0')*10+int(c-'0') <= 26 { 16 | f[i+1] += f[i-1] 17 | } 18 | } 19 | return f[n] 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/94.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | // l m r 10 | func inorderTraversal(root *TreeNode) (ans []int) { 11 | if root == nil { 12 | return []int{} 13 | } 14 | st := []*TreeNode{} 15 | for len(st) != 0 || root != nil { 16 | for root != nil { 17 | st = append(st, root) 18 | root = root.Left 19 | } 20 | node := st[len(st)-1] 21 | st = st[:len(st)-1] 22 | ans = append(ans, node.Val) 23 | root = node.Right 24 | } 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/95.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func generateTrees(n int) []*TreeNode { 4 | if n == 0 { 5 | return nil 6 | } 7 | return helper(1, n) 8 | } 9 | 10 | func helper(start int, end int) (ans []*TreeNode) { 11 | if start > end { 12 | return []*TreeNode{nil} 13 | } 14 | for i := start; i <= end; i++ { 15 | left := helper(start, i-1) 16 | right := helper(i+1, end) 17 | for _, l := range left { 18 | for _, r := range right { 19 | n := &TreeNode{i, nil, nil} 20 | n.Left = l 21 | n.Right = r 22 | ans = append(ans, n) 23 | } 24 | } 25 | } 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/96.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // G和F进行归纳求解 4 | // https://leetcode.cn/problems/unique-binary-search-trees/solution/bu-tong-de-er-cha-sou-suo-shu-by-leetcode-solution/ 5 | func numTrees(n int) int { 6 | g := make([]int, n+1) 7 | g[0], g[1] = 1, 1 8 | for i := 2; i <= n; i++ { 9 | for j := 0; j <= i; j++ { 10 | g[i] = g[j-1] * g[i-j] 11 | } 12 | } 13 | return g[n] 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/questionbank/1-100/97.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/interleaving-string/ 4 | // s3是否由s1和s2交错组成的 5 | func isInterleave(s1 string, s2 string, s3 string) bool { 6 | m, n, f := len(s1), len(s2), len(s3) 7 | if m+n != f { 8 | return false 9 | } 10 | dp := make([][]bool, m+1) 11 | for i := range dp { 12 | dp[i] = make([]bool, n+1) 13 | } 14 | dp[0][0] = true 15 | for i := 0; i <= m; i++ { 16 | for j := 0; j <= n; j++ { 17 | p := i + j - 1 18 | if i > 0 { 19 | dp[i][j] = dp[i][j] || ((s3[p] == s1[i-1]) && dp[i-1][j]) 20 | } 21 | if j > 0 { 22 | dp[i][j] = dp[i][j] || ((s3[p] == s2[j-1]) && dp[i][j-1]) 23 | } 24 | } 25 | } 26 | return dp[m][n] 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/questionbank/101-200/144.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | // m l r 10 | func preorderTraversal(root *TreeNode) (ans []int) { 11 | if root == nil { 12 | return []int{} 13 | } 14 | st := []*TreeNode{} 15 | for len(st) != 0 || root != nil { 16 | for root != nil { 17 | st = append(st, root) 18 | ans = append(ans, root.Val) 19 | root = root.Left 20 | } 21 | node := st[len(st)-1] 22 | st = st[:len(st)-1] 23 | root = node.Right 24 | } 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/questionbank/101-200/145.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // l r m 4 | func postorderTraversal(root *TreeNode) (ans []int) { 5 | if root == nil { 6 | return []int{} 7 | } 8 | st := []*TreeNode{} 9 | for len(st) != 0 || root != nil { 10 | for root != nil { 11 | st = append(st, root) 12 | root = root.Left 13 | } 14 | var last *TreeNode 15 | node := st[len(st)-1] 16 | if node.Right == nil || last == node.Right { 17 | ans = append(ans, node.Val) 18 | st = st[:len(st)-1] 19 | last = node 20 | } else { 21 | root = node.Right 22 | } 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/questionbank/101-200/181.sql: -------------------------------------------------------------------------------- 1 | 2 | # Write your MySQL query statement below 3 | 4 | select a.name as Employee from Employee a, Employee b 5 | where a.managerId = b.id 6 | and a.salary > b.salary -------------------------------------------------------------------------------- /leetcode/questionbank/101-200/190.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func reverseBits(num uint32) uint32 { 4 | var res uint32 5 | for i := 0; i < 32 && num > 0; i++ { 6 | res |= num & 1 << (31 - i) 7 | num >>= 1 8 | } 9 | return res 10 | } 11 | -------------------------------------------------------------------------------- /leetcode/questionbank/101-200/191.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math/bits" 4 | 5 | func hammingWeight(num uint32) int { 6 | return bits.OnesCount(uint(num)) 7 | } 8 | -------------------------------------------------------------------------------- /leetcode/questionbank/1600-1700/1675.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | # https://leetcode.cn/problems/minimize-deviation-in-array/ 4 | class Solution: 5 | def minimumDeviation(self, nums: List[int]) -> int: 6 | -------------------------------------------------------------------------------- /leetcode/questionbank/201-300/202.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isHappy(n int) bool { 4 | m := map[int]bool{} 5 | for ; n != 1 && !m[n]; n, m[n] = step(n), true { 6 | } 7 | return n == 1 8 | } 9 | 10 | func step(n int) int { 11 | sum := 0 12 | for n > 0 { 13 | sum += (n % 10) * (n % 10) 14 | n = n / 10 15 | } 16 | return sum 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/questionbank/201-300/290.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func wordPattern(pattern string, s string) bool { 6 | b := strings.Split(s, " ") 7 | if len(b) != len(pattern) { 8 | return false 9 | } 10 | m1, m2 := map[string]string{}, map[string]string{} 11 | for i, s1 := range b { 12 | s2 := string(pattern[i]) 13 | if v1, ok1 := m1[s1]; ok1 && v1 != s2 { 14 | return false 15 | } 16 | if v2, ok2 := m2[s2]; ok2 && v2 != s1 { 17 | return false 18 | } 19 | m1[s1] = s2 20 | m2[s2] = s1 21 | } 22 | return true 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/questionbank/300-400/338.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math/bits" 4 | 5 | func countBits(n int) []int { 6 | ans := []int{} 7 | for i := 0; i <= n; i++ { 8 | ans = append(ans, bits.OnesCount(uint(i))) 9 | } 10 | return ans 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/questionbank/300-400/387.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func firstUniqChar(s string) int { 4 | cti := map[int]int{} 5 | for _, c := range s { 6 | cti[int(c-'a')]++ 7 | } 8 | for i, c := range s { 9 | if cti[int(c-'a')] == 1 { 10 | return i 11 | } 12 | } 13 | return -1 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/questionbank/300-400/389.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findTheDifference(s string, t string) byte { 4 | num := 0 5 | for i, c := range s { 6 | num = num ^ int(c-'a') ^ int(t[i]-'a') 7 | } 8 | num ^= int(t[len(t)-1] - 'a') 9 | return byte(num + 'a') 10 | } 11 | -------------------------------------------------------------------------------- /leetcode/questionbank/401-500/401.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math/bits" 6 | ) 7 | 8 | func readBinaryWatch(turnedOn int) (ans []string) { 9 | for i := 0; i < 12; i++ { 10 | for j := 0; j < 60; j++ { 11 | if bits.OnesCount(uint(i))+bits.OnesCount8(uint8(j)) == turnedOn { 12 | ans = append(ans, fmt.Sprintf("%d:%02d", i, j)) 13 | } 14 | } 15 | } 16 | return 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/questionbank/401-500/404.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func sumOfLeftLeaves(root *TreeNode) int { 10 | if root == nil { 11 | return 0 12 | } 13 | var dfs func(node *TreeNode) int 14 | dfs = func(node *TreeNode) (ans int) { 15 | if node.Left != nil { 16 | if node.Left.Left == nil && node.Left.Right == nil { 17 | ans += node.Left.Val 18 | } else { 19 | ans += dfs(node.Left) 20 | } 21 | } 22 | if node.Right != nil && !(node.Right.Left == nil && node.Right.Right == nil) { 23 | ans += dfs(node.Right) 24 | } 25 | return 26 | } 27 | return dfs(root) 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/questionbank/401-500/405.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func toHex(num int) (ans string) { 4 | if num == 0 { 5 | return "0" 6 | } 7 | if num < 0 { 8 | num += 1 << 32 9 | } 10 | hex := "0123456789abcdef" 11 | for num != 0 { 12 | ans += string(hex[num%16]) 13 | num /= 16 14 | } 15 | b := []byte(ans) 16 | for l, r := 0, len(b); l < r; l++ { 17 | b[l], b[r] = b[r], b[l] 18 | r-- 19 | } 20 | return string(b) 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/questionbank/main.go: -------------------------------------------------------------------------------- 1 | package questionbank 2 | 3 | func main() { 4 | s := "22" 5 | println(s[1:1]) 6 | } 7 | -------------------------------------------------------------------------------- /leetcode/questionbank/面试题/17.14.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func missingNumber(nums []int) int { 4 | ans := 0 5 | for i := 0; i <= len(nums); i++ { 6 | ans ^= i 7 | } 8 | for _, num := range nums { 9 | ans ^= num 10 | } 11 | return ans 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1011.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // 1011 在 D 天内送达包裹的能力 6 | func shipWithinDays(weights []int, days int) int { 7 | // 确定二分查找左右边界 8 | left, right := 0, 0 9 | for _, w := range weights { 10 | if w > left { 11 | left = w 12 | } 13 | right += w 14 | } 15 | // 如果满足条件就right=mid，左边界 16 | return left + sort.Search(right-left, func(x int) bool { 17 | x += left 18 | day := 1 // 需要运送的天数 19 | sum := 0 // 当前这一天已经运送的包裹重量之和 20 | for _, w := range weights { 21 | if sum+w > x { 22 | day++ 23 | sum = 0 24 | } 25 | sum += w 26 | } 27 | return day <= days 28 | }) 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1014.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1014 最佳观光组合 4 | func maxScoreSightseeingPair(values []int) (ans int) { 5 | mx := values[0] + 0 6 | for i := 1; i < len(values); i++ { 7 | if mx+values[i]-i > ans { 8 | ans = mx + values[i] - i 9 | } 10 | // 维护当前mx 11 | mx = max(mx, values[i]+i) 12 | } 13 | return 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1016.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strconv" 5 | "strings" 6 | ) 7 | 8 | // dfs每个子串表示的数，用一个mask（1000位超过int范围了 ）记录，如果mask等于2^n-1则true 9 | func queryString2(s string, n int) bool { 10 | for i := 1; i <= n; i++ { 11 | a := strconv.FormatInt(int64(i), 2) 12 | if !strings.Contains(s, a) { 13 | return false 14 | } 15 | } 16 | return true 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1024.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1024 4 | func videoStitching(clips [][]int, time int) int { 5 | const inf = 0x3f3f3f3f 6 | dp := make([]int, time+1) 7 | for i := range dp { 8 | dp[i] = inf 9 | } 10 | // [0,i）的dp所需要的最小合并次数 11 | dp[0] = 0 12 | for i := 1; i <= time; i++ { 13 | for _, c := range clips { 14 | l, r := c[0], c[1] 15 | if l < i && i <= r && dp[l]+1 < dp[i] { 16 | dp[i] = dp[l] + 1 17 | } 18 | } 19 | } 20 | if dp[time] == inf { 21 | return -1 22 | } 23 | return dp[time] 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1027.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1027 最长等差数列 4 | // hash存储每个key 5 | func longestArithSeqLength(nums []int) (ans int) { 6 | m := map[int]map[int]int{} 7 | for i := range nums { 8 | for j := 0; j < i; j++ { 9 | d := nums[i] - nums[j] 10 | if m[d] == nil { 11 | m[d] = map[int]int{} 12 | } 13 | if m[d][j] == 0 { 14 | m[d][i] = 2 15 | if ans < 2 { 16 | ans = 2 17 | } 18 | } else { 19 | m[d][i] = m[d][j] + 1 20 | if ans < m[d][i] { 21 | ans = m[d][i] 22 | } 23 | } 24 | } 25 | } 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1042.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1042 不邻接植花 4 | func gardenNoAdj(n int, paths [][]int) []int { 5 | g := make([][]int, n) 6 | for _, p := range paths { 7 | a, b := p[0]-1, p[1]-1 8 | g[a] = append(g[a], b) 9 | g[b] = append(g[b], a) 10 | } 11 | ans := make([]int, n) 12 | for i := 0; i < n; i++ { 13 | color := [5]int{0} 14 | for _, t := range g[i] { 15 | color[ans[t]] = 1 16 | } 17 | for c := 1; c <= 4; c++ { 18 | if color[c] == 0 { 19 | ans[i] = c 20 | break 21 | } 22 | } 23 | } 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1072.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxEqualRowsAfterFlips(matrix [][]int) (ans int) { 4 | // m, n := len(matrix), len(matrix[0]) 5 | cnt := map[string]int{} 6 | for i := range matrix { 7 | sb := []byte{} 8 | for j := range matrix[i] { 9 | sb = append(sb, byte(matrix[i][j]+'0')) 10 | } 11 | if sb[0] != '0' { 12 | for j := 0; j < len(sb); j++ { 13 | sb[j] = ('1' - sb[j]) + '0' 14 | } 15 | } 16 | cnt[string(sb)]++ 17 | } 18 | for _, v := range cnt { 19 | if v > ans { 20 | ans = v 21 | } 22 | } 23 | return 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1079.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1079 4 | func numTilePossibilities(tiles string) (ans int) { 5 | nums := [26]int{} 6 | // 统计字母出现的次数 7 | for _, c := range tiles { 8 | nums[c-'A']++ 9 | } 10 | var dfs func() 11 | dfs = func() { 12 | for i, v := range nums { 13 | if v > 0 { 14 | ans++ 15 | nums[i]-- 16 | dfs() 17 | nums[i]++ 18 | } 19 | } 20 | } 21 | dfs() 22 | return 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1111.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 分成两半，简单来说就是奇偶分 4 | func maxDepthAfterSplit(seq string) (ans []int) { 5 | d := 0 6 | for _, c := range seq { 7 | if c == '(' { 8 | ans = append(ans, d%2) 9 | d++ 10 | } else { 11 | d-- 12 | ans = append(ans, d%2) 13 | } 14 | } 15 | return ans 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1145.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1145 4 | func btreeGameWinningMove(root *TreeNode, n int, x int) bool { 5 | l, r := 0, 0 6 | var dfs func(node *TreeNode) int 7 | dfs = func(node *TreeNode) int { 8 | if node == nil { 9 | return 0 10 | } 11 | lv := dfs(node.Left) 12 | rv := dfs(node.Right) 13 | if node.Val == x { 14 | l, r = lv, rv 15 | } 16 | return lv + rv + 1 17 | } 18 | tot := dfs(root) 19 | p := tot - l - r - 1 20 | if l > tot-l { 21 | return true 22 | } 23 | if r > tot-r { 24 | return true 25 | } 26 | if p > tot-p { 27 | return true 28 | } 29 | return false 30 | } 31 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1156.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 贪心 4 | func maxRepOpt1(text string) (ans int) { 5 | n := len(text) 6 | cnt := [26]int{} 7 | for _, c := range text { 8 | cnt[c-'a']++ 9 | } 10 | for i := 0; i < n; { 11 | le := 0 12 | for i+le < n && text[i+le] == text[i] { 13 | le++ 14 | } 15 | j := i + le + 1 16 | w := 0 17 | for j+w < n && text[j+w] == text[i] { 18 | w++ 19 | } 20 | ans = max(ans, min(le+w+1, cnt[text[i]-'a'])) 21 | } 22 | return 23 | } 24 | 25 | //func max(a, b int) int { 26 | // if a > b { 27 | // return a 28 | // } else { 29 | // return b 30 | // } 31 | //} 32 | //func min(a, b int)int { if a < b{return a}else {return b}} 33 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1171.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // 前缀和求法，当出现两次相同的sum时候，说明这中间的值为0，直接连接即可 9 | func removeZeroSumSublists(head *ListNode) *ListNode { 10 | dummy := &ListNode{} 11 | dummy.Next = head 12 | m := map[int]*ListNode{} 13 | sum := 0 14 | for d := dummy; d != nil; d = d.Next { 15 | sum += d.Val 16 | m[sum] = d 17 | } 18 | sum = 0 19 | for d := dummy; d != nil; d = d.Next { 20 | sum += d.Val 21 | d.Next = m[sum].Next 22 | } 23 | return dummy.Next 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1186.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 由求最大子数组和转化而来，多了一个删除的状态 4 | func maximumSum(arr []int) (ans int) { 5 | dp := make([][2]int, len(arr)) 6 | dp[0][0] = arr[0] 7 | dp[0][1] = 0 8 | for i := 1; i < len(arr); i++ { 9 | dp[i][0] = max(0, dp[i-1][0]) + arr[i] 10 | dp[i][1] = max(dp[i-1][0], dp[i-1][1]+arr[i]) 11 | ans = max(ans, max(dp[i][0], dp[i][1])) 12 | } 13 | return 14 | } 15 | func max(a, b int) int { 16 | if a > b { 17 | return a 18 | } else { 19 | return b 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1220.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1220 统计元音字母序列的数目 4 | func countVowelPermutation(n int) (ans int) { 5 | const mod = 1e9 + 7 6 | f := make([][]int, n) 7 | f[0] = []int{1, 1, 1, 1, 1} 8 | for i := 1; i < n; i++ { 9 | f[i] = make([]int, 5) 10 | f[i][0] = f[i-1][1] 11 | f[i][1] = f[i-1][0] + f[i-1][2] 12 | f[i][2] = (f[i-1][0] + f[i-1][1]) + f[i-1][3] + f[i-1][4] 13 | f[i][3] = f[i-1][2] + f[i-1][4] 14 | f[i][4] = f[i-1][0] 15 | for j := range f[i] { 16 | f[i][j] %= mod 17 | } 18 | } 19 | for i := 0; i < 5; i++ { 20 | ans += f[n-1][i] % mod 21 | } 22 | return ans % mod 23 | 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1239.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math/bits" 4 | 5 | // 1239 串联字符串的最大长度 6 | func maxLength(arr []string) (ans int) { 7 | masks := []int{0} 8 | out: 9 | for _, s := range arr { 10 | mask := 0 11 | for _, c := range s { 12 | ch := int(c - 'a') 13 | if mask>>ch&1 == 1 { 14 | continue out 15 | } 16 | mask |= 1 << ch 17 | } 18 | for _, m := range masks { 19 | if m&mask == 0 { 20 | masks = append(masks, m|mask) 21 | ans = max(ans, bits.OnesCount(uint(m|mask))) 22 | } 23 | } 24 | } 25 | return 26 | } 27 | 28 | //func max(a, b int) int { 29 | // if a > b { 30 | // return a 31 | // } 32 | // return b 33 | //} 34 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1312.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。 4 | // 请你返回让 s 成为回文串的 最少操作次数 。 5 | // 1312 其实就是求最长回文子序列，把其中不包含的各自添加一遍就行 6 | func minInsertions1(s string) int { 7 | dp := make([][]int, len(s)) 8 | for i := range dp { 9 | dp[i] = make([]int, len(s)) 10 | } 11 | for i := len(s) - 1; i >= 0; i-- { 12 | dp[i][i] = 1 13 | for j := i + 1; j < len(s); j++ { 14 | if s[i] == s[j] { 15 | dp[i][j] = dp[i+1][j-1] + 2 16 | } else { 17 | dp[i][j] = max(dp[i+1][j], dp[i][j-1]) 18 | } 19 | } 20 | } 21 | return len(s) - dp[0][len(s)-1] 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1359.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1359 有效的快递序列数目 4 | func countOrders(n int) int { 5 | const mod int = 1e9 + 7 6 | if n == 1 { 7 | return 1 8 | } 9 | ans := 1 10 | // 对i-1里面插入第i个p和d 11 | // P的位置有2i-1个，对应0，1，2，3，4...2n-2 12 | // 分别d有2n-1，2n-2，2n-3...1 13 | // 求和 (2n-1) * n 14 | for i := 2; i <= n; i++ { 15 | ans = ans * (i*2 - 1) % mod * i % mod 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1372.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /** 4 | * Definition for a binary tree node. 5 | * type TreeNode struct { 6 | * Val int 7 | * Left *TreeNode 8 | * Right *TreeNode 9 | * } 10 | */ 11 | // 树形dp 学习一下 12 | func longestZigZag(root *TreeNode) (ans int) { 13 | var dfs func(node *TreeNode) (int, int) 14 | dfs = func(node *TreeNode) (int, int) { 15 | if node == nil { 16 | return 0, 0 17 | } 18 | _, r1 := dfs(node.Left) 19 | l2, _ := dfs(node.Right) 20 | L, R := 0, 0 21 | if node.Left != nil { 22 | L = r1 + 1 23 | } 24 | if node.Right != nil { 25 | R = l2 + 1 26 | } 27 | ans = max(ans, max(L, R)) 28 | return L, R 29 | } 30 | dfs(root) 31 | return 32 | } 33 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1401.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1401 4 | func checkOverlap(radius int, xCenter int, yCenter int, x1 int, y1 int, x2 int, y2 int) bool { 5 | // 求最近的一个点有没有被包含 6 | x, y := -1, -1 7 | if x1 > xCenter { 8 | x = x1 - xCenter 9 | } else { 10 | if x2 < xCenter { 11 | x = xCenter - x2 12 | } else { 13 | x = 0 14 | } 15 | } 16 | if y1 > yCenter { 17 | y = y1 - yCenter 18 | } else { 19 | if y2 < yCenter { 20 | y = yCenter - y2 21 | } else { 22 | y = 0 23 | } 24 | } 25 | return x*x+y*y <= radius*radius 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1510.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func winnerSquareGame(n int) bool { 4 | f := make([]bool, n+1) 5 | for i := 1; i <= n; i++ { 6 | for k := 1; k*k <= i; k++ { 7 | if !f[i-k*k] { 8 | f[i] = true 9 | break 10 | } 11 | } 12 | } 13 | return f[n] 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1541.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 模拟题 4 | // 给你一个括号字符串s，它只包含字符'(' 和')'。一个括号字符串被称为平衡的当它满足： 5 | // 任何左括号'('必须对应两个连续的右括号'))'。 6 | // 左括号'('必须在对应的连续两个右括号'))'之前。 7 | // 你可以在任意位置插入字符 '(' 和 ')' 使字符串平衡。 8 | // 求最少的插入次数 9 | func minInsertions(s string) (ans int) { 10 | l := 0 11 | idx := 0 12 | n := len(s) 13 | for idx < n { 14 | c := s[idx] 15 | if c == '(' { 16 | l++ 17 | idx++ 18 | } else { 19 | if l > 0 { 20 | l-- 21 | } else { 22 | ans++ 23 | } 24 | if idx < n-1 && s[idx+1] == ')' { 25 | idx += 2 26 | } else { 27 | ans++ 28 | idx++ 29 | } 30 | } 31 | } 32 | ans += l * 2 33 | return 34 | } 35 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1567.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1567 乘积为正数的最长子数组长度 4 | func getMaxLen(nums []int) (ans int) { 5 | n := len(nums) 6 | pos, neg := make([]int, n), make([]int, n) 7 | if nums[0] < 0 { 8 | neg[0] = 1 9 | } else if nums[0] > 0 { 10 | pos[0] = 1 11 | } 12 | for i := 1; i < n; i++ { 13 | if nums[i] > 0 { 14 | pos[i] = pos[i-1] + 1 15 | if neg[i-1] > 0 { 16 | neg[i] = neg[i-1] + 1 17 | } 18 | } else if nums[i] < 0 { 19 | if neg[i-1] > 0 { 20 | pos[i] = neg[i-1] + 1 21 | } 22 | neg[i] = pos[i-1] + 1 23 | } 24 | ans = max(ans, pos[i]) 25 | } 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1593.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1593 4 | // 给你一个字符串 s ，请你拆分该字符串，并返回拆分后唯一子字符串的最大数目。 5 | // 字符串 s 拆分后可以得到若干非空子字符串，这些子字符串连接后应当能够还原为原字符串。 6 | // 但是拆分出来的每个子字符串都必须是唯一的 。 7 | func maxUniqueSplit(s string) (ans int) { 8 | n := len(s) 9 | s2b := map[string]struct{}{} 10 | var dfs func(i int) 11 | dfs = func(i int) { 12 | if i == n { 13 | if len(s2b) > ans { 14 | ans = len(s2b) 15 | } 16 | } 17 | if len(s2b)+n-i < ans { 18 | return 19 | } 20 | for k := i; k < n; k++ { 21 | sub := s[i : k+1] 22 | if _, ok := s2b[sub]; !ok { 23 | s2b[sub] = struct{}{} 24 | dfs(i + 1) 25 | delete(s2b, sub) 26 | } 27 | } 28 | } 29 | dfs(0) 30 | return 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1638.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1638 统计只差一个字符的子串数目 4 | // 从s遍历到t，分别遍历每次找到的数目 5 | func countSubstrings(s string, t string) (ans int) { 6 | m, n := len(s), len(t) 7 | for del := -(m - 1); del < n; del++ { 8 | i, j := 0, 0 9 | if del > 0 { 10 | j = del 11 | } else { 12 | i = -del 13 | } 14 | // f统计数目，g统计后缀长度 15 | f, g := 0, 0 16 | for ; i < m && j < n; i, j = i+1, j+1 { 17 | if s[i] == t[j] { 18 | // f 不变 19 | g++ 20 | } else { 21 | f = g + 1 22 | g = 0 23 | } 24 | ans += f 25 | } 26 | } 27 | return 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1653.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1653 4 | // 使得编程aaaabbb形式 5 | func minimumDeletions(s string) int { 6 | // 就是使得编程01形式的最少步骤 7 | n := len(s) 8 | dp0 := int(s[0] - 'a') 9 | dp1 := 0 10 | if s[0] == 'a' { 11 | dp1 = 1 12 | } 13 | for i := 1; i < n; i++ { 14 | t := dp0 15 | if s[i] == 'a' { 16 | dp0 = dp0 17 | dp1 = min(t, dp1) + 1 18 | } else { 19 | dp0 = dp0 + 1 20 | dp1 = min(t, dp1) 21 | } 22 | } 23 | return min(dp0, dp1) 24 | } 25 | func min(a, b int) int { 26 | if a < b { 27 | return a 28 | } else { 29 | return b 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1706.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findBall(grid [][]int) (ans []int) { 4 | m, n := len(grid), len(grid[0]) 5 | for i := 0; i < n; i++ { 6 | x, y := 0, i 7 | for y >= 0 && y < n && x >= 0 && x < m { 8 | if y < n-1 && grid[x][y] == 1 && 1 == grid[x][y+1] { 9 | x += 1 10 | y += 1 11 | } else if y > 0 && grid[x][y] == -1 && -1 == grid[x][y-1] { 12 | x += 1 13 | y -= 1 14 | } else { 15 | break 16 | } 17 | } 18 | if x == m { 19 | ans = append(ans, y) 20 | } else { 21 | ans = append(ans, -1) 22 | } 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1711.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func countPairs2(deliciousness []int) (ans int) { 4 | cnt := map[int]int{} 5 | ms := deliciousness[0] 6 | for _, v := range deliciousness { 7 | if v > ms { 8 | ms = v 9 | } 10 | } 11 | ts := ms * 2 12 | for _, v := range deliciousness { 13 | for sum := 1; sum <= ts; sum <<= 1 { 14 | ans += cnt[sum-v] 15 | } 16 | cnt[v]++ 17 | } 18 | return ans 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1781.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | // 1781 所有子字符串美丽值之和 6 | func beautySum(s string) (ans int) { 7 | // 暴力每一个子串 8 | n := len(s) 9 | for le := 3; le <= n; le++ { 10 | l, mi, ma := 0, math.MaxInt, math.MinInt 11 | cnt := [26]int{} 12 | for r := range s { 13 | cnt[s[r]-'a']++ 14 | if r-l+1 == le { 15 | mi, ma = math.MaxInt, math.MaxInt 16 | for i := 0; i < 26; i++ { 17 | if cnt[i] > 0 { 18 | mi = min(mi, cnt[i]) 19 | ma = max(ma, cnt[i]) 20 | } 21 | } 22 | ans += ma - mi 23 | cnt[s[l]-'a']-- 24 | l++ 25 | } 26 | } 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1814.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 统计数组中好数对的个数 4 | // nums[i] + rev[j] = nums[j] + rev[i] 5 | // nums[i] - rev[i] = nums[j] - rev[j] 6 | func countNicePairs(nums []int) (ans int) { 7 | const mod = 1e9 + 7 8 | m := map[int]int{} 9 | for _, num := range nums { 10 | cnt := num - rev(num) 11 | ans += m[cnt] 12 | m[cnt]++ 13 | ans %= mod 14 | m[cnt] %= mod 15 | } 16 | return 17 | } 18 | func rev(n int) (ans int) { 19 | for n != 0 { 20 | ans = ans*10 + n%10 21 | n /= 10 22 | } 23 | return 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1849.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strconv" 5 | "strings" 6 | ) 7 | 8 | // 1849 9 | // 枚举第一个值 10 | func splitString(s string) bool { 11 | next: 12 | for i := range s { 13 | v, _ := strconv.Atoi(s[:i]) 14 | v-- 15 | for t := s[i:]; t != ""; v-- { 16 | for len(t) > 1 && t[0] == '0' { 17 | t = t[1:] 18 | } 19 | tmp := strconv.Itoa(v) 20 | if !strings.HasPrefix(t, tmp) { 21 | continue next 22 | } 23 | t = t[len(tmp):] 24 | } 25 | return true 26 | } 27 | return false 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1911.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1911 4 | func maxAlternatingSum(nums []int) int64 { 5 | n := len(nums) 6 | dp := make([][2]int, n+1) 7 | dp[0][0] = 0 8 | dp[0][1] = -1 9 | for i := 1; i <= len(nums); i++ { 10 | dp[i][0] = max(dp[i-1][0], dp[i-1][1]-nums[i-1]) 11 | dp[i][1] = max(dp[i-1][1], dp[i-1][0]+nums[i-1]) 12 | } 13 | return int64(max(dp[n][0], dp[n][1])) 14 | } 15 | 16 | //func max(a, b int) int { 17 | // if a > b { 18 | // return a 19 | // } else { 20 | // return b 21 | // } 22 | //} 23 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/1954.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 1954 4 | // 求和计算公式 apple = n*(n+1)*2*(2n+1) 5 | func minimumPerimeter(neededApples int64) int64 { 6 | d := 1 7 | var sum int64 = 12 8 | var cnt0 int64 = 12 9 | for sum < neededApples { 10 | // 当前层等于上一层+这一层附加的值 11 | cnt1 := cnt0 + int64(d*2+1)*4 + 4*(int64(d)*2) + int64(d+1)*2*4 12 | sum += cnt1 13 | cnt0 = cnt1 14 | d++ 15 | } 16 | return int64(d) * 2 * 4 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2017.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | // 2017 网格游戏 6 | // 枚举拐弯的位置 7 | func gridGame(grid [][]int) int64 { 8 | ans := math.MaxInt64 9 | l0 := 0 10 | for _, v := range grid[0] { 11 | l0 += v 12 | } 13 | l1 := 0 14 | for i, v := range grid[0] { 15 | l0 -= v 16 | ans = min(ans, max(l0, l1)) 17 | l1 += grid[1][i] 18 | } 19 | return int64(ans) 20 | } 21 | 22 | //func min(a, b int) int { 23 | // if a < b { 24 | // return a 25 | // } else { 26 | // return b 27 | // } 28 | //} 29 | //func max(a, b int) int { 30 | // if a > b { 31 | // return a 32 | // } else { 33 | // return b 34 | // } 35 | //} 36 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2048.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2048 4 | // 枚举 5 | func nextBeautifulNumber(n int) int { 6 | next: 7 | for n++; ; n++ { 8 | cnt := [10]int{} 9 | for x := n; x > 0; x /= 10 { 10 | cnt[x%10]++ 11 | } 12 | for x := n; x > 0; x /= 10 { 13 | if cnt[x%10] != x%10 { 14 | continue next 15 | } 16 | } 17 | return n 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2070.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // 2070 每一个查询的最大美丽值 6 | func maximumBeauty(items [][]int, queries []int) []int { 7 | sort.Slice(items, func(i, j int) bool { 8 | return items[i][0] < items[j][0] 9 | }) 10 | for i, q := range queries { 11 | queries[i] = q<<32 | i 12 | } 13 | sort.Ints(queries) 14 | mx, i := 0, 0 15 | ans := make([]int, len(queries)) 16 | for _, q := range queries { 17 | for ; i < len(items) && items[i][0] <= q>>32; i++ { 18 | if items[i][1] > mx { 19 | mx = items[i][1] 20 | } 21 | } 22 | ans[q&(1<<32-1)] = mx 23 | } 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2075.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | // 2075 tle 8 | func decodeCiphertext(encodedText string, rows int) string { 9 | m := rows 10 | n := len(encodedText) / m 11 | ans := []byte{} 12 | for i, j, k := 0, 0, 0; k < n; { 13 | ans = append(ans, encodedText[i*n+j]) 14 | i++ 15 | j++ 16 | if i == m || j == n { 17 | k++ 18 | i, j = 0, k 19 | } 20 | } 21 | return string(bytes.TrimRight(ans, " ")) 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2080.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | type RangeFreqQuery struct{ pos [1e4 + 1]sort.IntSlice } 6 | 7 | func Constructor(arr []int) (q RangeFreqQuery) { 8 | for i, value := range arr { 9 | q.pos[value] = append(q.pos[value], i) // 统计 value 在 arr 中的所有下标位置 10 | } 11 | return 12 | } 13 | 14 | func (q *RangeFreqQuery) Query(left, right, value int) int { 15 | p := q.pos[value] // value 在 arr 中的所有下标位置 16 | return p[p.Search(left):].Search(right + 1) // 在下标位置上二分，求 [left,right] 之间的下标个数，即为 value 的频率 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2087.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minCost(startPos, homePos, rowCosts, colCosts []int) int { 4 | x0, y0, x1, y1 := startPos[0], startPos[1], homePos[0], homePos[1] 5 | ans := -rowCosts[x0] - colCosts[y0] // 初始的行列无需计算 6 | if x0 > x1 { 7 | x0, x1 = x1, x0 8 | } // 交换位置，保证 x0 <= x1 9 | if y0 > y1 { 10 | y0, y1 = y1, y0 11 | } // 交换位置，保证 y0 <= y1 12 | for _, cost := range rowCosts[x0 : x1+1] { 13 | ans += cost 14 | } // 统计答案 15 | for _, cost := range colCosts[y0 : y1+1] { 16 | ans += cost 17 | } // 统计答案 18 | return ans 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2121.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2121 4 | func getDistances(arr []int) (ans []int64) { 5 | pos := map[int][]int{} 6 | for i, v := range arr { 7 | pos[v] = append(pos[v], i) 8 | } 9 | ans = make([]int64, len(arr)) 10 | for _, p := range pos { 11 | sum := int64(0) 12 | for i := range p { 13 | sum += int64(p[i] - p[0]) 14 | } 15 | ans[p[0]] = sum 16 | for i := 1; i < len(p); i++ { 17 | sum += int64(2*i-len(p)) * int64(p[i]-p[i-1]) 18 | ans[p[i]] = sum 19 | } 20 | } 21 | return 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2134.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 转化为统计0的个数，因为区间内为1，即区间内的0需要和外部进行交换，所以内部的0就是需要进行交换的次数 4 | // 不断的进行滑动，最后所求的值就是我们所需要的 5 | func minSwaps(nums []int) int { 6 | tot1 := 0 7 | for i := range nums { 8 | tot1 += nums[i] 9 | } 10 | cur1, max1 := 0, 0 11 | nums = append(nums, nums...) 12 | for i, num := range nums { 13 | cur1 += num 14 | if i >= tot1 { 15 | cur1 -= nums[i-tot1] 16 | if cur1 > max1 { 17 | max1 = cur1 18 | } 19 | } 20 | } 21 | return tot1 - max1 22 | } 23 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2140.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2140 解决智力问题 4 | // 刷表法 5 | func mostPoints(questions [][]int) int64 { 6 | n := len(questions) 7 | f := make([]int, n+1) 8 | for i, q := range questions { 9 | f[i+1] = max(f[i+1], f[i]) 10 | j := i + q[1] + 1 11 | if j > n { 12 | j = n 13 | } 14 | f[j] = max(f[j], f[i]+q[0]) 15 | } 16 | return int64(f[n]) 17 | } 18 | 19 | //func max(a, b int) int { if b > a { return b }; return a } 20 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2171.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // 2171 6 | // 获取能保留的最多的豆，减一下就是取最少的豆 7 | func minimumRemoval(beans []int) int64 { 8 | sum := 0 9 | mi := 0 10 | sort.Ints(beans) 11 | for i, v := range beans { 12 | sum += v 13 | bean := (len(beans) - i) * v 14 | if bean > mi { 15 | mi = bean 16 | } 17 | } 18 | return int64(sum - mi) 19 | } 20 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2202.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2202 K 次操作后最大化顶端元素 4 | func maximumTop(nums []int, k int) (ans int) { 5 | n := len(nums) 6 | if n == 1 || k == 0 { 7 | if k%2 == 1 { 8 | return -1 9 | } 10 | return nums[0] 11 | } 12 | if k < n { 13 | nums = append(nums[:k-1], nums[k]) 14 | } else if k == n { 15 | nums = nums[:n-1] 16 | } 17 | for _, v := range nums { 18 | if v > ans { 19 | ans = v 20 | } 21 | } 22 | return 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2261.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2261 含最多 K 个可整除元素的子数组 4 | func countDistinct(nums []int, k int, p int) (ans int) { 5 | set := map[[200]int]struct{}{} 6 | for i := range nums { 7 | arr, cnt, idx := [200]int{}, 0, 0 8 | for _, v := range nums[i:] { 9 | if v%p == 0 { 10 | if cnt++; cnt > k { 11 | break 12 | } 13 | } 14 | arr[idx] = v 15 | idx++ 16 | set[arr] = struct{}{} 17 | } 18 | } 19 | return len(set) 20 | } 21 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2321.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func solve(nums1, nums2 []int) int { 4 | s1, maxSum, s := 0, 0, 0 5 | for i, x := range nums1 { 6 | s1 += x 7 | s = max(s+nums2[i]-x, 0) 8 | maxSum = max(maxSum, s) 9 | } 10 | return s1 + maxSum 11 | } 12 | 13 | func maximumsSplicedArray(nums1, nums2 []int) int { 14 | return max(solve(nums1, nums2), solve(nums2, nums1)) 15 | } 16 | 17 | //func max(a, b int) int { if b > a { return b }; return a } 18 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2359.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 2359 找到离给定两个节点最近的节点 4 | func closestMeetingNode(edges []int, node1 int, node2 int) (ans int) { 5 | const inf = 0x3f3f3f3f 6 | bfs := func(node int) []int { 7 | dis := make([]int, len(edges)) 8 | for i := range dis { 9 | dis[i] = inf 10 | } 11 | d := 0 12 | for node != -1 && dis[node] == inf { 13 | dis[node] = d 14 | d += 1 15 | node = edges[node] 16 | } 17 | return dis 18 | } 19 | ans = -1 20 | n1 := bfs(node1) 21 | n2 := bfs(node2) 22 | md := len(edges) 23 | for i := range n1 { 24 | mx := max(n1[i], n2[i]) 25 | if mx < md { 26 | md = mx 27 | ans = i 28 | } 29 | } 30 | return 31 | } 32 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/2369.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // dfs valid 4 | func validPartition(nums []int) bool { 5 | n := len(nums) 6 | // 表示nums[0]到nums[i]的数字能否有效划分 7 | dp := make([]bool, n+1) 8 | // 空的肯定可以 9 | dp[0] = true 10 | for i, v := range nums { 11 | if i > 0 && dp[i-1] && v == nums[i-1] || 12 | i > 1 && dp[i-2] && (v == nums[i-1] && v == nums[i-2]) || 13 | v == nums[i-1]+1 && v == nums[i-2]+2 { 14 | dp[i+1] = true 15 | } 16 | } 17 | return dp[n] 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/768.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 每段中的最小值和最大值，最大值要小于下个组的最小值 4 | // 求分割最多的次数 5 | // 贪心 6 | // 下一个大值 7 | // 遇到大值直接加入 8 | // 遇到小的就弹出 9 | func maxChunksToSorted(arr []int) int { 10 | st := []int{} 11 | for _, v := range arr { 12 | if len(st) == 0 || st[len(st)-1] <= v { 13 | st = append(st, v) 14 | } else if len(st) > 0 && st[len(st)-1] > v { 15 | cur := st[len(st)-1] 16 | st = st[:len(st)-1] 17 | for len(st) > 0 && st[len(st)-1] > v { 18 | st = st[:len(st)-1] 19 | } 20 | st = append(st, cur) 21 | } 22 | } 23 | return len(st) 24 | } 25 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/826.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // 826. 安排工作以达到最大收益 6 | func maxProfitAssignment(difficulty []int, profit []int, worker []int) (ans int) { 7 | type pair struct { 8 | hard, pro int 9 | } 10 | jobs := []pair{} 11 | for i := range difficulty { 12 | jobs = append(jobs, pair{difficulty[i], profit[i]}) 13 | } 14 | sort.Slice(jobs, func(i, j int) bool { 15 | return jobs[i].hard < jobs[j].hard 16 | }) 17 | sort.Ints(worker) 18 | i, best := 0, 0 19 | for _, skill := range worker { 20 | for i < len(jobs) && jobs[i].hard <= skill { 21 | if best < jobs[i].pro { 22 | best = jobs[i].pro 23 | } 24 | i++ 25 | } 26 | ans += best 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/875.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minEatingSpeed(piles []int, h int) int { 4 | m := piles[0] 5 | for _, v := range piles { 6 | if v > m { 7 | m = v 8 | } 9 | } 10 | l, r := 1, m+1 11 | for l < r { 12 | mid := l + (r-l)>>1 13 | if getH(piles, mid) <= h { 14 | r = mid 15 | } else { 16 | l = mid + 1 17 | } 18 | } 19 | return l 20 | } 21 | 22 | func getH(piles []int, k int) int { 23 | h := 0 24 | for _, v := range piles { 25 | if v%k != 0 { 26 | h += v/k + 1 27 | } else { 28 | h += v / k 29 | } 30 | } 31 | return h 32 | } 33 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/958.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /** 4 | * Definition for a binary tree node. 5 | * type TreeNode struct { 6 | * Val int 7 | * Left *TreeNode 8 | * Right *TreeNode 9 | * } 10 | */ 11 | // 958 判断是否是完全二叉树 12 | // 层次遍历，如果遇到空的就把标志位设为true，然后继续判断如果有值就设置为false 13 | func isCompleteTree(root *TreeNode) bool { 14 | q := []*TreeNode{root} 15 | f := false 16 | 17 | for len(q) != 0 { 18 | n := q[0] 19 | q = q[1:] 20 | // 如果空，则置为true 21 | if n == nil { 22 | f = true 23 | continue 24 | } else { 25 | if f { 26 | return false 27 | } 28 | } 29 | q = append(q, n.Left) 30 | q = append(q, n.Right) 31 | } 32 | return true 33 | } 34 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/971.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 971 4 | func flipMatchVoyage(root *TreeNode, voyage []int) (ans []int) { 5 | var dfs func(node *TreeNode) 6 | idx := 0 7 | dfs = func(node *TreeNode) { 8 | if node != nil { 9 | if node.Val != voyage[idx] { 10 | ans = []int{-1} 11 | return 12 | } 13 | idx++ 14 | if idx < len(voyage) && node.Left != nil && node.Left.Val != voyage[idx] { 15 | ans = append(ans, node.Val) 16 | dfs(node.Right) 17 | dfs(node.Left) 18 | } else { 19 | dfs(node.Left) 20 | dfs(node.Right) 21 | } 22 | } 23 | } 24 | dfs(root) 25 | if len(ans) == 0 || ans[0] == -1 { 26 | ans = []int{-1} 27 | } 28 | return ans 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/979.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | // 先把移动剩下的移动到根节点，然后进行转移 14 | func distributeCoins(root *TreeNode) (ans int) { 15 | var dfs func(node *TreeNode) int 16 | dfs = func(node *TreeNode) int { 17 | if node == nil { 18 | return 0 19 | } 20 | l, r := dfs(node.Left), dfs(node.Right) 21 | ans += int(math.Abs(float64(l)) + math.Abs(float64(r))) 22 | return node.Val + l + r - 1 23 | } 24 | dfs(root) 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/rank/1700-1800/983.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 983 4 | func mincostTickets(days []int, costs []int) int { 5 | n := len(days) 6 | lastday, firstday := days[n-1], days[0] 7 | dp := make([]int, lastday+32) 8 | for d, i := lastday, n-1; d >= firstday; d-- { 9 | if days[i] == d { 10 | dp[d] = min(min(dp[d+1]+costs[0], dp[d+7]+costs[1]), dp[d+30]+costs[2]) 11 | i-- 12 | } else { 13 | dp[d] = dp[d+1] 14 | } 15 | } 16 | return dp[firstday] 17 | } 18 | -------------------------------------------------------------------------------- /leetcode/rank/1800-1900/823.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numFactoredBinaryTrees(self, arr: List[int]) -> int: 3 | pass -------------------------------------------------------------------------------- /leetcode/weekcontest/2022-7-17/1.go: -------------------------------------------------------------------------------- 1 | package _022_7_17 2 | 3 | func numberOfPairs(nums []int) []int { 4 | mp := map[int]int{} 5 | for i := range nums { 6 | mp[nums[i]]++ 7 | } 8 | cnt := 0 9 | for k, _ := range mp { 10 | cnt += mp[k] / 2 11 | } 12 | return []int{cnt, len(nums) - cnt*2} 13 | } 14 | -------------------------------------------------------------------------------- /leetcode/weekcontest/2022-7-24/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func bestHand(ranks []int, suits []byte) string { 4 | mp1 := map[byte]int{} 5 | for i := range suits { 6 | mp1[suits[i]]++ 7 | } 8 | if mp1[suits[0]] == 5 { 9 | return "Flush" 10 | } 11 | mp2 := map[int]int{} 12 | for i := range ranks { 13 | mp2[ranks[i]]++ 14 | } 15 | min := 0 16 | for _, v := range mp2 { 17 | if v >= min { 18 | min = v 19 | } 20 | } 21 | if min >= 3 { 22 | return "Three of a Kind" 23 | } else if min >= 2 { 24 | return "Pair" 25 | } else { 26 | return "High Card" 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /leetcode/weekcontest/2022-7-24/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func zeroFilledSubarray(nums []int) int64 { 4 | cnt := 0 5 | cnt0 := 0 6 | for i := 0; i < len(nums); i++ { 7 | if nums[i] == 0 { 8 | cnt0++ 9 | } else { 10 | cnt += (1 + cnt0) * cnt0 / 2 11 | cnt0 = 0 12 | } 13 | } 14 | if cnt0 != 0 { 15 | cnt += (1 + cnt0) * cnt0 / 2 16 | } 17 | return int64(cnt) 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/weekcontest/2022-7-24/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https: //leetcode.cn/problems/shortest-impossible-sequence-of-rolls/ 4 | // 就是求互不交叉的完整序列出现了几次 5 | func shortestSequence(rolls []int, k int) int { 6 | set := map[int]struct{}{} 7 | ans := 0 8 | for i := 0; i < len(rolls); i++ { 9 | set[rolls[i]] = struct{}{} 10 | if len(set) == k { 11 | ans++ 12 | set = map[int]struct{}{} 13 | } 14 | } 15 | return ans + 1 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/weekcontest/2022-7-24/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | m := Constructor() 5 | m.Change(75, 40) 6 | m.Change(27, 40) 7 | m.Change(22, 40) 8 | m.Change(22, 40) 9 | m.Change(75, 40) 10 | m.Find(40) 11 | } 12 | -------------------------------------------------------------------------------- /leetcode/weekcontest/350/1.py: -------------------------------------------------------------------------------- 1 | 2 | from heapq import heappop 3 | 4 | 5 | class Solution: 6 | def findValueOfPartition(self, nums: List[int]) -> int: 7 | ans = inf 8 | for a,b in pairwise(sorted(nums, reverse=True)): 9 | ans = min(ans, a-b) 10 | return ans -------------------------------------------------------------------------------- /leetcode/weekcontest/350/2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/leetcode/weekcontest/350/2.py -------------------------------------------------------------------------------- /leetcode/weekcontest/350/4.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/leetcode/weekcontest/350/4.py -------------------------------------------------------------------------------- /leetcode/weekcontest/351/2.py: -------------------------------------------------------------------------------- 1 | from itertools import count 2 | 3 | 4 | class Solution: 5 | def makeTheIntegerZero(self, num1: int, num2: int) -> int: 6 | # 从暴力入手:枚举操作次数 k 7 | # 问题变成:设 x = num1 - num2 * k 8 | # 计算 x 能否分解成 k 个 2^i 9 | # k in [x.bit count()，x] 10 | for k in count(1): 11 | x = num1 - num2 * k 12 | if x < k: return -1 13 | if k >= x.bit_count(): return k 14 | -------------------------------------------------------------------------------- /leetcode/weekcontest/351/3.py: -------------------------------------------------------------------------------- 1 | from itertools import combinations 2 | 3 | 4 | class Solution: 5 | def numberOfGoodSubarraySplits(self, nums: List[int]) -> int: 6 | mod = 1e9 + 7 7 | ans = 1 8 | cnt = 0 9 | d1 = False 10 | for n in nums: 11 | if n == 0: 12 | if d1: 13 | cnt += 1 14 | else: 15 | d1 = True 16 | ans = ans * (cnt + 1) % mod 17 | cnt = 0 18 | return int(ans % mod) if d1 else 0 -------------------------------------------------------------------------------- /leetcode/weekcontest/b107/1.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/leetcode/weekcontest/b107/1.py -------------------------------------------------------------------------------- /leetcode/weekcontest/b107/2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/leetcode/weekcontest/b107/2.py -------------------------------------------------------------------------------- /leetcode/weekcontest/b107/3.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zhang-wangz/algorithm/9cdbae4323c3afc0bfbae1a006c5e9d6eb7d9497/leetcode/weekcontest/b107/3.py -------------------------------------------------------------------------------- /leetcode/weekcontest/main/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func repeatedCharacter(s string) byte { 4 | m := map[byte]int{} 5 | for i := 0; i < len(s); i++ { 6 | m[s[i]]++ 7 | if m[s[i]] == 2 { 8 | return s[i] 9 | } 10 | } 11 | return 's' 12 | } 13 | -------------------------------------------------------------------------------- /leetcode/weekcontest/main/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func equalPairs(grid [][]int) int { 4 | n := len(grid) 5 | tmp := make([][]int, n) 6 | for i := 0; i < n; i++ { 7 | for j := 0; j < n; j++ { 8 | if tmp[i] == nil { 9 | tmp[i] = make([]int, n) 10 | } 11 | tmp[i][j] = grid[j][i] 12 | } 13 | } 14 | ans := 0 15 | for i := 0; i < n; i++ { 16 | for j := 0; j < n; j++ { 17 | for k := 0; k < n; k++ { 18 | if grid[i][k] == tmp[j][k] { 19 | if k == n-1 { 20 | ans++ 21 | } 22 | } else { 23 | break 24 | } 25 | } 26 | } 27 | } 28 | return ans 29 | } 30 | -------------------------------------------------------------------------------- /leetcode/weekcontest/main/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func countExcellentPairs(nums []int, k int) int64 { 6 | sort.Ints(nums) 7 | 8 | for i := 1; i < len(nums); i++ { 9 | if nums[i] == nums[i-1] { 10 | continue 11 | } 12 | for j := i; j < len(nums); j++ { 13 | 14 | } 15 | } 16 | return 0 17 | } 18 | 19 | func compute(i, j int) int { 20 | cnt := 0 21 | a := i & j 22 | b := i | j 23 | for a != 0 { 24 | a &= a - 1 25 | cnt++ 26 | } 27 | for b != 0 { 28 | b &= b - 1 29 | cnt++ 30 | } 31 | return cnt 32 | } 33 | -------------------------------------------------------------------------------- /leetcode/weekcontest/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main() { 4 | m := Constructor([]string{"kimchi", "miso", "sushi", "moussaka", "ramen", "bulgogi"}, []string{"korean", "japanese", "japanese", "greek", "japanese", "korean"}, []int{9, 12, 8, 15, 14, 7}) 5 | m.ChangeRating("sushi", 16) 6 | m.HighestRated("japanese") 7 | } 8 | -------------------------------------------------------------------------------- /leetcode/weekcontest/main/moudle.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //type minHeap struct { 4 | // sort.IntSlice 5 | //} 6 | // 7 | //func (h *minHeap) Len() int { 8 | // return len(h.IntSlice) 9 | //} 10 | //func (h *minHeap) Push(i interface{}) { 11 | // h.IntSlice = append(h.IntSlice, i.(int)) 12 | //} 13 | //func (h *minHeap) Pop() interface{} { 14 | // top := h.IntSlice[len(h.IntSlice)-1] 15 | // h.IntSlice = h.IntSlice[:len(h.IntSlice)-1] 16 | // return top 17 | //} 18 | -------------------------------------------------------------------------------- /original/main/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := -0 7 | b := a >> 63 8 | fmt.Print(b) 9 | } 10 | -------------------------------------------------------------------------------- /original/solution/lc.py: -------------------------------------------------------------------------------- 1 | 2 | from heapq import heappop, heappush 3 | 4 | def solve(cakes, limits): 5 | ans = 0 6 | hq = [] 7 | day = 0 8 | heappush(hq, (day+limits[day], cakes[day], day)) 9 | while hq: 10 | while hq: 11 | q = heappop(hq) 12 | if q[0] > day: 13 | print(day, q) 14 | ans += 1 15 | cnt = q[1] - 1 16 | if cnt > 0: heappush(hq, (q[0], cnt, q[2])) 17 | break 18 | day += 1 19 | if day < len(cakes): heappush(hq, (day+limits[day], cakes[day], day)) 20 | return ans 21 | 22 | print(solve([1,3,2],[3,5,2])) 23 | -------------------------------------------------------------------------------- /original/solution/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func solve(root, node *TreeNode) int { 10 | h := 0 11 | var dfs func(root, node *TreeNode, h *int) 12 | dfs = func(root, node *TreeNode, h *int) { 13 | if root == nil { 14 | return 15 | } 16 | if root == node { 17 | return 18 | } 19 | *h += 1 20 | dfs(root.Left, node, h) 21 | dfs(root.Right, node, h) 22 | } 23 | dfs(root, node, &h) 24 | return h 25 | } 26 | 27 | func main() { 28 | a := &TreeNode{Val: 5} 29 | a.Left = &TreeNode{Val: 4} 30 | a.Right = &TreeNode{Val: 9} 31 | c := &TreeNode{Val: 10} 32 | a.Left.Left = c 33 | println(solve(a, c)) 34 | } 35 | -------------------------------------------------------------------------------- /original/solution/最长公共子串/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 最长公共子串的长度 4 | // 以si，sj结尾的最长dp 5 | func solve(s, t string) (ans int) { 6 | m, n := len(s), len(t) 7 | dp := make([][]int, m+1) 8 | for i := range dp { 9 | dp[i] = make([]int, n+1) 10 | } 11 | for i := 1; i <= m; i++ { 12 | for j := 1; j <= n; j++ { 13 | if s[i-1] == t[j-1] { 14 | dp[i][j] = dp[i-1][j-1] + 1 15 | } 16 | ans = max(ans, dp[i][j]) 17 | } 18 | } 19 | return 20 | } 21 | func max(a, b int) int { 22 | if a > b { 23 | return a 24 | } else { 25 | return b 26 | } 27 | } 28 | 29 | func main() { 30 | solve("hello", "loo") 31 | } 32 | -------------------------------------------------------------------------------- /test.js: -------------------------------------------------------------------------------- 1 | var message = "Hello World"; 2 | console.log(message); 3 | -------------------------------------------------------------------------------- /test.ts: -------------------------------------------------------------------------------- 1 | var str = '1322' 2 | var str2:number = str //str、str2 是 string 类型 3 | console.log(str2) --------------------------------------------------------------------------------