HDU 5348 MZL's endless loop 给边定向（欧拉回路，最大流）

 

 

 

题意：

　　给一个所有你可能想得到的奇葩无向图，要求给每条边定向，使得每个点的入度与出度之差不超过1。输出1表示定向往右，输出0表示定向往左。

 

思路：

　　网络流也是可以解决的！！应该挺简单理解的。但是由于复杂度的问题，EK和Dinic都搞不定，ISAP才行。

　　利用欧拉回路的思想。既然每个点的入度与出度之差不超过1，那么在每两个奇数度的点添加1条无向边并不会影响到什么。那么先添加一些边进去，使得所有点的度都是偶数的。先随意帮每条边定个方向，进行建新图（用于跑最大流），假设u->v，那么u的出度就是可以给v的（当且仅当这条边反转时），建边u->v，容量为1。添加超级源点s连接到所有【出度大于入度的点】，容量为(出度-入度)/2，表示它有这么多个出度可以赠人。将所有【入度大于出度的点】连一条边到超级汇点t，容量为(入度-出度)/2，表示需要这么多的入度。接着跑一遍最大流（结果必定是满流的，即所有点的出度=入度），每条有流的边就需要将原来随意定下的方向反过来。参考

 

 

#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL long long
using namespace std;
const int N=101000;
struct node
{
    int from, to, cap, flow, has;
    node(){};
    node(int from, int to,int cap,int flow,int has):from(from),to(to),cap(cap),flow(flow),has(has){};
}edge[N*15];
int chu[N], ru[N], vis1[N], ans[N*10], edge_cnt;
vector<int> vect[N], rev[N], md;    //图的反向边在这，反向BFS时用的。
vector<pii> g;

void init(int up)
{
    md.clear();
    g.clear();
    memset(chu,0,sizeof(chu));
    memset(ru, 0,sizeof(ru));
    edge_cnt=0;
    for(int i=0; i<=up; i++)    vect[i].clear(),rev[i].clear();
}

void add_node(int from,int to,int cap,int flow,int has)
{
    edge[edge_cnt]=node(from, to, cap, flow, has);
    rev[to].push_back(edge_cnt);    //反向，用于ISAP的BFS
    vect[from].push_back(edge_cnt++);
}

void change()   //修改原来定下方向的边
{
    for(int i=0; i<edge_cnt; i++)
    {
        node e=edge[i];
        if( e.has>=0 && e.flow>0 )    ans[e.has]= 1-ans[e.has];
    }
}

bool isok(int n)    //判断是否已经满足要求
{
    for(int j=1; j<=n; j++)    if( abs(chu[j]-ru[j])>1 )    return false;
    return true;
}


int num[N], p[N], d[N], cur[N], vis[N]; //最大流用的
deque<int> que;
void BFS(int s,int e)   //模板
{
    memset(vis, 0, sizeof(vis));
    que.clear();
    que.push_back(e);
    vis[e]=1;
    d[e]=0;
    num[0]=1;   //gap可以在这更新

    while(!que.empty())
    {
        int x=que.front();que.pop_front();
        for(int i=0; i<rev[x].size(); i++)
        {
            node e=edge[rev[x][i]];
            if(!vis[e.from])
            {
                vis[e.from]=1;
                d[e.from]=d[e.to]+1;
                ++num[d[e.from]];
                que.push_back(e.from);
            }
        }
    }
}

int Augment(int s,int e)  //模板
{
    int ed=e, big=INF;
    while(ed!=s)
    {
        node &e=edge[p[ed]];
        big=min(big, e.cap-e.flow);
        ed=edge[p[ed]].from;
    }
    ed=e;
    while(ed!=s)
    {
        edge[p[ed]].flow+=big;
        edge[p[ed]^1].flow-=big;
        ed=edge[p[ed]].from;
    }
    return big; //找到的流
}

