区间前k小的和（权值线段树+离散化）--2019牛客多校第7场C--砍树

题目链接：https://ac.nowcoder.com/acm/contest/887/C?&headNav=acm

题意：

给你 n 种树，有 高度，花费和数量 ，现在问你最少需要花多少钱使得最高的树的数量占总数的一半以上。

思路：

其实就是先把高度离散化一下（不离散化也没事），再按树的高度从低到高排一下序，枚举最高的树。

比如当前枚举的是 H，那花费就是（>H）的树的所有花费+（<H）的最多剩下num-1棵树，用权值线段树记录花费和花费的个数，每次查询前k小个就可以了。

 #define IOS ios_base::sync_with_stdio(0); cin.tie(0);
 #include <cstdio>//sprintf islower isupper
 #include <cstdlib>//malloc  exit strcat itoa system("cls")
 #include <iostream>//pair
 #include <fstream>
 #include <bitset>
 //#include <map>
 //#include<unordered_map>   https://ac.nowcoder.com/acm/contest/887/C?&headNav=acm
 #include <vector>
 #include <stack>
 #include <set>
 #include <string.h>//strstr substr
 #include <string>
 #include <time.h>//srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
 #include <cmath>
 #include <deque>
 #include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
 #include <vector>//emplace_back
 //#include <math.h>
 //#include <windows.h>//reverse(a,a+len);// ~ ! ~ ! floor
 #include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
 using namespace std;//next_permutation(a+1,a+1+n);//prev_permutation
 #define fo(a,b,c) for(register int a=b;a<=c;++a)
 #define fr(a,b,c) for(register int a=b;a>=c;--a)
 #define mem(a,b) memset(a,b,sizeof(a))
 #define pr printf
 #define sc scanf
 #define ls rt<<1
 #define rs rt<<1|1
 void swapp(int &a,int &b);
 double fabss(double a);
 int maxx(int a,int b);
 int minn(int a,int b);
 int Del_bit_1(int n);
 int lowbit(int n);
 int abss(int a);
 const long long INF=(1LL<<);
 const double E=2.718281828;
 const double PI=acos(-1.0);
 const int inf=(<<);
 const double ESP=1e-;
 const int mod=(int)1e9+;
 const int N=(int)1e5+;

 int n;
 struct node_
 {
     int h,num,cost;
     friend bool operator<(node_ a,node_ b)
     {
         return a.h>b.h;
     }
 }arr[N];
 int b[N];
 int LS(int n)
 {
     int m=;
     for(int i=; i<=n; ++i)
         b[++m]=arr[i].h;
     sort(b+,b++m);
     m=unique(b+,b++m)-b-;
     for(int i=; i<=n; ++i)
         arr[i].h=lower_bound(b+,b++m,arr[i].h)-b;
     return m;
 }
 //================================================离散化;
 struct node
 {
     long long cnt;
     long long sum;
 }tr[N<<];
 void Build(int l,int r,int rt)
 {
     tr[rt].sum=tr[rt].cnt=;
     if(l==r)return;
     int mid=(l+r)>>;
     Build(l,mid,rt<<);
     Build(mid+,r,rt<<|);
 }
 void update_dot(int cost,int cnt,int l,int r,int rt)
 {
     tr[rt].sum+=cost*cnt;
     tr[rt].cnt+=cnt;
     if(l==r)return;

     int mid=(l+r)>>;
     if(cost<=mid)
         update_dot(cost,cnt,l,mid,rt<<);
     else
         update_dot(cost,cnt,mid+,r,rt<<|);
 }
 long long Query(long long sum,int l,int r,int rt)
 {
     if(sum==)return ;
     if(l==r)
     {
         return sum*l;
     }
     int mid=(l+r)>>;
     long long ans=;

     if(sum<=tr[ls].cnt)
         ans+=Query(sum,l,mid,ls);
     else
         ans+=Query(sum-tr[ls].cnt,mid+,r,rs)+tr[ls].sum;
     return ans;
 }
 void check(int pos,int l,int r,int rt)
 {
     if(l==r)
     {
         pr("%lld %lld\n",tr[rt].cnt,tr[rt].sum);
         return ;
     }
     int mid=(l+r)>>;

     if(pos<=mid)
         check(pos,l,mid,rt<<);
     else
         check(pos,mid+,r,rt<<|);
 }
 void C(int tot)
 {
     fo(i,,n)
         check(i,,tot,);
     pr("----------------------------------\n");
 }
 long long dp[N];
 vector<vector<int> >v(N);

 int main()
 {
     while(~sc("%d",&n))
     {
         fo(i,,n)sc("%d%d%d",&arr[i].h,&arr[i].cost,&arr[i].num);
         arr[n+].num=arr[n+].cost=arr[n+].h=;
         LS(n);
         sort(arr+,arr++n);
         fo(i,,n)
             dp[i]=dp[i-]+arr[i].cost*arr[i].num,v[i].clear();
         long long ans=INF;
         int vcnt=;
         long long cnt=;
         long long CNT=;
         int ncnt=;
         for(int i=n;i>=;--i)
         {
             if(arr[i].h!=arr[i+].h)
                 v[++vcnt].push_back(i);
             else
                 v[vcnt].push_back(i);
         }
         Build(,,);
         int sz=v[].size();//vector用来存相同高度的树团体
         fo(i,,sz-)
             update_dot(arr[v[][i]].cost,arr[v[][i]].num,,,),CNT+=arr[v[][i]].num;
         ans=min(ans,dp[n-sz]);
         ncnt=sz;
         fo(i,,vcnt)
         {
             int sz_=v[i].size();
             fo(j,,sz_-)
                 cnt+=arr[v[i][j]].num;
             ncnt+=sz_;
             long long k=max(0LL,CNT-(cnt-));
             ans=min(ans,Query(k,,,)+dp[n-ncnt]);
             fo(j,,sz_-)
                 update_dot(arr[v[i][j]].cost,arr[v[i][j]].num,,,);
             CNT+=cnt;
             cnt=;
         }
         pr("%lld\n",ans);
     }
     return ;
 }

 /**************************************************************************************/

 int maxx(int a,int b)
 {
     return a>b?a:b;
 }

 void swapp(int &a,int &b)
 {
     a^=b^=a^=b;
 }

 int lowbit(int n)
 {
     return n&(-n);
 }

 int Del_bit_1(int n)
 {
     return n&(n-);
 }

 int abss(int a)
 {
     return a>?a:-a;
 }

 double fabss(double a)
 {
     return a>?a:-a;
 }

 int minn(int a,int b)
 {
     return a<b?a:b;
 }