E1/E2. Weights Division (easy version)/(hard version)

E1/E2. Weights Division (easy version)/(hard version)

E1. Weights Division (easy version)

题意：
一颗有n个节点的有根树，根节点是1。问最少操作多少次，可以使得从根节点到所有叶子节点的路径上的边权总和<=S。
即每个叶子节点上有一个人，这些人要到根节点去，每个人的花费为到根节点的边权和。操作多少次，使得所有人的边权总和<=S
每次操作使任选某一条边，将其边权值/2
思路：
我们已知树的结构，我们就可以知道每条边会经过多少次，然后采用优先队列，每次都选择操作总影响最大的那条边

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
ll n,S,sum,ned;
ll val[N],cnt[N]; //val[i]，表示以i为边的下端点，记录边的权值， cnt[i]表示第i条边使用的次数
struct node1{ll v,w;};
struct node2{
    ll val,cnt;
    bool operator<(const node2& t)const{ //按着影响从大到小排列
        return (val-val/2)*cnt<(t.val-t.val/2)*t.cnt;
    }
};
vector<node1>edge[N];

void dfs(ll u,ll fa){
    ll len=edge[u].size();
    if(len==1) cnt[u]=1;  //叶子节点
    for(ll i=0;i<len;i++){
        ll v=edge[u][i].v;
        if(v==fa) continue;
        dfs(v,u);
        val[v]=edge[u][i].w;
        cnt[u]+=cnt[v];
    }
}

void solve(){
    scanf("%lld%lld",&n,&S);
    sum=ned=0;
    for(ll i=1;i<=n;i++) edge[i].clear(),val[i]=cnt[i]=0;
    for(ll i=1;i<n;i++){
        ll u,v,w; scanf("%lld%lld%lld",&u,&v,&w);
        edge[u].push_back({v,w});
        edge[v].push_back({u,w});
    }
    dfs(1,-1);
    priority_queue<node2>q;
    for(ll i=2;i<=n;i++) q.push({val[i],cnt[i]}),sum+=val[i]*cnt[i]; //初始总花费
    while(sum>S){
        auto u=q.top(); q.pop();
        sum=sum-(u.val-u.val/2)*u.cnt;
        q.push({u.val/2,u.cnt});
        ned++;
    }
    printf("%lld\n",ned);
}

int main(){
    int t;scanf("%d",&t);
    while(t--) solve();
}

E2. Weights Division (hard version)

题意：
同E1，不过给每条边加了一个单次操作花费，要求输出花费最小的情况下，满足题意
思路：
我们知道花费只有1、2两种，我们将花费1跟2进行分类，分别按照只有改花费进行一次优先队列处理，记录两个的前缀和
随后我们枚举花费1的操作数，可以知道花费2应该做出的贡献，可以通过二分的方式来得到花费2的操作次数，最后取min值

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e5+5;
ll n,S,sum;
ll val[N],cnt[N];
ll pre[3][N*20],id1,id2;
struct node1{ll v,w,c;};
vector<node1>edge[N];
struct node2{
    ll val,cnt;
    bool operator<(const node2& t)const{
        return (val-val/2)*cnt<(t.val-t.val/2)*t.cnt;
    }
};
priority_queue<node2>q[3];

void init(){
    for(ll i=0;i<=id1;i++) pre[1][i]=0;
    for(ll i=0;i<=id2;i++) pre[2][i]=0;
    sum=id1=id2=0;
    for(ll i=1;i<=n;i++) edge[i].clear(),val[i]=cnt[i]=0;
    while(q[1].size()) q[1].pop();
    while(q[2].size()) q[2].pop();
}

void dfs(ll u,ll fa){
    ll len=edge[u].size();
    if(len==1&&fa!=-1) cnt[u]=1;
    for(ll i=0;i<len;i++){
        ll v=edge[u][i].v;
        if(v==fa) continue;
        dfs(v,u);
        val[v]=edge[u][i].w;
        cnt[u]+=cnt[v];
        sum+=val[v]*cnt[v];
        q[edge[u][i].c].push({val[v],cnt[v]});
    }
}

void solve(){
    scanf("%lld%lld",&n,&S);
    init();
    for(ll i=1;i<n;i++){
        ll u,v,w,c; scanf("%lld%lld%lld%lld",&u,&v,&w,&c);
        edge[u].push_back({v,w,c});
        edge[v].push_back({u,w,c});
    }
    dfs(1,-1);
    if(sum<=S) {puts("0");return;}
    while(!q[1].empty()){ //只对花费1的边进行操作
        auto u=q[1].top(); q[1].pop();
        ll now=(u.val-u.val/2)*u.cnt;
        id1++;
        pre[1][id1]=pre[1][id1-1]+now; //前缀和
        if(sum-pre[1][id1]<=S) break;
        if(u.val/2!=0) q[1].push({u.val/2,u.cnt});
    }
    while(!q[2].empty()){ //只对花费2的边进行操作
        auto u=q[2].top(); q[2].pop();
        ll now=(u.val-u.val/2)*u.cnt;
        id2++;
        pre[2][id2]=pre[2][id2-1]+now; //前缀和
        if(sum-pre[2][id2]<=S) break;
        if(u.val/2!=0) q[2].push({u.val/2,u.cnt});
    }
    ll ans=1e18;
    for(ll i=0;i<=id1;i++){ //枚举对花费1的边进行操作的次数
        ll ned2=sum-pre[1][i];
        ll l=0,r=id2,pos=1e18; //二分找对花费2的边需要的操作次数
        while(l<=r){
            ll mid=(l+r)>>1;
            if(ned2-pre[2][mid]<=S) pos=mid,r=mid-1;
            else l=mid+1;
        }
        ans=min(ans,i+pos*2);
    }
    printf("%lld\n",ans);
}

int main(){
    int t;scanf("%d",&t);
    while(t--) solve();
}