int max_flow(int n, int s, int e)   //最大流模板
{
    int ans_flow=0;
    memset(num, 0, sizeof(num));
    BFS(s, e);       //更新d数组
    int x=s;
    memset(cur, 0,sizeof(cur));
    while(d[s]<n)
    {
        if(x==e)
        {
            ans_flow+=Augment(s,e);
            x=s;
        }
        int ok=0;
        for(int i=cur[x]; i<vect[x].size(); i++)
        {
            node &e=edge[vect[x][i]];
            if(e.cap>e.flow && d[x]==d[e.to]+1)
            {
                ok=1;
                p[e.to]=vect[x][i]; //记录边号
                cur[x]=i;
                x=e.to;
                break;
            }
        }
        if(!ok)
        {
            int m=n-1;
            for(int i=0; i<vect[x].size(); i++)
            {
                node e=edge[vect[x][i]];
                if(e.cap>e.flow)    m=min(m, d[e.to]);
            }
            if(--num[d[x]]==0) break;
            d[x]=m+1;
            num[d[x]]++;
            cur[x]=0;
            if(x!=s)    x=edge[p[x]].from;
        }
    }
    return ans_flow;
}


int cal(int n, int s, int e)
{
    if(isok(n))    return 1;    //已经满足要求了，不用跑最大流
    int mcnt=g.size(), ncnt=0;;

    //奇数度的点需要补边
    md.clear();
    for(int i=1; i<=n; i++)    if((chu[i]+ru[i])&1)    md.push_back(i);
    for(int i=0; i<md.size(); i+=2)
    {
        g.push_back(make_pair(md[i],md[i+1]));
        chu[md[i]]++, ru[md[i+1]]++;
    }

    //建图***************
    memset(vis1,0,sizeof(vis1));
    for(int i=0; i<g.size(); i++)
    {
        int a=g[i].first;
        int b=g[i].second;
        int h= i<mcnt? i: -1;

        if(!vis1[a]) ncnt++;        //统计新图中的点数
        if(!vis1[b]) ncnt++;

        add_node(a, b, 1, 0, h);    //这是给定的边
        add_node(b, a, 0, 0, -1);

        if(!vis1[a]&&chu[a]>ru[a])    //添加源点
        {
            vis1[a]=1;
            int cnt=(chu[a]-ru[a])/2;
            add_node(0, a, cnt, 0, -1);
            add_node(a, 0, 0, 0, -1);

        }
        if(!vis1[b]&&ru[b]>chu[b])    //添加汇点
        {
            vis1[b]=1;
            int cnt=(ru[b]-chu[b])/2;
            add_node(b, n+1, cnt, 0, -1);
            add_node(n+1, b, 0, 0, -1);
        }
    }

    //最大流************
    max_flow(ncnt+2, s, e); //ncnt+2是表示点数

    //修改一下答案******
    change();
}

int main()
{
    freopen("input.txt", "r", stdin);
    int t, n, m, a, b;
    cin>>t;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init(n+1);
        for(int i=0; i<m; i++)
        {
            scanf("%d %d", &a, &b);
            chu[a]++, ru[b]++;
            ans[i]=1;
            g.push_back(make_pair(a,b));
        }
        cal(n, 0, n+1);
        for(int i=0; i<m; i++)    printf("%d\n",ans[i]);
    }
    return 0;
}

 

 

 

 

 

 

附送个数据产生程序（跑完最大流后再测试一下是否满足要求了）：

 

#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL long long
using namespace std;
const int N=101000;


int main()
{
    freopen("output.txt", "w+", stdout);
    int t=100;//例子数
    int a, b;
    puts("100");
    srand(time(0));
    while(t--)
    {
        a=((int)rand())%100+1;//点数
        b=((int)rand())%min((a*a),3000)+1;//边数
        printf("\n\n%d %d\n\n", a, b);

        for(int i=0; i<b; i++)
        {
            int u=((int)rand())%a+1;
            int v=((int)rand())%a+1;
            printf("%d %d\n",u,v);
        }
    }
    return 0;
}