待移植LeetCode代码块

最新推荐文章于 2023-02-11 16:42:40 发布

数学工具构造器

最新推荐文章于 2023-02-11 16:42:40 发布

阅读量390

点赞数

分类专栏：科学刷题

本文链接：https://blog.youkuaiyun.com/TQCAI666/article/details/116572583

版权

科学刷题专栏收录该内容

33 篇文章

订阅专栏

文章目录

骚题目
1363. 形成三的最大倍数
※ 440. 字典序的第K小数字
19. 删除链表的倒数第 N 个结点
54. 螺旋矩阵
105. 从前序与中序遍历序列构造二叉树
32. 最长有效括号
103. 二叉树的锯齿形层序遍历
76. 最小覆盖子串
236. 二叉树的最近公共祖先
347. 前 K 个高频元素
128. 最长连续序列
84. 柱状图中最大的矩形
64. 最小路径和
445. 两数相加 II
26. 删除排序数组中的重复项
6. Z 字形变换
96. 不同的二叉搜索树
739. 每日温度
85. 最大矩形
38. 外观数列
120. 三角形最小路径和
力扣找不到的字节面试题——36进制加法
头条笔试题 - 折木棍
逻辑题
双向链表的反转
补充题
- 字节跳动高频题——圆环回原点问题
- 面试字节前必看的高频题——木头切割问题
- 求区间最小数乘区间和的最大值
- 五分钟掌握：二叉树的下一个节点

骚题目

1420. 生成数组

1363. 形成三的最大倍数

927. 三等分

1363. 形成三的最大倍数

class Solution:
    def largestMultipleOfThree(self, digits: List[int]) -> str:
        n=len(digits)
        count=[0]*10
        modulo=[0]*3
        s=0
        for digit in digits:
            s+=digit
            count[digit]+=1
            modulo[digit%3]+=1
        if s%3==1:
            if modulo[1]>=1:
                rcnt=1
                rmod=1
            else:
                rcnt=2
                rmod=2
        elif s%3==2:
            if modulo[2]>=1:
                rcnt=1
                rmod=2
            else:
                rcnt=2
                rmod=1
        else:
            rcnt=0
            rmod=0
        ans=""
        for i in range(10):
            for j in range(count[i]):
                if rcnt>0 and i%3==rmod:
                    rcnt-=1
                else:
                    ans+=str(i)
                
        if len(ans)>0 and ans[-1]=='0':
            return '0'
        return ans[::-1]

※ 440. 字典序的第K小数字

440. 字典序的第K小数字

真的很头大，有空默写一遍

[字节跳动最常考题之一]本题史上最完整具体的手摸手解答，时间效率超越100%用户

class Solution:
    def findKthNumber(self, n: int, k: int) -> int:
        def get_count(prefix):
            nxt = prefix + 1
            count = 0
            while prefix <= n:
                count += min(nxt, n + 1) - prefix
                prefix *= 10
                nxt *= 10
            return count

        p = 1
        prefix = 1
        while p < k:
            count = get_count(prefix)
            if k < p + count:
                p += 1
                prefix *= 10
            else:
                p += count
                prefix += 1
        return prefix

19. 删除链表的倒数第 N 个结点

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        if not head:
            return None
        fast=head
        while fast and n:
            n-=1
            fast=fast.next
        dummy=ListNode(0)
        dummy.next=head
        p=dummy
        while fast:
            fast=fast.next
            p=p.next
        if p and p.next:
            p.next=p.next.next
        return dummy.next

54. 螺旋矩阵

注意break的判断条件

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m, n = len(matrix), len(matrix[0])
        left = top = 0
        right, bottom = n - 1, m - 1
        ans = []
        while True:
            for i in range(left, right + 1):
                ans.append(matrix[top][i])
            top += 1
            if top > bottom or left > right: break

            for i in range(top, bottom + 1):
                ans.append(matrix[i][right])
            right -= 1
            if top > bottom or left > right: break

            for i in range(right, left - 1, -1):
                ans.append(matrix[bottom][i])
            bottom -= 1
            if top > bottom or left > right: break

            for i in range(bottom, top - 1, -1):
                ans.append(matrix[i][left])
            left += 1
            if top > bottom or left > right: break
        return ans

105. 从前序与中序遍历序列构造二叉树

