一只在cv道路上爬行的小乌龟~

根据题目分析，画布上任意一个点的横坐标和纵坐标 到这四个点中任意一个点的 横坐标之差与纵坐标之差的和 小于2020 即该点会在2020min内变成黑色，计数加一。按照逻辑写出代码如下：（迭代约为6060*6040次，若无语言限制，python 运行较慢，计算出答案大概8s左右，c++较快，2s左右)#include <iostream>using namespace std;// (0,0),(2020,11),(11,14),(2000,2000)int main() {.

ans=0# 求最大公约数def help(a,b): t=a while(t>0): if a%t==0 and b%t==0: return t t=t-1for i in range(1,2021): # i 1-2020 for j in range(i+1,2021): if help(i,j)==1: ans+=2print(ans)答案跑出来是.

num=0n=78120for i in range(1,78121): if n%i==0: num+=1print(num)

n, m = map(int, input().split(' '))data = [[0] * n for _ in range(m)] # 用于保存旋转之后的元素的矩阵#print(data)for row in range(n): values = list(map(int, input().split(' '))) for col in range(m): data[col][n - row - 1] = values[col] # 就是将第一行..

这道题，一开始就按照正常思路写，然后没有取余，放在那里算了一个小时都没有算完，这才意识到不对劲，加上取余后，很快就算完了a, b, c = 1, 1, 1for i in range(3, 20190324): a, b, c = b, c, (a + b + c) % 10000print(c)...

with open("2020.txt","r") as f: s=f.read()lis=s.split("\n") # 将每一行保存为一个字符串# 逐行读取2020.txtans=0for i in range(300): for j in range(300): if lis[i][j]=='2': if j<=296 and lis[i][j+1]=='0' and lis[i][j+2]=='2' and lis[i].

n=0for i in range(2021): num = str(i) n += num.count('2')print(n)

一开始看成服务器之间必须连续的了，搞得还用深度优先搜索写成来了，然后发现只需要同行或者同列即可，真实冤大头class Solution: def countServers(self, grid: List[List[int]]) -> int: m, n = len(grid), len(grid[0]) count_m, count_n = [0] * m, [0] * n for i in range(m): fo.

class Solution: def firstBadVersion(self, n): """ :type n: int :rtype: int """ ans=[] def bina(pre,last): if pre==last: ans.append(pre) return mid=.

