力扣笔记.

难度简单35收藏分享切换为英文接收动态反馈

小扣在秋日市集选择了一家早餐摊位，一维整型数组 staple 中记录了每种主食的价格，一维整型数组 drinks 中记录了每种饮料的价格。小扣的计划选择一份主食和一款饮料，且花费不超过 x 元。请返回小扣共有多少种购买方案。

注意：答案需要以 1e9 + 7 (1000000007) 为底取模，如：计算初始结果为：1000000008，请返回 1

示例 1：

输入：staple = [10,20,5], drinks = [5,5,2], x = 15

输出：6

解释：小扣有 6 种购买方案，所选主食与所选饮料在数组中对应的下标分别是：
第 1 种方案：staple[0] + drinks[0] = 10 + 5 = 15；
第 2 种方案：staple[0] + drinks[1] = 10 + 5 = 15；
第 3 种方案：staple[0] + drinks[2] = 10 + 2 = 12；
第 4 种方案：staple[2] + drinks[0] = 5 + 5 = 10；
第 5 种方案：staple[2] + drinks[1] = 5 + 5 = 10；
第 6 种方案：staple[2] + drinks[2] = 5 + 2 = 7。

staple = [2,1,1]
drinks = [8,9,5,1]
x = 9

count = 0
arr = [0 for i in range(x+1)] # 辅助数组，记录所能购买的主食，省去排序
for i in staple:
    if i<x:
        arr[i] += 1 # arr[2] = 2 代表价格为2的主食有两种
for j in range(2, x): # 将价格小于 j 的主食个数累加，存入arr。arr[5] = 6;代表金钱为5时，能买六种主食
    arr[j] += arr[j-1]

for k in drinks:
    if k<x:
        remain = x - k # 购买drink之后的剩余金钱数
        count += arr[remain]
count = count % (10**9 + 7) # 题目要求，在可能性很多的时候，将结果对1e9+7取模
print(count)

1004. 最大连续1的个数 III

给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。

返回仅包含 1 的最长（连续）子数组的长度。

示例 1：

输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

解题思路

重点：题意转换。把「最多可以把 K 个 0 变成 1，求仅包含 1 的最长子数组的长度」转换为「找出一个最长的子数组，该子数组内最多允许有 K 个 0 」。

代码思路：

使用 leftleft 和 rightright 两个指针，分别指向滑动窗口的左右边界。
rightright 主动右移：rightright 指针每次移动一步。当 A[right]A[right] 为 00，说明滑动窗口内增加了一个 00；
leftleft 被动右移：判断此时窗口内 00 的个数，如果超过了 KK，则 leftleft 指针被迫右移，直至窗口内的 00 的个数小于等于 KK 为止。
滑动窗口长度的最大值就是所求。

转自：（内有执行动图）https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/fen-xiang-hua-dong-chuang-kou-mo-ban-mia-f76z/

A = [1,1,1,0,0,0,1,1,1,1,0]
K = 2
def longestOnes1(A, K):
    N = len(A)
    res, zeros = 0, 0
    right, left = 0, 0
    while right < N:
        if A[right] == 0:
            zeros += 1
        while zeros > K:
            if A[left] == 0:
                zeros -= 1
            left += 1
        res = max(res, right-left+1)
        right +=1
    print(res)
longestOnes1(A, K)


#转自大佬

def findSubArray(nums):
    N = len(nums) # 数组/字符串长度
    left, right = 0, 0 # 双指针，表示当前遍历的区间[left, right]，闭区间
    sums = 0 # 用于统计 子数组/子区间 是否有效，根据题目可能会改成求和/计数
    res = 0 # 保存最大的满足题目要求的 子数组/子串 长度
    while right < N: # 当右边的指针没有搜索到 数组/字符串 的结尾
        sums += nums[right] # 增加当前右边指针的数字/字符的求和/计数
        while 区间[left, right]不符合题意：# 此时需要一直移动左指针，直至找到一个符合题意的区间
            sums -= nums[left] # 移动左指针前需要从counter中减少left位置字符的求和/计数
            left += 1 # 真正的移动左指针，注意不能跟上面一行代码写反
        # 到 while 结束时，我们找到了一个符合题意要求的 子数组/子串
        res = max(res, right - left + 1) # 需要更新结果
        right += 1 # 移动右指针，去探索新的区间
    return res

作者：fuxuemingzhu
链接：https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/fen-xiang-hua-dong-chuang-kou-mo-ban-mia-f76z/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

作者：fuxuemingzhu
链接：https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/fen-xiang-hua-dong-chuang-kou-mo-ban-mia-f76z/
链接：https://leetcode-cn.com/problems/max-consecutive-ones-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

python建立hashmap的方法：

def twoSum(nums, target):
    hashmap={}
    for i,num in enumerate(nums):
        if hashmap.get(target - num) is not None:
            return [i,hashmap.get(target - num)]
        hashmap[num] = i #这句不能放在if语句之前，解决list中有重复值或target-num=num的情况

作者：lao-la-rou-yue-jiao-yue-xiang
链接：https://leetcode-cn.com/problems/two-sum/solution/xiao-bai-pythonji-chong-jie-fa-by-lao-la-rou-yue-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1047. 删除字符串中的所有相邻重复项

Python 简易栈

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def removeDuplicates(S):
    last = 0
    tool_list = []
    for i,w in enumerate(S):
#         print(last ,i, w)
        if last ==-1: # 栈为空时，若有入栈元素直接入栈，last++
            tool_list.append(w)
            last +=1
            continue
        if i==0: # 第一个元素直接入栈
            tool_list.append(S[i])
            continue
        elif tool_list[last] != w: # 栈顶元素与入栈元素不同，入栈，last++
            tool_list.append(w)
            last = last + 1
        else: # 栈顶元素与入栈元素相同，出栈，last--
            tool_list.pop(last)
            last = last - 1
    return(''.join(tool_list))

9. 回文数

不转换为字符串方法

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        temp = x
        flag = 1
        tmp = True
        while temp>=10:
            temp /= 10
            flag += 1
        print(flag)
        if x < 0:
            return False
        for i in range(1,int(flag/2)+1):
#             print(i)
            if int(x/10**(flag-i))%10 != int(x%(10**i)/10**(i-1)):
                print (int(x%(10**i)/10))
                return False
        return True

猜你喜欢