B. Bin Packing Problem

已于 2022-04-27 13:11:22 修改
阅读量291 收藏
点赞数
分类专栏： 笔记 文章标签： c++
于 2022-04-27 12:48:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51262775/article/details/124448385
版权

B. Bin Packing Problem

1.无旋treap写法：

以下代码会在第六个点TLE，估计是常数比较大！

#pragma GCC optimize("Ofast","inline")

#include<bits/stdc++.h>
using namespace std;

template<class T>void read(T& x)
{
    x=0;int f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
    x*=f;
}//快读

template<class T>void write(T& x)
{
    int num=0;char c[40];
    while(x)c[++num]=(x%10)+48,x/=10;
    while(num)putchar(c[num--]);
}//快写

const int N=2e6+10;
const int INF=1e9+10;

mt19937 rnd(time(0));

struct Node
{
    int l, r,size;
    int key, pos,mn;
    unsigned int val;
    
}tr[N];
 
int root, tot, rt1, rt2, rt3;
int New(int key, int pos)
{
    int id = ++tot;
    tr[id].l=tr[id].r=0;
    tr[id].size = 1;
    tr[id].key = key;
    tr[id].pos = tr[id].mn = pos;
    tr[id].val = rnd();
    return id;
}
 
void pushup(int p)
{
    tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + 1;
    tr[p].mn = min(tr[p].pos, min(tr[tr[p].l].mn, tr[tr[p].r].mn));
}
void split(int now,int k,int &x,int &y)
{
    if (!now)x = y = 0;
    else {
        if (tr[now].key <= k)
            x = now, split(tr[now].r, k, tr[now].r, y);
        else y = now, split(tr[now].l, k, x, tr[now].l);
        pushup(now);
    }
}
int merge(int x, int y)
{
    if (!x || !y)return x + y;
    if (tr[x].val > tr[y].val)
    {
        tr[x].r = merge(tr[x].r, y);
        pushup(x);
        return x;
    }
    else
    {
        tr[y].l = merge(x, tr[y].l);
        pushup(y);
        return y;
    }
}

void insert(int x, int pos)
{
    split(root, x, rt1, rt2);
    rt1 = merge(rt1 , New(x , pos));
    root = merge(rt1, rt2);
}
pair<int,int> erase(int &now,int mn)
{
    pair<int, int>ans;
    if (tr[now].pos == mn)
    {
        ans = { tr[now].key,tr[now].pos };
        now = merge(tr[now].l, tr[now].r);
        return ans;
    }
    if (tr[tr[now].l].mn == mn)ans = erase(tr[now].l, mn);
    else ans = erase(tr[now].r, mn);
    pushup(now);
    return ans;
}
pair<int, int> erase(int& now)
{
    pair<int, int>ans;
    if (!tr[now].l)
    {
        ans = { tr[now].key,tr[now].pos };
        now = merge(tr[now].l, tr[now].r);
        return ans;
    }
    ans = erase(tr[now].l);
    pushup(now);
    return ans;
}


int a[N];
 
void solve()
{
    int n, c;
    read(n), read(c);
 
    tr[0] = { 0,0,0,0,INF,INF,rnd() };
    for (int i = 1;i <= n;++i)tr[i] = { 0,0,0,0,0,0,0 };
    root = tot = 0;
    
    int ans = 0;
    for (int i = 1;i <= n;++i)
    {
        read(a[i]);
 
        split(root, a[i] - 1, rt1, rt2);
        
        if (!rt2)
        {
            root = merge(rt1, rt2);
            ++ans;
            int r = c - a[i];
            insert(r, ans);
        }
        else {
            pair<int, int>now = erase(rt2, tr[rt2].mn);
            root = merge(rt1, rt2);
            insert(now.first - a[i], now.second);
        }
    }
    write(ans);putchar(' ');

    for (int i = 1;i <= n;++i)tr[i] = { 0,0,0,0,0,0,0 };
    root = tot = 0;

    ans = 0;
    for (int i = 1;i <= n;++i)
    {
        split(root, a[i] - 1, rt1, rt2);

        if (!rt2)
        {
            root = merge(rt1, rt2);
            ++ans;
            int r = c - a[i];
            insert(r, ans);
        }
        else
        {
            pair<int, int>now = erase(rt2);
            root = merge(rt1, rt2);
            insert(now.first - a[i], now.second);
        }
    }

    write(ans);putchar('\n');
}

int main()
{
    int T;
    read(T);
    while (T--) {
        solve();
    }
    return 0;
}

2.将第二部分换成map后在第八个点TLE，无旋treap常数这么大吗，有点出乎意料······

