hewesH的博客

最近参加了一下zj的青训营，时间和周赛冲突了，只能刷每日一题了，周赛有时间会补上的，下面进入正题题目：给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数，并以数组形式返回。你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。func findDuplicates(nums []int) (ans []int) { // nums[i] 放在对应下标

题目地址解题思路利用三维数组实现动态规划，dp[i][j][k],i表示最大maxMove数，j和k表示从startRow和startColumn移动到这的路径数，如果i+1就是增加一步出界了，就直接累加上count就ok，否则需要更新dp，具体代码如下。package mainimport "fmt"const mod int = 1e9 + 7var dirs = []struct{ x, y int }{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}f

搜索回溯算法，我算是和回溯干上了，周赛也遇到，无奈还没学会，花点时间去攻克一下了package mainimport "fmt"func combinationSum(candidates []int, target int) (ans [][]int) { var dfs func(start int, tmp []int, sum int) dfs = func(start int, tmp []int, sum int) { if sum >= target { /

作为一个一直1AC的选手来说，能够A掉两题真的超级开心，可能是前两题比较简单吧，就直接上截图吧。第一题代码func largestInteger(num int) int { s := strconv.Itoa(num) n := len(s) odd, even := []int{}, []int{} vis := []int{} for i := 0; i < n; i++ { if s[i]%2 == 0 { odd = append(odd, -int(s[i

利用回溯的思想去求解本题，排列组合问题，先枚举每一个位置上数字对应的字母，每一层都是遍历选择，通过标记当前层数来判断当前是否已经完成一次排列组合，然后回退到上一层，以此类推。最后呈上代码package mainimport "fmt"var phoneMap map[string]string = map[string]string{ "2": "abc", "3": "def", "4": "ghi", "5": "jkl", "6": "mno", "7": "pqrs",

必须再次记录一下第二个双百题，2022年三月的最后一天打卡每日一题题目思路还是很清晰的，直接上代码func selfDividingNumbers(left int, right int) []int { if left > right { return []int{} } var cnt []int for i := left; i <= right; i++ { if check(i) { cnt = append(cnt, i) } } return

不难发现其中的规律，需要处理的点就是第一行和最后一行，此外，每一个完整的周期内都会存在两个元素，最后就是根据字符串的长度去判断最后一个周期的完整程度。package mainimport "fmt"func convert(s string, r int) string { n := len(s) if r == 1 || r >= n { return s } // 可以发现周期t t := 2*r - 2 ans := make([]byte, 0, n) // 循

巧妙地利用抵消的方法，实现多数的求解。另外的方法就是构建一个字典，然后超过半数的key就是这个多数元素。这个空间复杂度是O(n)，而上面的方法是O(1)的空间复杂度，时间复杂度都是一样的O(n)。func majorityElement(nums []int) int { candidate, count := 0, 0 for _, v := range nums{ // 统计count为正数时，candidate超过半数，为0就需要继续找candidate

这里采用同层次遍历相同的策略，同样是用数组存放结点，区别在于增加了结点所在当前层的序号，这个根据父节点的序号计算（左节点是父节点序号的2倍，右节点是父节点序号的2倍+1）。需要注意的是，计算宽度的时候别忘了➕1！！！/** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */// 借助一

这个题要求在数组nums1上直接排序，强行限制空间复杂度，但是如果你另外再开好一个数组，排好序之后，再拷贝到nums1也不是不行，但是应该不是出题者的初衷吧。考虑到头插法还需要移动nums1中后面的元素，用两个指针实现尾插法排序，具体代码如下：func merge(nums1 []int, m int, nums2 []int, n int) { length := m+n // 对应各自下标 m-- n-- length-- for m>=

/** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */func reverseKGroup(head *ListNode, k int) *ListNode { hair := &ListNode{Next:head} prev:= hair for head !=nil { tail .

继续二叉树的遍历，这次用到的是深度优先遍历dfsfunc numIslands(grid [][]byte) int { res := 0 m, n := len(grid), len(grid[0]) // 辅助数组记录是否已经访问 visited := make([][]bool,m) for i:=0;i<m;i++{ visited[i] = make([]bool,n) } var dfs func(i,j int

对树和图的知识忘的差不多了，借助LC重新复习一遍下面是二叉树的层次遍历/** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */func levelOrder(root *TreeNode) [][]int { ret := [][]int{} if root == n

这题乍一看不难，但是加上了O(n)的时间复杂度和O(1)的空间复杂度之后，就变得让人无从下手了，我是想到了集合方法，a是a了，但是没达到要求，求证了官方题解之后才豁然，异或太妙了集合的方法def singleNumber(self, nums: List[int]) -> int: seen = set() for i in range(len(nums)): if nums[i] not in seen: seen.add(nums[

class Solution: def generateMatrix(self, n: int) -> List[List[int]]: m = [[0] * n for _ in range(n)] row, col = 0, 0 num, direc = 1, 0 # 定义行进方向0，1，2，3分别代表右下左上，主要还是边界的判断 while num <= n ** 2: if .

package main/** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */// 哈希表实现//func detectCycle(head *ListNode) *ListNode {// isExistsMap := map[*ListNode]int{}// for head!=nil{// if _,ok := i.

package main// 141 Linked List Cyclefunc hasCycle(head *ListNode) bool { // 快慢指针方法 //fast, slow := head, head //for slow != nil && fast != nil { // slow = slow.Next // fast = fast.Next.Next // if slow == fast{ // return true // } //}.

方法1 递归实现func swapPairs(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } // 新的头节点是原先链表的第二个节点 newHead := head.Next // 这是把原先第二个节点后的链表看作一个整体 head.Next = swapPairs(newHead.Next) // 调换两个节点的顺序 newHead.Next = head // 返回新

方法1. 遍历整个链表，同时反转节点的指向前驱节点func reverseList(head *ListNode) *ListNode { // 定义前驱节点 var pre *ListNode cur := head for cur != nil { // 找到当前节点的下一个指针 next := cur.Next // 按照题目要求，当前指针需要指向前一个节点 cur.Next = pre

问题描述：给定一个二叉树的根节点 root ，返回它的 中序 遍历。提供两种解法1 递归实现func inorderTraversal(root * TreeNode) (res []int){ var inorder func(node *TreeNode) inorder = func(node *TreeNode){ if node == nil { return } inorder(node.Lef

解题的关键在于去除重复的组合func threeSum(nums []int) [][]int { n := len(nums) sort.Ints(nums) ans := make([][]int, 0) for first := 0; first < n; first++ { if first > 0 && nums[first] == nums[first-1] { continue } third := n - 1 target :

1. 直接排放之后快速排序func sortedSqueres(nums []int)[]int{ // 用make动态生成一维数组 ans := make([]int, len(nums)) for i,v := range nums{ ans[i] = v * v } // 这里直接用自带的快排 sort.Ints(ans)}2. 双指针func sortedSquares(nums []int) []int { n :

双指针法直接求解func maxArea(height []int) int { l, r := 0, len(height)-1 // 分别记录最大容器体积和当前容器体积 maxSize := 0 size := 0 for l < r { // 左右指针的坐标和对应数组中的较小值求的当前容器体积 size = (r - l) * min(height[l], height[r]) if size > maxSize { maxSize = size }

class Solution: def countQuadruplets(self, nums: List[int]) -> int: cnt = 0 if len(nums) < 4: return cnt # nums.sort() for a in range(len(nums)-3): for b in range(a+1, len(nums)-2): .

class Trie: def __init__(self): self.children = [None] * 26 self.isEnd = False # 根据插入的word构造字典树 def insert(self, word): node = self for ch in word: ch = ord(ch) - ord("a") if not node.ch.

class Trie: def __init__(self): self.children = [None] * 26 self.isEnd = False def searchPrefix(self, prefix): node = self for ch in prefix: ch = ord(ch) - ord("a") if not node.children[ch]:.

def numFriendRequests(ages): n = len(ages) ages.sort() left = right = ans = 0 for age in ages: if age < 15: continue # 找到满足第一个条件的前一个age while ages[left] < 0.5 * age + 7: left += 1 .

class Solution: def findOcurrences(self, text: str, first: str, second: str) -> List[str]: res = [] list_items = text.split(' ') for i in range(len(list_items)-2): if list_items[i] == first and list_items[i+1] ==.

class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = rightdef isEvenOddTree(root): queue = [root] level = 0 while queue: # 为了之后递增递减的准备的prev .

class Solution: def eatenApples(self, apples: List[int], days: List[int]) -> int: ans = 0 pq = [] i = 0 # 第一阶段还在产苹果 while i < len(apples): while pq and pq[0][0] <= i: heappop.

不得不说，今日一题，属实太难了，我看了半天题解，总算是看明白了点，直接上代码之后还得继续复习TODOimport randomclass Solution: def longestDupSubstring(self, s: str) -> str: a1, a2 = random.randint(26, 100), random.randint(26, 100) mod1, mod2 = random.randint(10 ** 9 + 7, 2

import mathclass Solution: def repeatedStringMatch(self, a: str, b: str) -> int: # 处理叠字的情况 Set_a, Set_b = set(a), set(b) if Set_a & Set_b != Set_b: return -1 # 下面就是正常逻辑的操作了 cnt_a = math.ceil(.

class Solution: def dayOfYear(self, date: str) -> int: months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334] time = date.split('-') year = int(time[0]) month = int(time[1]) day = int(time[2]) .

from bisect import bisect_rightclass Solution: def findRadius(self, houses: List[int], heaters: List[int]) -> int: ans = 0 heaters.sort() for house in houses: # house存在于heaters中，则插在相同元素的右边 j = bisect.

一切尽在代码中class Solution: def findJudge(self, n: int, trust: List[List[int]]) -> int: # 入度列表表示相信某人 # 出度表示主动相信某人 # 由题可知，法官不相信任何人，除了法官之外的人都相信法官 indegree = [0 for _ in range(n+1)] outdegree = [0 for _ in range(n+

由于战舰的位置只能是横着或者竖着，借助一个二维的数组记录已经访问过的点，即可统计出战舰的个数。下面是本人AC的codeclass Solution: def countBattleships(self, board: List[List[str]]) -> int: if not board or not board[0]: return 0 m = len(board) n = len(board[0])

一般解法class Solution: def numWaterBottles(self, numBottles: int, numExchange: int) -> int: # res表示最终我们能换到酒的数量 res = numBottles if numBottles < numExchange: return res while numBottles >= numExchange

class Solution: def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -> int: sameCnt = 0 polarDegrees = [] for p in points: if p == location: # 计算和出发点相同point的个数 .

拓扑排序TODOfrom collections import dequedef loudAndRich(richer, quiet): n = len(quiet) g = [[] for _ in range(n)] inDeg = [0] * n # 构建有向图（有钱指向没钱），并且统计每个节点的入度 for r in richer: g[r[0]].append(r[1]) inDeg[r[1]] += 1

以为有更方便快捷的解法，结果还是需要列举出全部的情况class Solution: def win(self, board: List[str], p: str) -> bool: # 包含同一行同一列和斜对角的情况 return any(board[i][0] == p and board[i][1] == p and board[i][2] == p or board[0][i] == p