BZOJ 2095 [Poi2010]Bridges 二分+最大流

最新推荐文章于 2021-12-20 21:06:06 发布

原创最新推荐文章于 2021-12-20 21:06:06 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#2010 #poi

BZOJ刷题录同时被 2 个专栏收录

225 篇文章

订阅专栏

Network Flows

6 篇文章

订阅专栏

本文介绍了一个结合欧拉回路与二分搜索算法的问题解决思路。具体地，文章探讨了如何在一个带权双向图中寻找一个从特定起点出发的欧拉回路，使该回路上最大边权值最小。通过使用二分搜索确定最大权值的范围，并借助最大流算法验证欧拉回路的存在性。

题意:
给定一张图，每条边双向且双向都有权值，求一个从1开始的欧拉回路，使得回路上的边的最大权值最小。
解析:
最大值最小！！
二分！！二分！！
第一部分完成辣，二分出路上的最大权值。
然后这时候我们要处理下所有的边，如果边上权值大于我们二分的值的话显然是不可取的。
这其实就是个混合图的欧拉回路问题。
首先无向的边我们任意记录一下出度入度，然后有向边直接记录出度入度。
如果有一个点的出度入度之差是奇数那么显然不可以成为欧拉回路。
如果都是偶数，那么需要用最大流来判定。
最大流流的是什么？是反悔的边。
比如我们对应先前的无向边，我们任意选定了一个方向记录出度入度，那么另一个方向我们就需要连一条容量为1的边，代表我们有一次机会来返回。
然后对于出度比入度大的点我们可以将其连向汇点一条容量为出度入度之差一半的边。
入度比出度大的点我们可以从源点向他连一条容量为入度出度之差一半的边。
这样我们新建出来的图可以假装把它称为反悔图。
如果满流，显然我们可以保证这个欧拉回路存在，如果不满流那么说明这个欧拉回路不存在(无法流回，不知所措)。
代码:

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 1010
#define M 2010
#define LL L[i].l
#define RR L[i].r
#define C L[i].c1
#define CC L[i].c2
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int low,high;
struct line
{
    int l,r;
    int c1,c2;
    line(){}
    line(int _l,int _r,int _c1,int _c2):l(_l),r(_r),c1(_c1),c2(_c2){}
    friend istream& operator >> (istream &_,line &a)
    {scanf("%d%d%d%d",&a.l,&a.r,&a.c1,&a.c2);return _;}
    void update()
    {
        if(c1>c2)swap(c1,c2),swap(l,r);
        low=min(low,c1);
        high=max(high,c2);
    }
}L[M];
struct node
{
    int from,to,val;
    int next;
}edge[M<<2];
int head[N],cnt;
int in[N],out[N];
int dep[N],st,ed;
void init()
{
    low=0x3f3f3f3f,high=-1;
}
void init_before_check()
{
    memset(head,-1,sizeof(head));
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    cnt=0,st=0,ed=n+1;
}
void edgeadd(int from,int to,int val)
{
    edge[cnt].from=from,edge[cnt].to=to;
    edge[cnt].val=val,edge[cnt].next=head[from];
    head[from]=cnt++;
}
bool bfs(int s,int e)
{
    memset(dep,0,sizeof(dep));
    queue<int>q;
    q.push(s);
    dep[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        if(u==e)return 1;
        q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int to=edge[i].to;
            if(dep[to]!=0||!edge[i].val)continue;
            dep[to]=dep[u]+1;
            q.push(to);
        }
    }
    return 0;
}
int dfs(int s,int max_vale)
{
    int ret=0;
    if(s==ed)return max_vale;
    for(int i=head[s];i!=-1;i=edge[i].next)
    {
        int to=edge[i].to;
        if(edge[i].val==0||dep[to]!=dep[s]+1)continue;
        int tmp=dfs(to,min(max_vale-ret,edge[i].val));
        edge[i].val-=tmp;
        edge[i^1].val+=tmp;
        ret+=tmp;
        if(ret==max_vale)return ret;
    }
    return ret;
}
bool if_has_odd()
{
    for(int i=1;i<=n;i++)
        if(abs(in[i]-out[i])&1)return 1;
    return 0;
}
bool check(int x)
{
    init_before_check();
    for(int i=1;i<=m;i++)
    {
        if(L[i].c2<=x)
            edgeadd(RR,LL,1),edgeadd(LL,RR,0);
        if(L[i].c1<=x)
            out[LL]++,in[RR]++;
    }
    if(if_has_odd())return 0;
    int judge=0;
    for(int i=1;i<=n;i++)
    {
        if(out[i]>in[i])
            edgeadd(i,ed,(out[i]-in[i])>>1),edgeadd(ed,i,0),judge+=(out[i]-in[i])>>1;
        else if(out[i]<in[i])
            edgeadd(st,i,(in[i]-out[i])>>1),edgeadd(i,st,0);
    }
    int ret=0;
    while(bfs(st,ed))
    {
        while(int t=dfs(st,INF))
        {
            ret+=t;
        }
    }
    return ret==judge;
}
int main()
{
    init();
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){cin>>L[i];L[i].update();}
    int l=low,r=high,ans=-1;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(check(mid))ans=mid,r=mid-1;
        else l=mid+1;
    }
    printf(ans==-1?"NIE\n":"%d\n",ans);
}