32. 最长有效括号

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        n = len(s)
        dp = [0] * n
        ans = 0
        for i in range(1, n):
            if s[i] == ")":
                if s[i - 1] == "(":
                    dp[i] = 2 + (
                        dp[i - 2] if i - 2 >= 0 else 0
                    )
                else:
                    pre = dp[i - 1]
                    pre_ix = i - 1 - pre
                    if pre_ix >= 0 and s[pre_ix] == "(":
                        dp[i] = dp[i - 1] + 2
                        # 没把条件缩进来
                        if pre_ix - 1 > 0:  # ()(())
                            dp[i] += dp[pre_ix - 1]
                ans = max(ans, dp[i])
        return ans

TODO: 栈

103. 二叉树的锯齿形层序遍历

76. 最小覆盖子串

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        need=collections.Counter(t)
        window=collections.defaultdict(int)
        valid=0
        n=len(s)
        l=0
        a,b=-1,n
        for r in range(n):
            c=s[r]
            if c in need:
                window[c]+=1
                if window[c]==need[c]:
                    valid+=1
            # 注意 l<=r 的判断条件
            while l<=r and valid==len(need): # 条件写错
                if r-l<b-a:
                    a,b=l,r
                c=s[l]
                if c in need:
                    if window[c]==need[c]:
                        valid-=1
                    window[c]-=1
                l+=1
        return "" if a==-1 else s[a:b+1]

236. 二叉树的最近公共祖先

因为判断条件顺序的bug导致卡了很久

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root is None:
            return None
        if root==p or root==q:
            return root
        left=self.lowestCommonAncestor(root.left,p,q)
        right=self.lowestCommonAncestor(root.right,p,q)
        # bug: 判断条件的顺序
        if left and right:
            return root
        if left or right:
            return left if left else right
        return None

347. 前 K 个高频元素

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        counter = collections.Counter(nums)
        heap=[]
        for num,cnt in counter.items():
            heapq.heappush(heap, (cnt, num))
            if len(heap)>k:
                heapq.heappop(heap)
        return [num for _,num in heap]

128. 最长连续序列

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        num_set=set(nums)
        max_len=0
        for num in num_set:
            if num-1 not in num_set:
                cur_len=1
                cur_num=num+1
                while cur_num in num_set:
                    cur_len+=1
                    cur_num+=1
                max_len=max(max_len, cur_len)
        return max_len

84. 柱状图中最大的矩形

注意是个单调递增栈

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        stack=[]
        n=len(heights)
        left=[-1]*n
        right=[n]*n
        for i, height in enumerate(heights):
            # 单调性写错
            # 单调递增
            while stack and heights[i]<heights[stack[-1]]: 
                top=stack.pop()
                right[top]=i
            if stack:
                left[i]=stack[-1]
            stack.append(i)
        ans=0
        for i in range(n):
            l=left[i]
            r=right[i]
            ans=max(ans, (r-l-1)*heights[i])
        return ans

64. 最小路径和

刚开始用回溯写的，我是傻逼

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m,n=len(grid),len(grid[0])
        visit=[[0]*n for _ in range(m)]
        # path=[]
        ans=inf
        def dfs(i,j,cur_sum):
            nonlocal ans
            if i==m-1 and j==n-1:
                # sum_=sum(path)
                ans=min(ans, cur_sum)
            for dx,dy in [[1,0],[-1,0],[0,1],[0,-1]]:
                x,y=i+dx,j+dy
                # val=
                if  (0<=x<m and 0<=y<n) and visit[x][y]==0 and cur_sum+grid[x][y]<ans:
                    visit[x][y]=1
                    # path.append(val))
                    dfs(x,y,cur_sum+grid[x][y])
                    # path.pop()
                    visit[x][y]=0
        visit[0][0]=1
        # path.append(grid[0][0])
        dfs(0,0, grid[0][0])
        return ans

做的我有点想吐了。。

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        dp = [[0] * (n) for _ in range(m)]
        dp[0][0] = grid[0][0]
        for i in range(1, m):
            dp[i][0] = dp[i - 1][0] + grid[i][0]
        for i in range(1, n):
            dp[0][i] = dp[0][i - 1] + grid[0][i]
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
        return dp[m - 1][n - 1]

445. 两数相加 II

