LeetCode每日一题： 3145 大数组元素的乘积

Car_Dingding

已于 2024-08-23 10:57:50 修改

阅读量516

点赞数 9

分类专栏： LeetCode每日一题文章标签： leetcode 算法数据结构

于 2024-08-23 10:50:24 首次发布

本文链接：https://blog.csdn.net/weixin_66250702/article/details/141449956

版权

LeetCode每日一题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

题目

一个非负整数 x 的 强数组 指的是满足元素为 2 的幂且元素总和为 x 的最短有序数组。下表说明了如何确定 强数组 的示例。可以证明，x 对应的强数组是独一无二的。

数字二进制表示强数组
1 00001 [1]
8 01000 [8]
10 01010 [2, 8]
13 01101 [1, 4, 8]
23 10111 [1, 2, 4, 16]

我们将每一个升序的正整数 i （即1，2，3等等）的 强数组 连接得到数组 big_nums ，big_nums 开始部分为 [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...] 。

给你一个二维整数数组 queries ，其中 queries[i] = [fromi, toi, modi] ，你需要计算 (big_nums[fromi] * big_nums[fromi + 1] * ... * big_nums[toi]) % modi 。

请你返回一个整数数组 answer ，其中 answer[i] 是第 i 个查询的答案。

示例 1：

输入：queries = [[1,3,7]]

输出：[4]

解释：

只有一个查询。

big_nums[1..3] = [2,1,2] 。它们的乘积为 4。结果为 4 % 7 = 4。

示例 2：

输入：queries = [[2,5,3],[7,7,4]]

输出：[2,2]

解释：

有两个查询。

第一个查询：big_nums[2..5] = [1,2,4,1] 。它们的乘积为 8 。结果为 8 % 3 = 2。

第二个查询：big_nums[7] = 2 。结果为 2 % 4 = 2。

提示：

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 1015
1 <= queries[i][2] <= 105

数字	二进制表示	强数组
1	00001	[1]
8	01000	[8]
10	01010	[2, 8]
13	01101	[1, 4, 8]
23	10111	[1, 2, 4, 16]

思路与代码

又是二进制的位运算的题，题是好读了，强度又上来了，构建这个big_nums好说，重要的是要如何快速定位到切片范围，然后去做累乘（从0开始一个一个big_nums.extend(f(n)) 包超时的)。

定位的话二分查找就行，子问题就转化成了昨天3007中的问题，详情参考昨天的每日一题（其实就是昨天问题里x=1的特例）：LeetCode每日一题：3007 价值小于等于K的最大数字累乘的话big_nums里面全都是2的倍数，矩阵快速幂直接开撕。

现在剩下的问题就是处理边界问题了，这里已经可以找到比from小的数和to大的数，所以快速幂的结果只要处理这里面的左边多出来和右边多出来的就行，计算多的位数以及多出来的位与运算就可以结果。现在就可以写代码了。

首先找n之前位置带1的个数，以及1所在位的总和（用来作为指数），这里代码的说明在昨天的文章里LeetCode每日一题：3007 价值小于等于K的最大数字

# 昨天的代码
def countBits(self, n):
    cnt=0
    for i in range(1,n.bit_length()+1):
        pre=((n+1)>>i) *(1<<i-1)
        sub=(n+1) % (1<<i) ^ (1<<i-1)
        sub=0 if sub>=(1<<i-1) else sub
        cnt+=(pre+sub)
    return cnt


# 这里只要多乘一个位数就行
def countEachBit(self, n):
    cnt=0
    for i in range(1,n.bit_length()+1):
        pre=((n+1)>>i) *(1<<i-1) *(i-1)
        sub=(n+1) % (1<<i) ^ (1<<i-1)
        sub=0 if sub>=(1<<i-1) else sub
        sub*=(i-1)
        cnt+=(pre+sub)
    return cnt

之后就是如何处理边界上多出来的位数，经典的位与运算问题

def countLastNum(self, num, bits):
    count = 0
    bit = 1
    i=0
    while(bits!=0):
        if (num & bit) != 0:
            count += i
            bits -= 1
        bit <<= 1
        i+=1
    return count

