leetcode之下载插件(这个运行结果有点瘆人~)

题目描述

小扣打算给自己的 VS code 安装使用插件，初始状态下带宽每分钟可以完成 1 个插件的下载。假定每分钟选择以下两种策略之一:

使用当前带宽下载插件
将带宽加倍（下载插件数量随之加倍）
请返回小扣完成下载 n 个插件最少需要多少分钟。

注意：实际的下载的插件数量可以超过 n 个

示例 1：

输入：n = 2

输出：2

解释：
以下两个方案，都能实现 2 分钟内下载 2 个插件

方案一：第一分钟带宽加倍，带宽可每分钟下载 2 个插件；第二分钟下载 2 个插件
方案二：第一分钟下载 1 个插件，第二分钟下载 1 个插件
示例 2：

输入：n = 4

输出：3

解释：
最少需要 3 分钟可完成 4 个插件的下载，以下是其中一种方案:
第一分钟带宽加倍，带宽可每分钟下载 2 个插件;
第二分钟下载 2 个插件;
第三分钟下载 2 个插件。

提示：

1 <= n <= 10^5

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

思路

一开始的我想着利用dp的思路来解，但是想了半天没有结果，于是就只好暴力求解了，根据题目描述可知，对于每一步，我们都有两个选择：1.选择宽带加倍 2.不选择宽带加倍， 因此，我就想到了建立一颗对应的二叉树，树中每一个节点都保存当前的下载量和宽带，然后层次遍历这一颗树，直到找到下载量大于n的那个节点，此时这个节点的深度就是最少所需时间。

源码

class Node:
    def __init__(self, l=None, r=None, speed=None, val=None):
        self.l = l
        self.r = r
        self.speed = speed
        self.val = val


from collections import deque


class Solution:
    def leastMinutes(self, n: int) -> int:
        if n == 1: return 1
        root = Node()
        root.l = Node(None, None, 2, 0)  # 左孩子选择宽带加倍
        root.r = Node(None, None, 1, 1)  # 右孩子选择直接下载

        que = deque()
        que.append(root.l)
        que.append(root.r)
        N = 1
        '''
        #层次遍历解法
        
        1.将root的左右两个孩子加入队列
        2.依次取出队列中的节点(同时用一个临时列表来保存这些节点)，然后根据这个节点的speed(带宽)和val(下载量)建立新的节点(就是它的左右孩子)
            如果新节点的val>=n 那么就退出循环(出口)
            否则将其添加为孩子节点
        3.遍历那个临时列表，将它们的孩子节点加入队列
        '''

        while True:
            node_tmp = []
            flag = 0

            # 依次取从队列取节点
            while len(que) > 0:
                cur_node = que.popleft()
                node_tmp.append(cur_node)
                new_l_val = cur_node.val
                if new_l_val >= n:
                    flag = 1
                    N += 1
                    break
                else:
                    new_l_speed = cur_node.speed * 2  # 左孩子宽带加倍，下载量不增加
                    cur_node.l = Node(None, None, new_l_speed, new_l_val)

                new_r_val = cur_node.val + cur_node.speed
                if new_r_val >= n:
                    flag = 1
                    N += 1
                    break
                else:
                    new_r_speed = cur_node.speed  # 右孩子宽带不增加，但下载量增加
                    cur_node.r = Node(None, None, new_r_speed, new_r_val)

            if flag:  # 循环的出口
                break
            else:
                N += 1
            # 添加临时列表中的孩子节点到队列中
            while node_tmp:
                node = node_tmp.pop()
                if node.l: que.append(node.l)
                if node.r: que.append(node.r)
        return N


if __name__ == '__main__':
    n = 2
    print(Solution().leastMinutes(n))

运行通过截图

很显然，这种解题方法不管是时间复杂度（2^n）还是空间复杂度(2^n)都非常的高,运行的结果也可想而知，居然通过了！真是万幸哈哈哈哈，不过这个执行时间和内存消耗看着真是吓人！看题解去了~

 

 同步更新于个人博客系统：leetcode之下载插件(这个运行结果有点瘆人~)