#pragma GCC optimize("Ofast","inline")

#include<bits/stdc++.h>
using namespace std;

template<class T>void read(T& x)
{
    x=0;int f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
    x*=f;
}//快读

template<class T>void write(T& x)
{
    int num=0;char c[40];
    while(x)c[++num]=(x%10)+48,x/=10;
    while(num)putchar(c[num--]);
}//快写

const int N=2e6+10;
const int INF=1e9+10;

mt19937 rnd(time(0));

struct Node
{
    int l, r,size;
    int key, pos,mn;
    unsigned int val;
    
}tr[N];
 
int root, tot, rt1, rt2, rt3;
int New(int key, int pos)
{
    int id = ++tot;
    tr[id].l=tr[id].r=0;
    tr[id].size = 1;
    tr[id].key = key;
    tr[id].pos = tr[id].mn = pos;
    tr[id].val = rnd();
    return id;
}
 
void pushup(int p)
{
    tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + 1;
    tr[p].mn = min(tr[p].pos, min(tr[tr[p].l].mn, tr[tr[p].r].mn));
}
void split(int now,int k,int &x,int &y)
{
    if (!now)x = y = 0;
    else {
        if (tr[now].key <= k)
            x = now, split(tr[now].r, k, tr[now].r, y);
        else y = now, split(tr[now].l, k, x, tr[now].l);
        pushup(now);
    }
}
int merge(int x, int y)
{
    if (!x || !y)return x + y;
    if (tr[x].val > tr[y].val)
    {
        tr[x].r = merge(tr[x].r, y);
        pushup(x);
        return x;
    }
    else
    {
        tr[y].l = merge(x, tr[y].l);
        pushup(y);
        return y;
    }
}

void insert(int x, int pos)
{
    split(root, x, rt1, rt2);
    rt1 = merge(rt1 , New(x , pos));
    root = merge(rt1, rt2);
}
pair<int,int> erase(int &now,int mn)
{
    pair<int, int>ans;
    if (tr[now].pos == mn)
    {
        ans = { tr[now].key,tr[now].pos };
        now = merge(tr[now].l, tr[now].r);
        return ans;
    }
    if (tr[tr[now].l].mn == mn)ans = erase(tr[now].l, mn);
    else ans = erase(tr[now].r, mn);
    pushup(now);
    return ans;
}
pair<int, int> erase(int& now)
{
    pair<int, int>ans;
    if (!tr[now].l)
    {
        ans = { tr[now].key,tr[now].pos };
        now = merge(tr[now].l, tr[now].r);
        return ans;
    }
    ans = erase(tr[now].l);
    pushup(now);
    return ans;
}


int a[N];
 
void solve()
{
    int n, c;
    read(n), read(c);
 
    tr[0] = { 0,0,0,0,INF,INF,rnd() };
    for (int i = 1;i <= n;++i)tr[i] = { 0,0,0,0,0,0,0 };
    root = tot = 0;
    
    int ans = 0;
    for (int i = 1;i <= n;++i)
    {
        read(a[i]);
 
        split(root, a[i] - 1, rt1, rt2);
        
        if (!rt2)
        {
            root = merge(rt1, rt2);
            ++ans;
            int r = c - a[i];
            insert(r, ans);
        }
        else {
            pair<int, int>now = erase(rt2, tr[rt2].mn);
            root = merge(rt1, rt2);
            insert(now.first - a[i], now.second);
        }
    }
    write(ans);putchar(' ');

    ans = 0;
    map<int, int>mp;
    for (int i = 1;i <= n;++i)
    {
        auto it = mp.lower_bound(a[i]);
        if (it == mp.end())++mp[c - a[i]], ++ans;
        else{
            int r = it->first - a[i];
            --(it->second);
            if (it->second == 0)mp.erase(it);
            ++mp[r];
        }
    }
    write(ans);putchar('\n');
}

int main()
{
    int T;
    read(T);
    while (T--) {
        solve();
    }
    return 0;
}

3.再将第一部分换成线段树，成功AC。

#pragma GCC optimize("Ofast","inline")

#include<bits/stdc++.h>
using namespace std;

template<class T>void read(T& x)
{
    x=0;int f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
    x*=f;
}//快读

template<class T>void write(T& x)
{
    int num=0;char c[40];
    while(x)c[++num]=(x%10)+48,x/=10;
    while(num)putchar(c[num--]);
}//快写

const int N = 5e6 + 10;
const int INF = 1e9;

int n, c;
int a[N];
int tr[N], ans;

#define ls p<<1
#define rs p<<1|1