class Solution: def preorder(self, root: 'Node') -> List[int]: ans=[] def dfs(root): if root==None: return ans.append(root.val) for child in root.children: dfs(chi.

这道题可算是写了一下午，思路错误写半天还超时，思路正确1min写出来！！！所以啊，好的思路胜过一切，做题前还是多想想办法。首先给出我写了半天还超时的代码叭，留作纪念：主要就是遍历1到n，然后维护一个列表，每次将数字插入到列表中的正确位置，这样一来时间复杂度可就高了去了class Solution: def lexicalOrder(self, n): ans=[1] def insert_(s,j): s=str(s) .

class Solution: def largestNumber(self,nums): res=[] for i in nums: res.append(str(i)) for passnum in range(len(res)-1,0,-1): for i in range(passnum): if int(res[i]+res[i+1])<int(res[i.

class Solution: def sumNumbers(self, root: TreeNode) -> int: if root==None: return 0 ans=[] temp=[] def help(ans,temp,node:TreeNode): if node.left: temp.append(str(node.val)) .

class Solution: def merge(self, intervals): intervals.sort(key=lambda x:x[0]) i=0 while(i<len(intervals)-1): if intervals[i][1]<intervals[i+1][0]: i+=1 if i<len(intervals)-1 and .

class Solution: def climbStairs(self,n): ans=[1,2,3,5] while(len(ans)<n): ans.append(ans[-1]+ans[-2]) return ans[n-1]

class Solution: def search(self, nums: List[int], target: int) -> int: if target in nums: return nums.index(target) return -1

class Solution: def minCostClimbingStairs(self, cost): n=len(cost) dp=[0 for _ in range(n+1)] i=2 while(i<n+1): dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]) i+=1 return dp[-1]

class Solution: def generateParenthesis(self, n: int) -> List[str]: def generate(A): if len(A) == 2*n: if valid(A): ans.append("".join(A)) else: A.append('(') .

# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution: def minDepth(self, root: TreeNode) -> i.

class Solution: def evalRPN(self, tokens: List[str]) -> int: op_to_binary_fn = { "+": add, "-": sub, "*": mul, "/": lambda x, y: int(x / y), # 需要注意 python 中负数除法的表现与题目不一致 } s.

class Solution: def majorityElement(self, nums: List[int]) -> int: ans=0 a=set(nums) for i in a: if nums.count(i)>(len(nums)/2): ans=i return ans

class Solution: def missingNumber(self, nums: List[int]) -> int: n=len(nums) nums=sorted(nums) j=0 for i in nums: if i!=j: return j j+=1 return j

主要思想就是将字母出现的次数和字母保存在不同的两个列表中，字母和出现次数一一对应，然后根据出现次数大小对字母进行重新组合class Solution: def frequencySort(self, s: str) -> str: d=dict() for i in s: if i not in d: d[i]=s.count(i) ans="" strs=list(d..

import queueclass Solution: def levelOrder(self, root: TreeNode) -> List[List[int]]: if not root: return [] q = queue.Queue() q.put(root) # 先把根节点入队 ans = [] while not q.empty(): .

利用动态规划，构建dp数组：class Solution: def countVowelStrings(self, n: int) -> int: temp = [[0] *5 for _ in range(n)] for i in range(5): temp[0][i]=1 for i in range(n): for j in range(5): if .

题目：（ 买卖股票的最佳时机）给定一个数组 prices ，其中 prices[i] 表示股票第 i 天的价格。在每一天，你可能会决定购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以购买它，然后在 同一天 出售。返回 你能获得的 最大 利润 。示例 1:输入: prices = [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格= 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股

class Solution: def searchMatrix(self, matrix, target: int) -> bool: for row in matrix: for element in row: if element == target: return True return False

刷到快乐数，我快乐了！！！class Solution: def isHappy(self, n: int) -> bool: def help(x): temp = list(map(int,[i for i in str(x)])) num=0 for i in temp: num+=i**2 return num arrive

class Solution: def generate(self, numRows): ans = [] for i in range(numRows): row = [] for j in range(0, i + 1): if j == 0 or j == i: row.append(1) else: .

maze.txt文件内容如下：010101010010110010010101100101101001000010001010100000100010000010101001000010000000100110011010010101111011010010001000001101001011100011000000010000010000000010101000110100001010000010101010110010110001111100000010100001001010001010..

class Solution: def findString(self, words: List[str], s: str) -> int: for i in range(len(words)): if words[i]=="": pass else: if words[i]==s: return i retu.

class Solution: def findTheDifference(self, s: str, t: str) -> str: if s=="": return t temp=dict() s=list(s) for i in s: if i not in temp: temp[i]=1 if i in temp:.

class Solution: def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]: l = [] node = head while node: l.append(node.val) node = node.next l.sort() node = head for..

class Solution: def hIndex(self, citations): if len(citations)==1: if citations[0]==1: return 1 if citations[0]==0: return 0 citations.sort(reverse=-1) h=0 for i i.

第一次做多线程的题目，以前学过的操作系统好多知识都忘记了，题解描述的很详细，可以用锁或者信号量来实现。不同编程语言实现的方法不同，python用到的是threading库，c++中用到的是semaphore.h这个库#include<semaphore.h>class Foo {protected: sem_t firstJobDone; sem_t secondJobDone; public: Foo() { sem_init(&a.

class Solution: def thirdMax(self, nums: List[int]) -> int: nums.sort(reverse=True) juge = 1 for i in range(1, len(nums)): if nums[i] != nums[i - 1]: juge += 1 if juge == 3: .

class Solution: def majorityElement(self, nums: List[int]) -> int: ans=0 a=set(nums) for i in a: if nums.count(i)>(len(nums)/2): ans=i return ans

简单题，双指针就好class Solution: def findContinuousSequence(self, target: int): ans = [] i = 1 j = 2 while (j <= target): num=int((i + j) * (j - i + 1) / 2) if num == target: ans.appe.

这道题一开始又又又又超时了，我迭代到num/2，这样是超时的。然后看了题解，发现确实，有一个小的就会存在一个大的，这样只要解决n**2=num的特殊情况，就可以只迭代到sqrt(num)了class Solution: def checkPerfectNumber(self, num: int) -> bool: if num<=1: return False temp=1 min_num=2 .

这道题看着挺简单，但是一写就超时了，想了一下，主要耗时在计算质数上，如果用枚举法去判断一个数是不是质数，肯定就会超时。迭代一遍的写法应该是：class Solution: def countPrimes(self, n: int) -> int: if n < 3: return 0 else: # 首先生成了一个全部为1的列表 output = [1] * n .