1996MZH的博客

以为 是博弈的从两边拿结果是随便拿毫无技术含量n = int(input())l = [int(val) for val in input().split(' ')]l = sorted(l,reverse= True)index = 0jia = 1suma = 0sumb = 0while index < len(l): if jia == 1: suma += l[index] jia = 0 else: s.

可能的结果只有两种即 所有G在左侧或所有B在左侧alist = [a for a in input()]t1 = 0t2 = 0index = 0lastGindex = 0while lastGindex <= len(alist) - 1 and 'G' in alist[lastGindex:]: G_index = alist.index('G') alist[G_index] ='g' t1 += G_index - index index.

class Solution: def missingNumber(self, nums: List[int]) -> int: start = 0 end = len(nums) - 1 if nums[0] != 0: return 0 while start <= end: mid = start + ((end-start)>>1) .

二分class Solution: def __init__(self): self.d = {} def arrangeCoins(self, n: int) -> int: if n == 0: return 0 if n == 1: return 1 elif n == 3: return 2 start = 0 .

动态规划建立dp表格m行n列m为s的长度n为t的长度只填主对角线及其右上部分dp[i][j]==2表示s[:i]恰是t[:j]的子串== 1 表示s[:i]是t[:j]的子串且是t[:j-1]的子串==0表示 s[:i]不是t[:j]的子串先将第一行填好我们为第一个重合的位置填2 后续填1对于第二行到第m行如果dp[i][j-1] >=1 即s[:i]是t[:j-1]的子串则s[:i]一定是t[:j]的子串 即dp[i][j] = 1否则如果s[i] == t[j] .

