UVA 1149 Bin Packing 装箱 经典贪心 (SWERC 2005)

贪心解法

我认为这是正解，就是先将物品排序，因为每个物品都要选，不妨每次考虑选择那个最重的物品，之后考虑将最轻的物品也放进去，若放不进去，那么这次就装1个最重的物品，否则，装这两个。

原理：因为最重的物品总要放进去，如果最轻的物品还不能与之搭配，那么他永远只能一个人。

#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
typedef long long ll;
typedef pair<int, int> pii;
const int INF =0x3f3f3f3f;
const int maxn= 100000   ;
int n,V,a[maxn+10];

void work()
{
    int le=1,ri=n,ans=0;
    while(le<=ri)
    {
        if(a[ri]+a[le]<=V)
        {
            ri--;
            le++;
        }
        else
        {
            ri--;
        }
        ans++;

    }
    printf("%d\n",ans);
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&V);
        for1(i,n)
        {
            scanf("%d",&a[i]);
        }
        sort(a+1,a+1+n);
        work();
        if(T)  putchar('\n');
    }

   return 0;
}

STL+二分

这个其实也用到了贪心，只不过比起正解low些。不妨每次考虑放进最重的物品，然后尽可能再放进一个最重的物品，能有多重放多重。

#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
typedef long long ll;
typedef pair<int, int> pii;
const int INF =0x3f3f3f3f;
const int maxn= 100000   ;
int n,V;
vector<int >a;

void work()
{
    int ans=0;
    while(a.size())
    {
        ans++;
        vector<int >:: iterator it=a.end();
        it--;
        int v=V-*it;
        a.erase(it);

        if(!a.size())  continue;

        it=upper_bound(a.begin(),a.end(),v);

        if(it==a.begin()) continue;
        it--;
        a.erase(it);
    }
    printf("%d\n",ans);
}
int main()
{
    int T,x;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&V);
        a.clear();
        for1(i,n)
        {
            scanf("%d",&x);
            a.push_back(x);
        }
        sort(a.begin(),a.end());
        work();
        if(T)  putchar('\n');
    }

   return 0;
}

线段树

其实跟STL+二分原理相同，只不过实现方法更为复杂，需要人工维护数据结构，但是应该快些。

#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
#define MID   int mid=(le+ri)>>1
#define  lson   ind<<1,le,mid
#define rson    ind<<1|1,mid+1,ri
#define all(x) (x).begin(), (x).end()
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
typedef long long ll;
typedef pair<int, int> pii;
const int INF =0x3f3f3f3f;
const int maxn= 100000    ;
const int maxL= 10000    ;
int V,n,a[maxn+10],N;
bool vis[maxn+10];
struct SegmentTree
{
    int sum[4*maxL+10];
    void build(int ind,int le,int ri)
    {
        if(le==ri)
        {
           sum[ind]=0;
           return;
        }
        MID;
        build(lson);
        build(rson);
        sum[ind]=0;
    }
    void update(int ind,int le,int ri,int pos,int add)
    {
        if(le==ri)
        {
            sum[ind]+=add;
            return;
        }
        MID;
        if(pos<=mid)  update(lson,pos,add);
        else update(rson,pos,add);
        sum[ind]=sum[ind<<1]+sum[ind<<1|1];
    }
    int findbig(int ind,int le,int ri)
    {
        if(le==ri)
        {
            return le;
        }
        MID;
        if(sum[ind<<1|1]>0)  return findbig(rson);
        if(sum[ind<<1]>0)  return  findbig(lson);
        return -1;

    }
    int findsmall(int ind,int le,int ri)
    {
        if(le==ri)
        {
            return le;
        }
        MID;
        if(sum[ind<<1]>0)    return findsmall(lson);
        if(sum[ind<<1|1]>0)  return findsmall(rson);
        return -1;
    }



}sgt;
bool cmp(int x,int y)
{
    return x>y;
}
void work()
{
    int ans=0;
    sgt.build(1,1,N);
    for1(i,n)
    {
        sgt.update(1,1,N,a[i],1);
    }
    while(sgt.sum[1])
    {
        ans++;
        int x=sgt.findbig(1,1,N);
        sgt.update(1,1,N,x,-1);


        if(!sgt.sum[1])  continue;
        int y=sgt.findsmall(1,1,N);
        if(y+x>V) continue;

        sgt.update(1,1,N,y,-1);

    }
    printf("%d\n",ans);

}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        N=0;
        scanf("%d%d",&n,&V);

        for1(i,n)  scanf("%d",&a[i]);
        sort(a+1,a+1+n);
        N=a[n];
        work();
        if(T)  putchar('\n');

    }

   return 0;
}

说的通俗一点，第一个解法其实是通过某个"点"来考虑最优解，后面的解法其实是从全局来考虑最优解。

有些时候不妨换个思维的角度来考虑问题。