hdu 3996 最大权闭合图

最新推荐文章于 2021-11-21 23:27:15 发布

sdjzujxc

最新推荐文章于 2021-11-21 23:27:15 发布

阅读量782

点赞数

CC 4.0 BY-SA版权

分类专栏：网络流

本文链接：https://blog.youkuaiyun.com/sdjzujxc/article/details/8163628

网络流专栏收录该内容

9 篇文章

订阅专栏

本文探讨了一种解决金矿收益问题的方法，通过最大闭合图算法实现最优解。首先介绍问题背景及输入输出解释，接着阐述算法思路，即构建最大闭合图并采用广度优先搜索策略求解。文章详细描述了代码实现过程，并最终通过实例验证了算法的有效性。

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

题意：有一些金矿区域，挖一个金矿时必须挖掉上边的跟他关联的，为最多赚的钱数。输入解释：第一个行是样例的组数。第二行表示有n个区域,接下来的一行m表示第i个区域的金矿的个数为m。接下来的m行为这个区域金矿花费的钱数，获得钱数，以及相关连的金矿的个数w，（下面的w行就是表示这些相关联的金矿的区域和在这个区域的第几个）。

思路：最大闭合图。类似poj 2987.建图时把每层的金矿数固定，然后编号建边。

此题错了N次，一直没找到错，就一直改，开始用long long int一直不对，是因为结构体中的流量变量没有改。改了之后还是不对，继续改__int64，还是不对，很纠结啊。最后也不知道是为什么就对了，初步猜测是因为输出类型不对应，主函数中要用__int64,输出时用I64d。最终也不知道错哪了。纠结!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#include <stdio.h>
#include <string.h>
#define VM 66000
#define EM 99999999
const long long int inf=1LL<<60;
struct E
{
    int to,nxt;
    long long int cap;
} edge[EM];

int head[VM],gap[VM],dist[VM],cur[VM],pre[VM];
int ep;
void addedge (int cu,int cv,long long int cw)
{
    edge[ep].to = cv;
    edge[ep].cap = cw;
    edge[ep].nxt = head[cu];
    head[cu] = ep;
    ep ++;
    edge[ep].to = cu;
    edge[ep].cap = 0;
    edge[ep].nxt = head[cv];
    head[cv] = ep;
    ep ++;
}
long long int min (long long int a ,long long int b)
{
    return a > b ? b : a;
}

long long int sap (int src,int des,int n)
{

    memset (dist,0,sizeof(dist));
    memset (gap,0,sizeof (gap));
    memcpy (cur,head,sizeof(head));
    long long int res = 0;
    int u = pre[src] = src;
    long long int aug = inf;
    gap[0] = n;
    while (dist[src] < n)
    {
loop:
        for (int &i = cur[u]; i != -1; i = edge[i].nxt)
        {
            int v = edge[i].to;
            if (edge[i].cap && dist[u] == dist[v] + 1)
            {
                aug = min (aug,edge[i].cap);
                pre[v] = u;
                u = v;
                if (v == des)
                {
                    res += aug;
                    for (u = pre[u]; v != src; v = u,u = pre[u])
                    {
                        edge[cur[u]].cap -= aug;
                        edge[cur[u]^1].cap += aug;
                    }
                    aug = inf; //
                }
                goto loop;
            }
        }
        int mindist = n;  //
        for (int i = head[u]; i != -1; i = edge[i].nxt)
        {
            int v = edge[i].to;
            if (edge[i].cap && mindist > dist[v])
            {
                cur[u] = i;
                mindist = dist[v];
            }
        }
        if ((--gap[dist[u]]) == 0)
            break;
        dist[u] = mindist + 1;
        gap[dist[u]] ++;
        u = pre[u];
    }
    return res;
}

int main ()
{
    int n,u,v;
    int src,des;
    int cas;
    int lnum,mnum,w;
    int cost,val;

    scanf("%d",&cas);
    for(int t=1; t<=cas; t++)
    {
        __int64 sum=0;
        ep = 0;
        src = 0;
        memset (head,-1,sizeof(head));
        des =3000;
        n=des+1;
        scanf("%d",&lnum);

        for(int i=1; i<=lnum; i++)
        {
            scanf("%d",&mnum);
            for(int j=1; j<=mnum; j++)
            {
                scanf("%d%d%d",&cost,&val,&w);
                val-=cost;
                if(val>0)
                {
                    addedge(src,i*26+j,val);
                    sum+=val;
                }
                else
                    addedge(i*26+j,des,-val);

                while(w--)
                {
                    scanf("%d%d",&u,&v);
                    addedge(i*26+j,u*26+v,inf);
                }
            }
        }
       __int64 max_flow=sap(src,des,n);

        printf("Case #%d: %I64d\n",t,sum-max_flow);
    }
    return 0;
}