分为三步第一在原链表的每个节点后面 复制一个与该节点值相等的节点 这个复制节点的random可以先不管 默认为None第二将每个原本的节点的next（即刚刚复制出的节点） 指向原本节点的random的next（原本的节点的random的next是原本节点的random指向的节点所对应的复制节点）第三只保留所有复制出的节点将原本的节点都断连最后返回第一个复制节点"""# Definition for a Node.class Node: def __init__(self, ..

三指针法记住 不需要伪头指针先对长度小于等于2 的链表进行特殊处理对于更普通的长链表三个指针初始分别指前三个 允许第三个是None先把头指针的next指空然后在cur3不是None的时候让cur2的next指cur1然后依次将cur1指向cur2cur2指向cur3cur3指向cur3的next最后将cur2的next指向cur1返回cur2# Definition for singly-linked list.# class ListNode:# def __in.

注意 返回到上一层的值 只能是自己或由自己一条子树返回的值# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None## # @param root TreeNode类 # @return int整型#class Solution: def __init__(self): s...

注意 当所有零食的体积和小于等于容积时直接返回2^nl = [int(val) for val in input().split(' ')]n = l[0]w = l[1]s = [int(val) for val in input().split(' ')]s = sorted(s)suma = 0def rec(last_used_space,rest,n,w): global suma if rest == [] and last_used_space <= .

三指针遇到相同的时候 可能是用A的第i个 有可能是用B的第j个递归 or即可# -*- coding:utf-8 -*-class Mixture: def chkMixture(self, A, n, B, m, C, v): # write code here if n + m != v: return False if n == 0: return True if A == C else.

先找两端点 也就是说如果原数组是单增或单减的 结果就是0然后统计每个位置左侧最大的数和右侧最大的数当前位置的储水量为min(leftmax,rightmax)-自己的高度n = int(input())l = [int(val) for val in input().split(' ')]startx = -1endx = -1for i in range(len(l)-1): if l[i] > l[i+1]: startx = i + 1 ...

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39# -*- coding:utf-8 -*-class Solution: def Fibonacci(self, n): # write code here if n == 0: return 0 elif n == 1: return 1 f1 = 0

# -*- coding:utf-8 -*-class Solution: # array 二维列表 def Find(self, target, array): # write code here rows = len(array) cols = len(array[0]) startx = rows - 1 starty = 0 while startx >= 0 and start.

本题最大的难点不是题目本身而是如何处理牛客网的多组流数据输入输出from heapq import * while True: try: n = int(input()) direction = int(input()) heap = [] score_dict = {} for _ in range(n): l = input().split(' ') this_.

先找到所有上升区间的起始位置索引存为[(start1,end1),(start2,end2),…]然后从上面第二个区间开始 依次探讨和其前一个区间合并的可能性假设原数组为l合并的条件是start2 = end1 + 1 and l[end1] > l[start2] and l[end1] < l[start2+1]或start2 = end1 + 1 and l[end1] > l[start2] and l[end1-1] < l[start2]当满足上述条件.

二阶DPDP[i][j]的意义是s1和s2之间以s1[i]和s2[j]位置元素为结尾的连续公共子串长度最后取DP中最大的数即可s1 = input()s2 = input()m = len(s1)n = len(s2)dp = []for _ in range(m): dp.append([0 for _ in range(n)])maxa = 0#先填第一行for i in range(n): if s1[0] != s2[i]: continue.

从原数组的末尾往前2个2个跳 然后再跳向末尾 同样是2个2个跳n = int(input())l = input().split(' ')resstr = ''index = n - 1if n % 2 == 0: while index >= 1: resstr += l[index] resstr += ' ' index -= 2 index = 0 while index < n - 1: .

按照两数之和的思想解n = int(input())l = [int(val) for val in input().split(' ')]l = sorted(l)nums = 0for i in range(n-2): for j in range(i+1,n-1): pre_sum = l[i] + l [j] for k in range(j+1,n): if pre_sum > l[k]: .

判断循环字符串的简单方法如果a和b是互为循环字符串则a in b+bn = int(input())res = []for _ in range(n): res.append(input())all_word = set()suma = 0def check(old,this): if old in this+this and len(old)==len(this): return True else: return Falsefo.

n = int(input())l = [int(val) for val in input().split(' ')]l = sorted(l)mina = Nonemaxa = Nonefor i in range(n//2): tempres = l[i] + l[-(i+1)] mina = tempres if mina == None else min(mina,tempres) maxa = tempres if maxa == None else max..

95%通过率l1 = input().split(' ')original_str = input()strl2 = list(original_str)l2 = [int(val) for val in strl2]n,k = int(l1[0]),int(l1[1])#一共n位#需要有k个相同all_val = []diff = 0for each in l2: if each not in all_val: all_val.append(each) ..

思路都写在注释里了n = int(input())x = input().split(' ')res = []maxlen = 0for each in x: this_x = int(each) maxlen = max(maxlen,this_x) tempres = [(1/this_x) for _ in range(this_x)] res.append(tempres)for i in range(len(res)): while len(r.

找规律求最小值 只需要从大到小排列（从1开始 最小值的规律是1 1 0 0 1 1 0 0 … ）求最大值 只需要将最大的N放在最后一个 前面N-1个 是 MID,MID+1,…,N-1,MID-1,… 1即可从1开始 最大值规律是 i i-1 i-1 i i i-1 i-1 …找规律即可得 得到如下代码n = int(input())for _ in range(n): N = int(input()) if N%2==0: minres = 0 if (N..

多多鸡有N个魔术盒子（编号1～N），其中编号为i的盒子里有i个球。多多鸡让皮皮虾每次选择一个数字X（1 <= X <= N），多多鸡就会把球数量大于等于X个的盒子里的球减少X个。通过观察，皮皮虾已经掌握了其中的奥秘，并且发现只要通过一定的操作顺序，可以用最少的次数将所有盒子里的球变没。那么请问聪明的你，是否已经知道了应该如何操作呢？输入描述:第一行，有1个整数T，表示测试用例的组数。（1 <= T <= 100）接下来T行，每行1个整数N，表示有N个魔术盒子。（1 &

链接：https://www.nowcoder.com/questionTerminal/5c5fa5bf2a9942fcb1a3844d715087b9来源：牛客网众所周知，牛妹非常喜欢打游戏，在阳光明媚的一天，她在玩一个叫做打怪兽的游戏。也许您已经知道游戏“打怪物”。如果您不知道，没关系，让我现在告诉您，森林里有那么多怪物，您就是攻击怪物并保护村庄的英雄。为了简化问题，我们把怪物排成一行，怪物身上有很多攻击点，你有一把剑，只能切掉攻击点，当切掉一个攻击点时，怪物会分裂成两个在段中，您必须消耗与怪

递归 全局变量记录数目用一个数组记录此前达到的所有结果值每次都在以前的结果上 加上当前root的val加完 如果右等于目标值的 全局变量+1而最后还需要单独加入一个root的val元素再递归下一层返回全局变量class Solution: def __init__(self): self.res = 0 self.target = 0 def pathSum(self, root: TreeNode, sum: int) -> int: .

注意，本题容易想复杂题目保证输入是整数数组因此不存在像[0.01,1,-57,-56,0.01,1]这种傻逼案例记住:本体的答案子数组一定要么是从左边 要么是从右边开始的因为 所有元素都是整数 或正或负或0我们先假设 不会遇到0假设全正 那么一定是整个数组的连乘如果有奇数个负数如果是1个负数我们只需要计算这1个负数左侧和右侧的连乘结果即可 此时结果一定是要么是从左边 要么是从右边开始的如果是3个或以上（假设是m个）负数我们只需要找到从左边开始 到第m个负数左侧（不含）的结果 的连乘.

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def __init__(self): self.res = [] self.length = 0 de.

我们将数据分开存储用两个小根堆一个存数据流偏小的半段一个存数据流偏大的半段如何实现呢python中的heapq是默认的小根堆 也就是每次都弹出最小的元素那么我们用它来存储偏大的半段 则我们每次都可以吐出偏大一段的最小值要构造偏小、且能随时吐出自身中最大元素的半段我们还是用另一个小根堆B代替 只不过在记录数据的时候有一些技巧我们在每次录入时进行检查如果小根堆A和大跟堆B长度相等则我们将元素先取相反数然后录入B然后再将它吐出后取反录入A如果二者长度不等我们先将元素录入A然后从A中.

import matplotlib.pyplot as pltclass kmeans: def __init__(self,k,n,node_list,iterations): self.k = k self.n = n self.all_nodes = node_list self.iter = iterations self.center = [] self.res = []

class Solution: def __init__(self): self.history = set() def exist(self, board: List[List[str]], word: str) -> bool: if board == [] or board[0] == []: return False m = len(board) n = len(board[0]) .

class Solution: def __init__(self): self.alldict = {} def topKFrequent(self, nums: List[int], k: int) -> List[int]: for each in nums: if each in self.alldict: self.alldict[each] += 1 else:.

快慢指针找中点反转后半段 注意将原后半段的头结点的next清空将反转后的后半段的节点 插入到前半段的两两节点间# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def reorderList(self, head.

设word1的长度是mword2的长度是ndp是一个m+1行 n+1列的矩阵dp[0][0] = 0其中 第0行第i个元素表示 从一个空字符串变到word2[:i] 最少需要几步 很明显需要i步其中 第0行第j个元素表示 从一个空字符串变到word1[:i] 最少需要几步 很明显需要i步而dp[i][j] i,j均大于1 表示 从word1[:i]变到word2[:j]最少需要几步看几种情况假设我们知道从word1[:i-1]变到word2[:j]需要x步 则从word1[:i]变到wor.

我们将每一层的最左侧索引和最右侧索引记录为一个元组，放在一个全局变量list里我们设计一个函数用于递归其输入是 新递归到的节点root、其父节点在上一层（父节点自己那层）从左往右数是第几个index、自己这层的深度depth 以及自己是父节点的左孩子还是右孩子direction（int,左 为 1 右为2）根据index 我们计算出上一层中 父节点前面有几个节点k = index-1则每一个节点在本层从左往右数是第几个 this= 2*k + direction然后我们看 本层是否已经有..

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None#前序 根 左 右#中序 左 根 右#先找根 然后将中序分左右class Solution: def buildTree(self, preorder: List[int.

后续 [左子树区，右子树区，根]二叉搜索树 严格满足 左子树区<根<右子树区因为不能保证数组是满足 左子树<根<右子树的所以需要从头开始依次遍历特殊情况：只有一个root的后续 True否则 需要划分左右子树区先确定 根root为post[-1]我们在[:-1]上 找第一个比根大的节点 此节点为右子树区开端之后 继续遍历 如果在右子树区找到比root小的 则false如果没有比root大的 再判断左子树和右子树是不是也是二叉搜索树上述的寻找有下面几种可能.

原函数是有一次删除机会的再定义一个严格回文的函数用双指针指向0和末尾当所指数相等 且 双指针相差不大于2时 返回True这是为了解决cabac这种情况 当两个指针都指a时 因为二者相差小于等于2 所以直接是True当所指数相等 且 双指针相差大于2时 二者同时向中间靠拢当所指数不等时如果是指针之间只隔了一个 即aabcaa这种情况 可以删去一个 则也认为是True如果指针之间相隔了多个则需使用删除机会删哪个呢？都有可能因此 需判断s[start+1:end+1] 即删除start或.

先排除 大于[-1][-1] 小于[0][0] 和空阵然后从左下角开始找因为 存在于矩阵中的数 比最下角大的都在左下角右边 比左下角小的都在坐下角上面这样 如果左下为目标 则true如果左下角大于目标 则最后一行排除若左下角小于目标则最左一列排除class Solution: def searchMatrix(self, matrix, target): """ :type matrix: List[List[int]] :type ta.

快慢指针即可# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def middleNode(self, head: ListNode) -> ListNode: if head == None: ret.