砍树最小花费

题意：有n种树，每种树给出高度h，砍掉每颗树的花费c，每种树的数量p，现在要砍掉一些树，使得最高的树的数量超过所有树的一半，问最小花费。（不同种类的树高度可能相同）

题解：枚举不同的高度，把高于它的树都砍掉，然后比它矮的树挑便宜的砍，使得该高度的树占所有树的1/2+1。给树按高度排序，首先可以用后缀和预处理出砍掉高于每种高度的树的花费，然后用线段树维护某一价格区间的树一共有多少颗，tr[1].num就是比当前高度矮的树的总数，要砍掉的树的数量就是tr[1].num-tot+1，tot是当前高度的树的总数量。询问砍掉矮的树的花费时，当要砍的树的数量k小于左子树，就递归到左子树，如果大于左子树，就花费加上左子树的花费，数量k减去左子树的数量，然后递归到右子树。当递归到叶子节点的时候，花费直接加上剩余数量*该价格。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
using namespace std;
typedef long long ll;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5+5;
ll ans,suf[maxn];
struct tree
{
    ll h,p;
    int c;
}a[maxn];

bool cmp(const tree &a,const tree &b)
{
    return a.h < b.h;
}

struct node
{
    int l,r;
    ll num,sum;
}tr[200*4+1];

void build(int k,int l,int r)
{
    tr[k].l = l,tr[k].r = r;
    if(l == r)
    {
        tr[k].num = 0ll;
        tr[k].sum = 0ll;
        return;
    }
    int mid = (l+r)/2;
    build(k*2,l,mid);
    build(k*2+1,mid+1,r);
}

void update(int k,int cost,ll cnt)
{
    if(tr[k].l == tr[k].r)
    {
        tr[k].num += cnt;
        tr[k].sum += (ll)cost*cnt;
        return;
    }
    int mid = (tr[k].l+tr[k].r)/2;
    if(cost <= mid)
        update(k*2,cost,cnt);
    if(cost > mid)
        update(k*2+1,cost,cnt);
    tr[k].num = tr[k*2].num + tr[k*2+1].num;
    tr[k].sum = tr[k*2].sum + tr[k*2+1].sum;
}

void query(int k,ll cnt)
{
    if(tr[k].l == tr[k].r)
    {
        ans += cnt*tr[k].l;
        return;
    }
    if(cnt <= tr[k*2].num)
        query(k*2,cnt);
    if(cnt > tr[k*2].num)
    {
        ans += tr[k*2].sum;
        cnt -= tr[k*2].num;
        query(k*2+1,cnt);
    }
}

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(suf,0,sizeof(suf));
        memset(a,0,sizeof(a));
        memset(tr,0,sizeof(tr));
        int mx = 0;
        for(int i=1; i<=n; i++)
        {
            scanf("%lld%d%lld",&a[i].h,&a[i].c,&a[i].p);
            mx = max(mx,a[i].c);
        }
        build(1,1,mx);
        sort(a+1,a+1+n,cmp);
        for(int i=n; i>0; i--)
        {
            suf[i] = suf[i+1] + a[i].p*a[i].c;
        }
        ll anss = INF;
        for(int i=1; i<=n; i++)
        {
            if(a[i].h == a[i-1].h)
                continue;
            int j=i;
            ll tot = a[i].p;
            while(j+1<n && a[j+1].h == a[i].h)
            {
                j++;
                tot += a[j].p;
            }
            ans = 0;
            ans += suf[j+1];
            if(tr[1].num >= tot)
                query(1,tr[1].num-tot+1);
            for(int l=i; l<=j; l++)
                update(1,a[l].c,a[l].p);
            anss = min(anss,ans);
        }
        printf("%lld\n",anss);
    }
}