void pushup(int p)
{
    tr[p] = max(tr[ls], tr[rs]);
}
void update(int p, int pl, int pr, int val)
{
    if (pl == pr)
    {
        if (tr[p] == c)++ans;
        tr[p] -= val;
        return;
    }
    int mid = pl + pr >> 1;
    if (tr[ls] >= val)update(ls, pl, mid, val);
    else update(rs, mid + 1, pr, val);
    pushup(p);
}
 
void solve()
{
    read(n), read(c);
    for (int i = 1;i <= 4 * n;++i)tr[i] = c;

    ans = 0;
    for (int i = 1;i <= n;++i)
    {
        read(a[i]);
        update(1, 1, n, a[i]);
    }
    write(ans);putchar(' ');

    ans = 0;
    map<int, int>mp;
    for (int i = 1;i <= n;++i)
    {
        auto it = mp.lower_bound(a[i]);
        if (it == mp.end())++mp[c - a[i]], ++ans;
        else{
            int r = it->first - a[i];
            --(it->second);
            if (it->second == 0)mp.erase(it);
            ++mp[r];
        }
    }
    write(ans);putchar('\n');
}

int main()
{
    int T;
    read(T);
    while (T--) {
        solve();
    }
    return 0;
}

总结：以后1e6的数据再也不敲平衡树了！！！

