算法学习1

String vs Array

已于 2022-04-25 20:01:29 修改

阅读量416

点赞数 1

文章标签：算法

于 2022-04-25 20:00:54 首次发布

本文链接：https://blog.csdn.net/SStringss/article/details/124413002

版权

本文介绍了动态规划和优先队列（堆）在解决计算机科学问题中的应用，如背包问题和分割等和子集。通过递归遍历和字典记录状态优化算法，但仍然面临时间复杂度问题。动态规划的0-1背包问题通过状态转移方程降低复杂度，而优先队列（堆）用于实现高效插入和删除操作。文章提供了大根堆的实现，并举例说明其在处理最接近原点的K个点问题中的作用。

摘要由CSDN通过智能技术生成

因为周五的时候收到了周日要笔试的消息，So, 上牛客刷了刷题，然后都不会~~（阿哲）~~ 。反正这两天就是疯狂刷题适应OJ, 我估计笔试五道变成应该能写出两道（泪目），所以被迫更新一下算法.（好的结果是AC 2.6/5, 太拉了，，)

背包问题

问题：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。

很明显这玩应绝壁不可能是贪心算法~~(要是贪心算法该有多好，呜呜呜)~~。那么我作为一个最小白的普通人，肯定最先想到的就是递归遍历，找最大值

import copy
# 用例
bag_size = 5
put_value = [2,4,4,5]
put_size = [1,2,3,4]
put_size_with_loca = []
for i in range(len(put_size)):
    put_size_with_loca.append((put_value[i],put_size[i]))
    
# 对于0,1背包问题的遍历
def dfs(space_, put):
    value_all = []
    for size_xiaohao in put:
        if space_ < size_xiaohao[1]:
            value_all.append(0)
        else:
            put_new = copy.deepcopy(put)
            put_new.remove(size_xiaohao)
            value_all.append(size_xiaohao[0] + dfs(space_ - size_xiaohao[1], put_new))
    return max(value_all)
dfs(bag_size, put_size_with_loca)

这个时间复杂度怎么说呢，假设背包size = m , 物品大小的均值 = n

时间复杂度就是： O((m / n)!) m/n 的阶乘，时间复杂度高的一批，但是我们使用的是枚举所以对0，1背包还是0,n 背包亦或者是填充满背包都可以用的