def reverse(p):
    pre=None
    while p:
        aft=p.next
        p.next=pre
        pre=p
        p=aft
    return pre

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        l1=reverse(l1)
        l2=reverse(l2)
        dummy=ListNode(0)
        dp=dummy
        carry=0
        while l1 or l2:
            v1=l1.val if l1 else 0
            v2=l2.val if l2 else 0
            l1=l1.next if l1 else None
            l2=l2.next if l2 else None
            v=v1+v2+carry
            carry=v//10
            dp.next=ListNode(v%10)
            dp=dp.next
        if carry:
            dp.next=ListNode(carry)
        return reverse(dummy.next)

26. 删除排序数组中的重复项

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow=fast=0
        n=len(nums)
        while fast<n:
            if nums[slow]!=nums[fast]:
                slow+=1
                nums[slow]=nums[fast]
            fast+=1
        return slow+1

6. Z 字形变换

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows==1:
            return s
        rows=[""]*numRows
        i=0
        flag=-1
        for c in s:
            rows[i]+=c
            if i in (0, numRows-1):
                flag*=-1
            i+=flag
        return "".join(rows)

96. 不同的二叉搜索树

def C(a, b):
    ans = 1
    for _ in range(b):
        ans *= a
        a -= 1
    while b >= 1:
        ans //= b
        b -= 1
    return ans

def catalan(n):
    return C(2*n, n) // (n + 1)


class Solution:
    def numTrees(self, n: int) -> int:
        return (catalan(n))

739. 每日温度

class Solution:
    def dailyTemperatures(self, T: List[int]) -> List[int]:
        stack=[]
        # 从右到左，第一个更小的
        n=len(T)
        right=[0]*n
        for i in range(n-1, -1, -1):
            # 单调递减
            while stack and T[stack[-1]]<=T[i]: # 要求更高的气温
                stack.pop()
            # 这里卡住了
            right[i]=stack[-1]-i if stack else 0
            stack.append(i)
        return right

85. 最大矩形

def max_hist_rect(heights):
    n=len(heights)
    left=[0]*n
    right=[n]*n
    stack=[]
    for i in range(n):
        # 单调递增栈      栈顶比当前元素大
        while stack and heights[stack[-1]]>heights[i]:
            top = stack.pop()
            right[top]=i
        left[i]=stack[-1] if stack else -1
        stack.append(i)
    ans=0
    for i in range(n):
        ans=max(ans, heights[i]*(right[i]-left[i]-1))
    return ans

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        if len(matrix)==0:
            return 0
        m, n = len(matrix), len(matrix[0])
        hist=[0]*n
        ans=0
        for i in range(m):
            for j in range(n):
                if matrix[i][j]=='0':
                    hist[j]=0
                else:
                    hist[j]+=1
            ans=max(ans, max_hist_rect(hist))
        return ans

38. 外观数列

class Solution:
    def countAndSay(self, n: int) -> str:
        pre = ''
        cur = '1'
        for _ in range(1, n):
            pre = cur
            cur = ''
            start = 0
            end = 0
            while end < len(pre):
                while end<len(pre) and pre[start] == pre[end]:
                    end += 1
                cur += str(end - start) + pre[start]
                start = end
        return cur

120. 三角形最小路径和

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        n=len(triangle)
        dp=copy.deepcopy(triangle)
        for i in range(1, n):
            for j in range(i+1):
                min_=inf
                for k in range(max(0, j-1),min(i,j+1)):
                    min_=min(min_, dp[i-1][k])
                min_+=triangle[i][j]
                dp[i][j]=min_
        return min(dp[n-1])

力扣找不到的字节面试题——36进制加法

415. 字符串相加

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        l1 = len(num1)
        l2 = len(num2)
        i1 = l1 - 1
        i2 = l2 - 1
        carry = 0
        base = 10
        ans = ''
        while i1 >= 0 or i2 >= 0 or carry:
            a = int(num1[i1]) if i1 >= 0 else 0
            b = int(num2[i2]) if i2 >= 0 else 0
            sum_ = a + b + carry
            ans = ans + str(sum_ % base)
            carry = sum_ // base
            i1 -= 1
            i2 -= 1
        return ans[::-1]

43. 字符串相乘