二分定位和快速幂代码如下

# 二分定位
def f_num(self, index):
    count = index + 1
    low = 1
    high = count
    last = 0
    while low <= high:
        mid = (low + high) // 2
        if self.countBits(mid) >= count:
            last = mid
            high = mid - 1
        else:
            low = mid + 1
    return last

# 快速幂
def fastPower(self, x, n, mod):
    ans = 1
    while n > 0:
        if n & 1:
            ans = ans * x % mod
        x = x * x % mod
        n >>= 1
    return ans % mod

最后分别计算queries里面提供的每个slice即可，全部代码如下

class Solution:
    def findProductsOfElements(self, queries: List[List[int]]) -> List[int]:
        size = len(queries)
        ans = [0] * size
        for i in range(size):
            from_val, to_val, mod = queries[i]
            last = self.f_num(to_val)
            count = self.countEachBit(last - 1) + self.countLastNum(last, to_val + 1 - self.countBits(last - 1))
            if from_val != 0:
                last = self.f_num(from_val - 1)
                count -= (self.countEachBit(last - 1) + self.countLastNum(last, from_val - self.countBits(last - 1)))
            ans[i] = self.fastPower(2, count, mod)
        return ans

    def countBits(self, n):
        cnt=0
        for i in range(1,n.bit_length()+1):
            pre=((n+1)>>i) *(1<<i-1)
            sub=(n+1) % (1<<i) ^ (1<<i-1)
            sub=0 if sub>=(1<<i-1) else sub
            cnt+=(pre+sub)
        return cnt


    def countEachBit(self, n):
        cnt=0
        for i in range(1,n.bit_length()+1):
            pre=((n+1)>>i) *(1<<i-1) *(i-1)
            sub=(n+1) % (1<<i) ^ (1<<i-1)
            sub=0 if sub>=(1<<i-1) else sub
            sub*=(i-1)
            cnt+=(pre+sub)
        return cnt

    def countLastNum(self, num, bits):
        count = 0
        bit = 1
        i=0
        while(bits!=0):
            if (num & bit) != 0:
                count += i
                bits -= 1
            bit <<= 1
            i+=1
        return count

    def f_num(self, index):
        count = index + 1
        low = 1
        high = count
        last = 0
        while low <= high:
            mid = (low + high) // 2
            if self.countBits(mid) >= count:
                last = mid
                high = mid - 1
            else:
                low = mid + 1
        return last

    def fastPower(self, x, n, mod):
        ans = 1
        while n > 0:
            if n & 1:
                ans = ans * x % mod
            x = x * x % mod
            n >>= 1
        return ans % mod

总结

每日一题难度一点点上来了，今天的题里在昨天的基础上加了一个矩阵快速幂，除了这种简单的二进制位运算之外，一些递推问题如果能写出来递推公式的话也可以很快解决这些问题(O(LogN)) 的复杂度确实要吊一点。

大概半个月的时间吧，从最开始的算法时间空间复杂度分析，到重新捡起来线性表、树这些知识；这几天的状态似乎是一样的。题一下子无从下手，点一盏台灯，泡一杯雀巢，写写画画，好不容易有了思路，码好代码之后又要花很长时间去检查一些很小很小的错误（比如边界条件，<写出<=进去死循环，但你没注意到只能一遍一遍去验证）。但在这个过程中我也惊讶的发现，我竟然能够不知疲倦的对着屏幕一遍一遍过这些代码，才算是体会到了英雄哥“夜深人静写算法”的魅力。我想这段时间的经历除了带给我算法能力的提升外，更珍贵的东西是他让我自己的内心变得更加强大了。几个小时前看到一些不太好的结果心里并没有什么波澜，就像是点击运行然后样例报错的那样。生活中所能遇到的难以解决的问题，只要你能意识到他的存在，你一定有办法解决的。我想在之后的生活中（至少在大四上学期这个尴尬的时间里），无论遇到什么麻烦，那些躺在题库里AC的题，都会成为支持我挺过去的一股力量。

因为某些原因，2024年可能就没机会接着刷题搞算法这些了。之后可能会分享一点和遥感地信专业课相关的笔记心得。就这样吧，再见！