codeforces #375(div.2) 723E One-Way Reform 欧拉回路或网络流

题意：n个点，m条无向边，有回路，无重边，无自环，可以有孤立点。现要求把所有边标上方向，使得目标点的数目最大，并输出标上方向后的边，目标点满足其出度等于入度。

题解：自己不会，看了官方题解上网看了博客，学会了第一种思路。

我们把开始把所有点的度统计出来，假设所有的点度都为偶数，只有两个为奇数，那么我们将这个两个点之间建立一条边，则若从其中一点延向另一点出发并能走回起点，则走过的回路构成欧拉回路，那么此时这一条回路上除了这两点以外的点都满足目标点的条件，那么实际上我们要找的目标点的点数就是度数为偶数的点。而我们应该给边标上的方向就是在回路上走的方向。

那么对于任意一张图，我们只需要在度数为奇数的点之间建立边，使图上形成多个欧拉回路，再走一遍标上方向就可以了，注意，自己加的边不要输出。

在查题解的过程中，发现某位巨巨用网络流解决了这个问题，于是上网查了一下，又学会了一个网络流的用法-处理混合图的欧拉回路。

具体的方法我学的这个：http://yzmduncan.iteye.com/blog/1149049

下面简单讲下，就是首先将原图上的无向边随意定向，加入网络，并统计在随意定向后，度数为奇数的点，在他们之间建立有向边，方向随意，两两一对（注意，是每找出一对，加边，再找出下一对，加边，而不是连续的将这些点连成一条线），并加入网络，这样我们得到的就是一张全是有向边的网络，然后，我们需要对每个点的入度出度只差进行判断，若其入度初度之差的绝对值k为偶数，则说明，如果将连到这个的点上的边中的k/2个边反向，则我们使这个点的出度等于入度，则满足欧拉回路的条件，若其入度大于出度，将其与虚拟汇点之间建立有向边，方向为该店->汇点，容量为k/2，若出度大于入度，则在其与虚拟源点之间建立有向边，方向为源点->汇点，容量亦为k/2，接着我们在这张图上跑一边最大流，这样，若从S出发的所有边都满流，则说明存在欧拉回路，那么在原有网络的基础上，我们把流量非0的边全部反向，就得到了我们要的欧拉回路，由于在加边时，我们是先加的原图上的无向边，因此我们只要输出网络中前2×m条边中的不同边就行了（i与i^1是相同边不同向，可以看做分别记录了一条边的起点和终点），这样可以保证不输出自己虚拟的边。

另外，在实现的时候，用加了当前弧优化的dinic是没法跑的，不加优化貌似可以，我这里用的是sap，希望懂的巨巨能给解答下。

先上按官方题解实现的代码：

#include<bits/stdc++.h>
#define MEM(a,x) memset(a,x,sizeof(a));
#define MEMINF(a) memset(a,0x3f,sizeof(a));
using namespace std;
typedef long long LL;
const int MAXN=5000;
const int INF=0x3f3f3f3f;
const int MOD=1000000007;
int deg[MAXN];
struct Edge{
int u,v,nex;
int in;
}edge[MAXN];
int head[MAXN];
int top;
int vis[MAXN];
void Addedge(int u,int v,int in) {
edge[top].u=u,edge[top].v=v,edge[top].in=in,edge[top].nex=head[u],head[u]=top++;
}

void Addedges(int u,int v,int in) {
Addedge(u,v,in);
Addedge(v,u,in);
}

int main() {
int Test;
cin>>Test;
while (Test--) {
MEM(vis,0);
MEM(deg,0);
MEM(head,-1);
int n,m;
cin>>n>>m;
int u,v;
top=2;
for (int i=0; i<m; ++i) {
scanf("%d %d",&u,&v);
Addedges(u,v,1);
deg[u]++;
deg[v]++;
}
int pre=0;
int ans=n;
for (int i=1; i<=n; i++) {
if (deg[i]%2) {
if (!pre) pre=i;
else {
Addedges(i,pre,0);deg[i]++,deg[pre]++;
}
ans--;
}
}
printf("%d\n",ans);
pre=0;
int cnt=0;
for (int i=1; i<=n; ++i) {
while(deg[i]) {
pre=i;
while(deg[pre]) {
for (int p=head[pre]; ~p; p=edge[p].nex) {
if (!vis[p]) {
vis[p]=vis[p^1]=1;
if (edge[p].in) printf("%d %d\n",pre,edge[p].v);
deg[pre]--;
deg[edge[p].v]--;
pre=edge[p].v;
break;
}
}
}
}
}
}
}

