159.库存管理(TOPk问题!)

本文介绍了两种方法实现库存管理,一种是基于快速排序的分块思想,另一种是利用优先级队列。两种算法都旨在找到并返回前k个最小的元素。

思路:也是tok的问题,与上篇博客思路一样,只不过是求前k个小的元素!

基于快排分块思路的代码如下:

class Solution {
public:
    int getkey(vector<int>&nums,int left,int right)
    {
        int r=rand();
        return nums[r%(right-left+1)+left];
    }
    void qsort(vector<int>&nums,int left,int right,int k)
    {
        if(left>=right ) return ;
        vector<int>ret(k);
        int l=-1,r=right+1;
        int i=0;
        int key=getkey(nums,left,right);
        while(i<r)
        {
            if(nums[i]<key)
            {
                swap(nums[++l],nums[i++]);
            }
            else if(nums[i]>key)
            {
                swap(nums[--r],nums[i]);
            }
            else
            {
                i++;
            }
        }

        int a=l-left+1;
        int b=r-l-1;
        int c=right-r+1;

        if(a>=k)
        {
            return qsort(nums,left,l,k);
        }
        else if(a+b>=k)
        {
            return ;
        }
        else
        {
            return qsort(nums,r,right,k-a-b);
        }
        return ;
    }

    vector<int> inventoryManagement(vector<int>& stock, int cnt) 
    {
        int n=stock.size();
        qsort(stock,0,n-1,cnt);
        return {stock.begin(),stock.begin()+cnt};
    }
};

 优先级队列代码:

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt)
    {
        vector<int>ret(cnt);
        priority_queue<int,vector<int>,greater<int>>q;
        for(auto ch:stock)
        {
            q.push(ch);
        }
        for(int i=0;i<cnt;i++)
        {
            ret[i]=q.top();
            q.pop();
        }       
        return ret;
    }
};

### 关于蓝桥杯比赛中的商品库存管理 在蓝桥杯比赛中,涉及商品库存管理的题目通常会考察参赛者对于数据结构算法的理解能力以及实际应用的能力。这类问题可能涉及到数组、链表、哈希表等基础数据结构的应用,同时也可能会结合动态规划或者贪心算法来解决优化类的问题。 #### 数据结构的选择 针对商品库存管理这一场景,可以选择合适的数据结构以提高程序效率。例如,在处理频繁的商品出入库操作时,可以考虑使用双向链表配合哈希表的方式实现快速查询与更新功能[^2]: ```python class InventoryItem: def __init__(self, product_id, quantity): self.product_id = product_id self.quantity = quantity self.prev = None self.next = None class InventoryManager: def __init__(self): self.head = None self.tail = None self.lookup_table = {} def add_item(self, product_id, quantity): new_item = InventoryItem(product_id, quantity) if not self.head: self.head = self.tail = new_item else: self.tail.next = new_item new_item.prev = self.tail self.tail = new_item self.lookup_table[product_id] = new_item def update_quantity(self, product_id, delta): item = self.lookup_table.get(product_id) if item is not None: item.quantity += delta ``` 上述代码展示了如何通过自定义节点类 `InventoryItem` 和管理者类 `InventoryManager` 来维护一个简单的商品库存管理系统[^3]。 #### 贪心算法的应用 当面临诸如最小化成本或最大化利润等问题时,贪心策略往往能提供一种高效求解方法。假设有一道题要求合理分配有限资源给多个仓库以便满足最大需求,则可以通过优先级队列(堆)来进行调度[^4]: ```cpp #include <queue> #include <vector> using namespace std; int maxSatisfaction(vector<int>& demands, int totalSupply){ priority_queue<int> pq; for(auto d : demands)pq.push(d); long sum=0,res=0; while(!pq.empty() && (sum + pq.top())*totalSupply >=0 ){ sum+=pq.top();pq.pop(); res=max(res,sum*totalSupply--); } return res; } ``` 此C++片段实现了基于贪婪思想的最大满意度计算函数[^5]。 #### 动态规划思路 如果遇到需要寻找最优子序列的情况,比如连续时间段内的最佳补货计划,那么动态规划可能是更好的选择。下面是一个简化版的例子说明如何利用DP表格记录状态转移过程并最终得出全局最优解[^6]: ```java public class OptimalRestocking { public static int optimalPlan(int[] prices,int k){ int n =prices.length; int[][] dp=new int[n][k+1]; for(int i=0;i<n;i++) Arrays.fill(dp[i],Integer.MIN_VALUE); for(int j=0;j<=k;j++)dp[0][j]=0; for(int i=1;i<n;i++) for(int j=1;j<=Math.min(i,k);j++){ dp[i][j]=Math.max(dp[i-1][j],dp[t][j-1]+prices[i]-prices[t]); } return dp[n-1][k]; } } ``` 以上Java代码段展示了一个用于确定最多允许交易次数下的最高收益模型[^7]。
评论 27
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值