poj 2125 Destroying The Graph

最新推荐文章于 2021-08-13 11:33:49 发布

原创最新推荐文章于 2021-08-13 11:33:49 发布 · 715 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种求解最小点权覆盖问题的算法，并通过最大流算法进行求解，同时还实现了输出覆盖路径的功能。该算法适用于解决特定类型的匹配问题。

最小点权覆盖加输出路径。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=3e3+9,inf=2e9;
int in[maxn],out[maxn];
int S,T,level[maxn],que[maxn];
bool visit[maxn];
int n,m;
int head[maxn],lon;
struct
{
    int next,to,c;
}e[maxn*maxn];
void edgeini()
{
    memset(head,-1,sizeof(head));
    lon=-1;
}
void edgemake(int from,int to,int c)
{
    e[++lon].to=to;
    e[lon].c=c;
    e[lon].next=head[from];
    head[from]=lon;
}

bool makelevel(int s,int t)
{
    memset(level,0,sizeof(level));
    int front=1,end=0;
    que[++end]=s;
    level[s]=1;
    while(front<=end)
    {
        int u=que[front++];
//        printf("%d %d\n",front,end);
        if(u==t) return true;
        for(int k=head[u];k!=-1;k=e[k].next)
        {
            int v=e[k].to;
            if(!level[v]&&e[k].c)
            {
                level[v]=level[u]+1;
                que[++end]=v;
            }
        }
    }
    return false;
}

int dfs(int now,int t,int maxf)
{
    if(now==t) return maxf;
    int ret=0;
    for(int k=head[now];k!=-1;k=e[k].next)
    {
        int u=e[k].to;
        if(level[u]==level[now]+1&&e[k].c)
        {
            int f=dfs(u,t,min(maxf-ret,e[k].c));
            e[k].c-=f;
            e[k^1].c+=f;
            ret+=f;
            if(ret==maxf) return ret;
        }
    }
    return ret;
}

int dfs1(int now,int t,int maxf)
{
    level[now]=1;
    if(now==t) return maxf;
    int ret=0;
    for(int k=head[now];k!=-1;k=e[k].next)
    {
        int u=e[k].to;
        if(!visit[u]&&!level[u]&&e[k].c)
        {
            int f=dfs1(u,t,min(maxf-ret,e[k].c));
            e[k].c-=f;
            e[k^1].c+=f;
            ret+=f;
            if(ret==maxf) return ret;
        }
    }
    return ret;
}

int maxflow(int s,int t)
{
    int ret=0;
    while(makelevel(s,t))
    {
        ret+=dfs(s,t,inf);
    }
    return ret;
}


void ff()
{
//    for(int i=0;i<=T;i++)
//    for(int k=head[i];k!=-1;k=e[k].next)
//    {
//        int u=e[k].to;
//        printf("%d %d\n",i,u);
//    }
//    cout<<endl;
}

bool dfs(int now,int t)
{
    if(now==t) return true;
    level[now]=1;
    for(int k=head[now];k!=-1;k=e[k].next)
    {
        int u=e[k].to;
        if(e[k].c&&!level[u])
        if(dfs(u,t)) return true;
    }
    return false;
}

void prin()
{
    memset(visit,0,sizeof(visit));
    int sum=0;

//    for(int k=head[6];k!=-1;k=e[k].next)
//    if(e[k].to==T)
//    cout<<e[k].c<<endl;

    for(int k=head[S];k!=-1;k=e[k].next)
    {
        memset(level,0,sizeof(level));
        if(!dfs(S,e[k].to))
        {
            sum++;
            int u=e[k].to;

            memset(level,0,sizeof(level));
            e[k].c=0;
            e[k^1].c=0;
            dfs1(T,u,out[u]);
            visit[u]=1;
    //        ff();
        }
    }

//    for(int k=head[6];k!=-1;k=e[k].next)
//    if(e[k].to==T)
//    cout<<e[k].c<<endl;

    for(int i=n+1;i<=n+n;i++)
    for(int k=head[i];k!=-1;k=e[k].next)
    if(e[k].to==T&&e[k].c==0)
    {
        memset(level,0,sizeof(level));
        if(!dfs(i,T))
        {
            sum++;
            int u=i;

            memset(level,0,sizeof(level));
            e[k].c=0;
            e[k^1].c=0;
            dfs1(u,S,in[u-3]);
            visit[u]=1;
    //        ff();
        }
    }
    cout<<sum<<endl;
    for(int i=1;i<=n+n;i++)
    if(visit[i])
    {
        if(i<=n) printf("%d -\n",i);
        else printf("%d +\n",i-n);
    }
}


int main()
{
//    freopen("in.txt","r",stdin);
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        edgeini();
        S=0,T=n+n+1;
        for(int i=1;i<=n;i++) scanf("%d",&in[i]);
        for(int i=1;i<=n;i++) scanf("%d",&out[i]);
        for(int i=1,from,to;i<=m;i++)
        {
            scanf("%d%d",&from,&to);
            to+=n;
            edgemake(from,to,inf);
            edgemake(to,from,0);
        }
        for(int i=1;i<=n;i++)
        {
            edgemake(0,i,out[i]);
            edgemake(i,0,0);
            edgemake(i+n,T,in[i]);
            edgemake(T,i+n,0);
        }
        int ans=maxflow(S,T);
        cout<<ans<<endl;
        prin();
    }
    return 0;
}