fslse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
B. Bin Packing Problem(线段树+multiset)
m0_64158084的博客
11-10 311
"最佳 "的意思是，如果有一个以上的仓可以容纳该物品，则选择剩余空间最小的仓。如果没有找到合适的仓，它就在列表的最后添加一个新的仓，并将项目放入新的仓中。对于每个案例，输入的第一行包含两个整数n,C（1≤n≤106，1≤C≤109），即物品的数量和每个仓的容量。在垃圾箱包装问题中，不同体积的物品必须以最小化所使用的垃圾箱数量的方式装入固定容量为C的有限数量的垃圾箱。对于每个案例，打印一个包含两个整数的单行，分别表示第一次拟合和最佳拟合算法所使用的仓的数量。输入的第一行包含一个正整数T，即案例的数量。
Gym 102770 B-Bin Packing Problem 2020浙江省省赛 （线段树 + set）
forward77
11-17 887
题意：装箱问题。两种算法分别对应操作系统中的首次适应算法和最佳适应算法。然后给定你一个请求序列（顺序不可更改），然后问你在这两种不同的算法下，每种情况会各自申请多少个个大小为C的箱子？ 思路：很明显就是想怎么用算法有优化这个两种模拟。 对于第一种操作：我们每次都需要找的是最前面的第一个大于当前ai的箱子，快速查询就那么几种方法，这里没有顺序，所以我们就有线段树维护区间最大值，然后既然要找最前面的，那么我每次就在符合条件的情况下，尽量往左子树走，否则才会往右子树去找。 第二种操作：每次找的是大于等于当前值的.
B - Bin Packing Problem （线段树+multiset）
Bookerbobo的博客
05-06 435
第一个算法用线段树来进行快速查询第一个可以装下item的bin 第二个算法用multiset的二分快速找到能装下item的最小的bin（也就是lower_bound（）） 线段树可以对无序的序列实现快速查询的操作，根据题意第一个算法因为要找到第一个可以装下item的bin，用set或map等容器会对bin的集合进行排序，无法实现。 #include<iostream> #include<queue> #include<algorithm> #include<
2020浙江省赛ZJCPC B.Bin Packing Problem (线段树+map）
kaka03200的博客
10-23 1297
原题链接 题意：按顺序（记住放入物品的顺序是给定的）给一串序列，代表物品的重量，并且给定容器的容量大小， 要求最少需要几个容器存放这些物品。 题中给了两种算法： 从前往后遍历容器，找到第一个可以放的容器，把物品放进去，如果放不了，再开一个位置 找到能放并且当前剩余容量最小的容器，如果放不下，再开一个位置 第一个算法按照朴素算法，需要n2的复杂度。但我们可以考虑维护区间的最值，如果可以往左找就一直往左，直到找到。因此可以考虑线段树，我们维护区间的最值，初始值全部赋值为容量，如果当前放的物品体积小于左子树
2019美赛b题
02-28
2019美赛b题所用图，有需要的就下载下来看看吧，仅供参考
binpacking.rar_Bin Packing_Bin packing problem_BinPacking MATLAB
07-14
it is a matlab code for bin-packing problem this problem solved with genetic algorithm output is very beautiful
bin packing matlab.rar_Bin Packing_Bin packing problem_bin packi
07-13
装箱问题MATLAB程序，求解一维装箱问题
01 Bin Packing Problem using GA.rar_bicycleyxd_taken72u_遗传算法
07-15
运用标准遗传算法解决TSP旅行商问题，代码全面，涵盖了全部的代码
A bin packing problem with over-sized items
03-01
bin packing 问题的外文文献，可以学习一下！
三维装箱问题（Three-Dimensional Bin Packing Problem,3D-BPP）是一个经典的组合优化问题
最新发布
05-01
三维装箱
算法：装箱问题——bin-packing problem(greedy algorithm)
u010513327的博客
07-13 7855
problem：Afactory produces products packed in square packets of the same height h and ofthe sizes 1*1, 2*2, 3*3, 4*4, 5*5, 6*6. These products are always delivered tocustomers in the square parcels of ...
【算法理论】bin packing 装箱问题
热门推荐
u010900754的专栏
12-27 2万+
Bin packing（装箱问题） Problem：给定n件物品和k个箱子，每一个箱子的容量为1，每一件物品的大小w为(0,1)，要求使用最少数目的箱子来装上全部的物品。 这个问题是NPC问题，只有approximation（近似）算法。 一个2-approximation的多项式算法。 算法： 先打开一个箱子，然后逐一放入物品，如果当前的物品没有一个已打开的箱子可以放入，那么就新打开一
B Bin Packing Problem
qq_46264636的博客
10-06 188
第十七届浙江省省赛B题 题意 思路 用线段树维护第一种做法：如果区间最大值大于 a[i]a[i]a[i] 则递归左儿子；否则递归右儿子； 维护一个 111—nnn 的值为 CCC 的数组，最后检查多少个不是 CCC，即为答案。 用 multisetmultisetmultiset 维护第二种做法：二分查找第一个可以装下的。不过要用 multisetmultisetmultiset 自带的 lowerlowerlower_boundboundbound 否则会 TTT 。 代码 #include &lt
uva 1149 Bin Packing
最爱她！
08-15 331
简单地贪心。。。。先排序，然后看最小的a和最大的b能否在同一条船上，若不能，则船数加1，b--；若能则 a++ ， b--，ans++ ;  // // main.cpp // uva 1149 - Bin Packing // // Created by XD on 15/8/15. // Copyright (c) 2015年 XD. All rights reser
2020 浙江省赛 B. Bin Packing Problem（线段树+map）
Chstelove的博客
04-13 592
题目链接：https://codeforces.com/gym/102770/problem/B 2020 浙江省赛 B. Bin Packing Problem题意思路代码 题意 有n个物品，每个物品的容量为a[i]，有一种箱子（无数个），每个箱子的容量为c，将物品装入箱中，按照如下装法，请问最少各需要多少个箱子： 第一种：每次选择从前往后找到第一个余下空间能够装下当前物品的箱子，把物品装入其中，若没找到，则增加一个箱子，将物品装入增加的箱子中。 第二种，每次选择余下空间最小的且能装下当前物品的箱子，若
Bin Packing
饮酒在风里的博客
09-29 981
#include &lt;iostream&gt; #include &lt;string&gt; #include&lt;algorithm&gt; using namespace std; int main() { int n,l; while(~scanf("%d",&amp;n)) { int m[100001]; ...
算法/贪心算法/BinPacking一维装箱问题
Carinya的博客
04-25 1万+
问题描述We have a number of bins each with a capacity of 1, and we have a set of objects all with different sizes, s1,s2,…,sn between 0 and 1. What is the fewest number of bins that would be needed to stor
UVA - 1149 Bin Packing 贪心水题
静静地码
04-14 624
题目大意：有一种包裹能装的体积是V，每个包裹只能装两件物品，现在给出n件物品，问最少要使用多少包裹去装那n件物品解题思路：给n件物品排序，用体积最大的加上最小的看能不能装进包裹，如果可以的话，就放入，如果不行的话，就只放入大的那个#include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define ma
学习笔记21.08.16:利用python的cplex库解决混合整数规划MIP问题
zzzssszzzzsz的博客
08-16 1714
# -*- coding: utf-8 -*- # The MIP problem solved in this example is: # 问题描述 # Maximize x1 + 2 x2 + 3 x3 + x4 # Subject to # - x1 + x2 + x3 + 10 x4 <= 20 # x1 - 3 x2 + x3 <= 30 # x2 - 3.5x4 = 0 # Bo...
bin packing problem
06-28
装箱问题（bin packing problem）是一种经典的组合优化问题，其目标是将一组物品（每个物品有不同的大小和价值）装入尽可能少的容器中，使得每个容器的总大小不超过容器的容量限制。这个问题在物流、制造业、计算机...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值