coci2011 debt 还债

最新推荐文章于 2024-11-30 14:31:53 发布

wang3312362136

最新推荐文章于 2024-11-30 14:31:53 发布

阅读量483

点赞数 1

CC 4.0 BY-SA版权

分类专栏：贪心拓扑排序文章标签： c语言

本文链接：https://blog.youkuaiyun.com/wang3312362136/article/details/78131574

贪心同时被 2 个专栏收录

16 篇文章

订阅专栏

拓扑排序

1 篇文章

订阅专栏

本文介绍了一种解决特定图论问题的算法——如何使一群人之间的债务通过最少的花费完全清偿。通过构建有向图并结合拓扑排序与深度优先搜索（DFS），文章详细解释了算法的具体实现过程与关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description
有N个人，每个人恰好欠另一个人Bi元钱，现在大家都没有钱，政府想要给其中一些人欠，使得大家都不欠别人钱。
如A欠B 50，B欠C 20，则当政府给A50元时，A会立刻用50还清和B的债务，B也会立刻用20还清和C的债务。
欠款必须一次还清。如A欠B 50， B欠A 50，你不能给A 49元让A还49元给B。
问政府至少花多少钱？

Input
第一行 $N (2≤N ≤ 200,000)$ 表示居民数
接下来 $N$ 行，每行有两个数 $A_i$ 和 $B_i$ ，表示第 $i$ 位居民欠编号为 $A_i$ 的居民 $B_i$ 元钱 $(1 ≤ A_i≤ N, A_i ≠ i )$ , $1 ≤B_i ≤10,000$

Output
如题

Sample Input
4
2 100
1 100
4 70
370

Sample Output
170

HINT

标准题解请点击这里

自己的题解
如果 $i$ 欠 $a_i$ 钱，那么就让 $i$ 向 $a_i$ 连一条边，就构成了一个图。
在这个图中如果一个点的入度为0（包括一个人的所有父亲都还清了债务这种情况，也就是说处理过程中入度变成了0），那么没有人会给他钱，那么政府就必须给这个人钱，使他还清债务。
没错，就是拓扑排序。
但是拓扑排序只适用于有向无环图，如果出现了环，那么这个环里的点都不会被遍历到。
没错，拓扑排序后每个点都处于一个环中，这时只要dfs找环即可。
接下来详细说明记录答案的方法：

这个样例有两个地方要注意：第一个是2号点收到了1还给他的30块钱后，要还给3号点的钱数是20块钱，也就是说2号点拿到钱后自己先保留10块钱；第二个是3号点收到了二号点的20块钱后，接下来应该直接给4号点10块钱，不需要等到找环时再进行寻找。

这个样例要注意的是：2在收到1给的10块钱后，接下来只需要给2号点5块就可以使得这里面的整个环都被满足。（具体如何寻找这个点请看代码）

这个样例中，2号点如果收到了1号点的10块之后还不足以还清欠下的债务，那么政府必须给2号点补贴10块钱。（具体如何实现还是看代码）

代码

#include <cstdio>
#include <algorithm>

const int maxn=200000;
const int inf=2000000000;

int n,have[maxn+10],ans;
int stack[maxn+10],head;
int son[maxn+10],need[maxn+10];
int ru[maxn+10],b[maxn+10];

int search(int now)
{
    int res=0,r=now,f=inf;
    if(need[now]+have[son[now]]<need[son[now]])
    {
        res+=need[son[now]]-need[now]-have[son[now]];
        have[son[now]]=need[son[now]]-need[now];
    }
    now=son[now];
    while(now!=r)
    //寻找图3中描述的点并将给予的补贴计入答案
    {
        if(need[now]+have[son[now]]<need[son[now]])
        {
            res+=need[son[now]]-need[now]-have[son[now]];
            have[son[now]]=need[son[now]]-need[now];
        }
        now=son[now];
    }
    while(!b[now])
    //寻找图2中描述的点
    {
        b[now]=1;
        f=std::min(f,std::max(need[now]-have[now],0));
        now=son[now];
    }
    return res+f;
}

int main()
{
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        int s,v;
        scanf("%d%d",&s,&v);
        son[i]=s;
        need[i]=v;
        ru[s]++;
    }
    for(int i=1; i<=n; i++)
    {
        if(!ru[i])
        {
            head++;
            stack[head]=i;
        }
    }
    while(head)
    {
        int u=stack[head];
        head--;
        b[u]=1;
        if(need[u]<=have[u])
        {
            have[u]-=need[u];
            have[son[u]]+=need[u];
            if(!b[son[u]])
            {
                ru[son[u]]--;
                if(!ru[son[u]])
                {
                    head++;
                    stack[head]=son[u];
                }
            }
        }
        else
        {
            ans+=need[u]-have[u];
            have[u]+=need[u]-have[u];
            have[son[u]]+=need[u];
            have[u]-=need[u];
            ru[son[u]]--;
            if(!b[son[u]])
            {
                if((!ru[son[u]])||(need[son[u]]<=have[son[u]]))
                //逻辑或后面的条件特判图1中的情况
                {
                    head++;
                    stack[head]=son[u];
                }
            }
        }
    }
    for(int i=1; i<=n; i++)
    {
        if(!b[i])
        {
            ans+=search(i);
        }
    }
    printf("%d\n",ans);
    return 0;
}