$O((n+m)\times n)$

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        if num1 == "0" or num2 == "0":
            return "0"
        
        ans = "0"
        m, n = len(num1), len(num2)
        for i in range(n - 1, -1, -1):
            add = 0
            y = int(num2[i])
            curr = ["0"] * (n - i - 1)
            for j in range(m - 1, -1, -1):
                product = int(num1[j]) * y + add
                curr.append(str(product % 10))
                add = product // 10
            if add > 0:
                curr.append(str(add))
            curr = "".join(curr[::-1])
            ans = self.addStrings(ans, curr)
        
        return ans
    
    def addStrings(self, num1: str, num2: str) -> str:
        i, j = len(num1) - 1, len(num2) - 1
        add = 0
        ans = list()
        while i >= 0 or j >= 0 or add != 0:
            x = int(num1[i]) if i >= 0 else 0
            y = int(num2[j]) if j >= 0 else 0
            result = x + y + add
            ans.append(str(result % 10))
            add = result // 10
            i -= 1
            j -= 1
        return "".join(ans[::-1])

头条笔试题 - 折木棍

TODO: 用合理的思路再重刷一遍

int breakNum(vector<int>& nums) {
    int ans = 0;
    for (int i = nums.size() - 2; i >= 0; i--) {
        if (nums[i + 1] >= nums[i]) continue;
        int t = (nums[i] - 1) / nums[i + 1];
        ans += t;
        nums[i] /= (t + 1);
    }
    return ans;
}

基本思路大概知道，两个比较难理解的点：

int t = (nums[i] - 1) / nums[i + 1];
nums[i] /= (t + 1);

第一个，t表示折出多少段。如 12 6, 可以折 6 ， 6，t=1

但是 12/6=2，所以- 1

第二个，折出t段，加上自己，一共t+1，故除 (t + 1)

逻辑题

100个人从1到100,每个回合去掉奇数序号的人,剩下的人向前排列，最后一回合剩下的人是第几个序号

双向链表的反转

补充题

字节跳动高频题——圆环回原点问题

设dp[i][j]为从0点出发走i步到j点的方案数

在这里插入图片描述

class Solution:
    def backToOrigin(self,n):
        #点的个数为10
        length = 10
        dp = [[0 for i in range(length)] for j in range(n+1)]
        dp[0][0] = 1
        for i in range(1,n+1):
            for j in range(length):
                #dp[i][j]表示从0出发，走i步到j的方案数
                dp[i][j] = dp[i-1][(j-1+length)%length] + dp[i-1][(j+1)%length]
        return dp[n][0]

面试字节前必看的高频题——木头切割问题

在这里插入图片描述

#include <iostream>
using namespace std;

const int N = 100010;
int a[N];
int n, k;

int check(int mid)
{
    int res = 0;
    for (int i = 0; i < n; i ++ ) res += a[i] / mid;
    return res;
}

int main()
{
    cin >> n >> k;
    int l = 1, r = -1;
    
    for (int i = 0; i < n; i ++ )
    {
        cin >> a[i];
        r = max(r, a[i]);
    }
    
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid) >= k) l = mid;
        else r = mid - 1;
    }
    
    cout << l << endl;
    return 0;
}

# 数组长度为【n】，切出至少【k】个相同长度为【m】的木块，已知【k】，求【m】
def check(nums, n, mid):
    res = 0
    for i in range(n):
        res += nums[i] // mid
    return res


def cut_wood(nums, k):
    n = len(nums)
    l, r = 1, max(nums)
    while l < r:
        cur_m = (l + r) // 2
        # m越大，k越小
        cur_k = check(nums, n, cur_m)
        if cur_k == k:
            r = cur_m
        elif cur_k < k:
            r = cur_m
        else:
            l = cur_m + 1
    return l


m = cut_wood([4, 7, 2, 10, 5], 5)
print(m)

求区间最小数乘区间和的最大值

五分钟掌握：二叉树的下一个节点

[编程题]二叉树的下一个结点

二叉树为空，则返回空；
节点右孩子存在，则设置一个指针从该节点的右孩子出发，一直沿着指向左子结点的指针找到的叶子节点即为下一个节点；
节点不是根节点。如果该节点是其父节点的左孩子，则返回父节点；否则继续向上遍历其父节点的父节点，重复之前的判断，返回结果。

class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if(pNode==NULL)
            return NULL;
        if(pNode->right!=NULL)
        {
            pNode=pNode->right;
            while(pNode->left!=NULL)
                pNode=pNode->left;
            return pNode;
        }  
        while(pNode->next!=NULL)
        {
            TreeLinkNode *proot=pNode->next;
            if(proot->left==pNode)
                return proot;
            pNode=pNode->next;
        }
        return NULL;
    }
};