一道例题：416. 分割等和子集

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 分割成两个自己换句话说就就是分割出和为1/2 的背包
        sum_ = sum(nums)
        if sum_ % 2 != 0:
            return False
        def dfs(value_sum,list_shengyu):
            for p in list_shengyu:
                if p + value_sum == (sum_ // 2):
                    return True
                elif p + value_sum < sum_ // 2:
                    list_new = copy.deepcopy(list_shengyu)
                    list_new.remove(p)
                    k = dfs(value_sum + p, list_new)
                    if k == True:
                        return True
            return False
        return dfs(0, nums)
# 直接运行会在第33个用例超时

# 继续优化，使用字典记录状态信息
# 拿字典记录状态
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 分割成两个自己换句话说就就是分割出和为1/2 的背包
        sum_ = sum(nums)
        if sum_ % 2 != 0:
            return False
        # 拿字典记录状态, 放置重复的false多次继续遍历。True不需要记录，有True直接就返回了
        dict_ = dict()
        def dfs(value_sum,list_shengyu):
            if dict_.get(value_sum) == 1:
                return False
            for p in list_shengyu:
                if p + value_sum == (sum_ // 2):
                    return True
                elif p + value_sum < sum_ // 2:
                    list_new = copy.deepcopy(list_shengyu)
                    list_new.remove(p)
                    k = dfs(value_sum + p, list_new)
                    if k == True:
                        return True
            dict_[value_sum] = 1
            return False
        return dfs(0, nums)

然后在第37个用例超时，，，所以说这种方法时间复杂度上已经报废了。

OK我们言归正传，那么背包算法是什么样子的呢？https://www.cnblogs.com/jbelial/articles/2116074.html

首先是0，1 背包：

我们对于每种物品，都有选和不选两种选则。当然我们不可能遍历每一种选和不选，这样时间复杂度就是 O(2 ** len(object) ), 这个时间复杂度更可怕，我们选或者不选是根据选择此物品所能带来的贡献的大小来决定的。换言之，如何表示贡献，也就是我们列出动态规划解析式的关键.

动态规划么，子问题缩减 + 递归遍历，我们可以定义出如下的方程 ~~（怎么有种在做奥数的感觉）~~

f[i][s] 代表前i件物品放入容量为s的背包可以获得的最大价值 ，w[i]表示物品i的占用的容量， v[i] 表示物体i的价值。

其状态转移方程就是：f[i][s] = max( f[i-1][s], f[i - 1][s - w[i]] + v[i] ）

如果要是叫我们来列状态转移方程的话，我多半会变化s, 但是变化s之后的max又不好表示，换句话说要考虑所有的w[i] ，然后就陷入死循环了，，

说实话，看到这个方程的时候我是蒙蔽的，是真的蒙蔽的状态。而这玩应又不好用语言来表示，读者们加加油吧

bag_size = 20
put_value = [2,4,4,5,13,7,3,8,1,9,5,2,6,4]
put_size = [1,2,3,4,3,8,6,9,10,3,8,7,5,14]
count_ = 0
dict_ = {}
def dfs(i,s):
    global count_
    count_ += 1
    if dict_.get(str((i,s))):
        return dict_.get(str((i,s)))
    if i == 0 or s == 0:
        dict_[str((i,s))] = 0
        return 0
    else:
        k = dfs(i-1,s)
        if s > put_size[i]:
            dict_[str((i,s))] =  max(k,  dfs(i - 1, s - put_size[i]) + put_value[i])
            return dict_[str((i,s))]
        else:
            dict_[str((i,s))] =  k
            count_ += 1
            return dict_[str((i,s))]

对于物品多样甚至无限的情况下，我们新的状态方gai程就是： max( f[i-1][s], f[i - 1][s - w[i] * k] + v[i] * k )) , k的取值也很好找： min( 物品i数量， s // w[i] )这样我们的递归就能实现多重甚至无线的情况

至于恰好装满的情况：

我们在i == 0 and s != 0的情况下返回一个 -FFFFFFFFFFF 这样的界限值放置这种情况拿到最大值就可以了。

优先队列，大根堆，小根堆

堆是一种偏序的完全二叉树，其中大根堆和小根堆是我们常用的两种数据类型，分别是代表：父节点的值小于或等于子节点的值、父节点的值大于或等于子节点的值：

作用呢，就是是实现 O(logn) 时间复杂度的插入删除。由于是一颗完全二叉树，我们通常就不直接构造树了，而是直接使用list存储即可。根据完全二叉树的特性 + 数组从0开始， index_parent = (index_son - 1) // 2 (向下取整)

push, 直接在最后一位增加，从下到上调整

pop,将最后一位与第零位互换，然后从上到下调整

class heap_big:
    def __init__(self,list_):
        self.list_ = list_
        self.size = len(self.list_)
        
#   从下往上的swap, 初始化和push的时候用
    def swap_(self, now):
        if now == 0:
            return None
        if self.list_[(now-1)//2] <  self.list_[now]:
            a = self.list_[now]
            self.list_[now] = self.list_[(now-1)//2]
            self.list_[(now-1)//2] = a
            self.swap_((now-1)//2)

# 从上向下的swap, pop的时候用
    def swap_2(self, now):
        if (now*2 + 1) < self.size:
            if self.list_[now] < self.list_[(now*2 + 1)]:
                a = self.list_[now]
                self.list_[now] = self.list_[(now*2 + 1)]
                self.list_[(now*2 + 1)] = a
                self.swap_2(now*2 + 1)
        if (now*2 + 2) < self.size:
            if self.list_[now] < self.list_[(now*2 + 2)]:
                a = self.list_[now]
                self.list_[now] = self.list_[(now*2 + 2)]
                self.list_[(now*2 + 2)] = a
                self.swap_2(now*2 + 2)
                
# 初识堆顺序化，讲道理这个可以直接sort()没问题
    def init_heap(self):
        n = 0
        # 这个初始化，就我查到的算法都至少需要nlog(n)的时间,所以我也就nlog(n)
        for i in range(self.size - 1, 0,-1):
            self.swap_(i)
# 向堆中压入数据
    def push(self,val):
        self.size += 1
        self.list_.append(val)
        self.swap_(self.size - 1)
# 弹出堆首数据
    def pop(self):
        k = self.list_[0]
        self.list_[0] = self.list_[-1]
        self.list_ = self.list_[:-1]
        self.size -= 1
        self.swap_2(0)
        return k
# 这个是大根堆， 把所有的> 和 < 取反就是小根堆。