网络流代码：

#include<bits/stdc++.h>
#define MEM(a,x) memset(a,x,sizeof(a));
#define MEMINF(a) memset(a,0x3f,sizeof(a));
using namespace std;
typedef long long LL;
const int MAXN=205;
const int MAXM=MAXN*MAXN;
const int INF=0x3f3f3f3f;
const int MOD=1000000007;
int inde[MAXN];
int outde[MAXN];
int deg[MAXN];
bool vis[MAXN][MAXN];
int b[MAXN];
struct Edge
{
int v;
int next;
int flow;
};
Edge edge[MAXM];
int head[MAXN],edgeNum;
int now[MAXN],d[MAXN],vh[MAXN],pre[MAXN],preh[MAXN];

void Addedge(int a,int b,int c)
{
edge[edgeNum].v = b;
edge[edgeNum].flow = c;
edge[edgeNum].next = head[a];
head[a] = edgeNum++;
edge[edgeNum].v = a;
edge[edgeNum].flow = 0;
edge[edgeNum].next = head[b];
head[b] = edgeNum++;
}

void Init()
{
edgeNum = 0;
memset(head,-1,sizeof(head));
memset(d,0,sizeof(d));
}

int sap(int s,int t,int n)
{
int i,x,y;
int f,ans = 0;
for(i = 0; i < n; i++)
now[i] = head[i];
vh[0] = n;
x = s;
while(d[s] < n)
{
for(i = now[x]; i != -1; i = edge[i].next)
if(edge[i].flow > 0 && d[y=edge[i].v] + 1 == d[x])
break;
if(i != -1)
{
now[x] = preh[y] = i;
pre[y] = x;
if((x=y) == t)
{
for(f = INF,i=t; i != s; i = pre[i])
if(edge[preh[i]].flow < f)
f = edge[preh[i]].flow;
ans += f;
do
{
edge[preh[x]].flow -= f;
edge[preh[x]^1].flow += f;
x = pre[x];
}while(x!=s);
}
}
else
{
if(!--vh[d[x]])
break;
d[x] = n;
for(i=now[x]=head[x]; i != -1; i = edge[i].next)
{
if(edge[i].flow > 0 && d[x] > d[edge[i].v] + 1)
{
now[x] = i;
d[x] = d[edge[i].v] + 1;
}
}
++vh[d[x]];
if(x != s)
x = pre[x];
}
}
return ans;
}
int main() {
int Test;
int sum=0;
cin>>Test;
while (Test--) {
int n,m;
scanf("%d %d",&n,&m);
int u,v;
edgeNum=0;
MEM(vis,0);
MEM(inde,0);
MEM(deg,0);
MEM(outde,0);
Init();
for (int i=0; i<m; ++i) {
scanf("%d %d",&u,&v);
Addedge(u,v,1);
outde[u]++;
inde[v]++;
deg[u]++;
deg[v]++;
}
int pre=0;
int ans=n;
int cnt=0;
for (int i=1; i<=n; ++i) {
if (deg[i]%2) {
++cnt;
if (!pre) pre=i;
else {
//          printf("u:%d v:%d\n",pre,i);
Addedge(pre,i,1),outde[pre]++,inde[i]++;
pre=0;
}
}
}
for (int i=1 ;i<=n; ++i) {
int x=abs(outde[i]-inde[i])/2;
if (inde[i]>outde[i]) {
Addedge(i,n+1,x);
}
else if (inde[i]<outde[i]) {
Addedge(0,i,x);
}
}
sap(0,n+1,n+2);
printf("%d\n",n-cnt);
for (int i=0; i<m*2; i+=2) {
int from=edge[i].v;
int to=edge[i^1].v;
if (edge[i].flow==1) printf("%d %d\n",from,to);
else printf("%d %d\n",to,from);
}
}
}