歐拉回路

簡介：

• 歐拉回路：每條邊恰好只走一次,並能回到出發點的路徑.
• 尤拉路徑：經過每一條邊一次,但是不要求回到出發點.
• 尤拉圖：圖當且僅存在歐拉回路.
• 半尤拉圖：圖當且僅存在尤拉路徑.

常規操作：

• 關於尤拉圖的問題,一般是判迴路的存在性或生成一個（半）尤拉圖的代價或方案.
• 判尤拉圖,即判存在迴路,這裡通過判點的度數來實現.
• 生成尤拉圖的代價,類似於一筆畫,這時候就要通過一些結論再判定一下即可.
• 求尤拉圖的方案,一般即為無向圖變有向圖,同時滿足尤拉圖.
• 一般的,通過並查集來合併歐拉回路點集

歐拉回路的判定：

1. 在無向圖中，每個點的度數都是偶數，則存在歐拉回路。
2. 在有向圖中，每個點的入度
   等於出度，則存在歐拉回路。

尤拉路徑的判定：

1. 在無向圖中，當且僅當所有點的度數為偶數或者除了兩個度數為奇數外其餘的全是偶數。
2. 在有向圖中，當且僅當該圖所有點的度數為0$0$或者 一個點的度數為1$1$，另一個度數為−1$-1$，其他點的度數為0$0$。

有關判定迴路的例題：HDU 1116 Play on Words

Description:

判斷 n個單詞是 否可以相連成一條鏈，兩的件個單詞是 否可以相連成一條鏈，兩的件個單詞是 否可以相連成一條鏈，兩的件前一個單 詞的最後字母和詞。

Solution:

• 通過每個單詞的首尾為邊，記錄點的入度與出度，
• 通過並查集判點集個數，進而判定是否為尤拉圖。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t)for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define SREP(i,f,t)for(int i=(f),i##_end_=(t);i<i##_end_;i++)
#define DREP(i,f,t)for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define db double
#define LL long long 
#define INF 0x3f3f3f3f
 

#define inf 0x3f3f3f3f3f3f3f
#define Sz(a)sizeof(a)
#define mcl(a,b)memset(a,b,Sz(a))
#define mcp(a,b)memcpy(a,b,Sz(b))
#define pb push_back
#define fi first
#define se second
template<class T>inline bool chkmin(T&x,T y){return y<x?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
inline LL Max(LL x,LL y){return x>y?x:y;}
inline LL Min(LL x,LL y){return x<y?x:y;}
typedef pair<int,int>PII;

#define N 30

int n;
char s[1002];
int In[N],Out[N],fa[N];

int find(int x){return x==fa[x]?x:find(fa[x]);}

void Clear(){
    mcl(In,0);
    mcl(Out,0);
    SREP(i,1,N)fa[i]=i;
}

int main(){
    int cas;scanf("%d",&cas);
    while(cas--){

        Clear();

        scanf("%d",&n);
        REP(i,1,n){
            scanf("%s",s);
            int len=strlen(s);
            int x=s[0]-'a'+1;
            int y=s[len-1]-'a'+1;
            Out[x]++;
            In[y]++;
            x=find(x),y=find(y);
            if(x!=y)fa[y]=x;
        }

        bool f=1;
        int innum=0,outnum=0,root=0;
        SREP(i,1,N){
            if(!In[i] && !Out[i])continue;
            if(fa[i]==i){
                root++;
                if(root>1){f=0;break;}
            }
            if(In[i]!=Out[i]){
                if(In[i]-Out[i]==1)innum++;
                else if(Out[i]-In[i]==1)outnum++;
                else {f=0;break;}
            }
        }

        if(f && ((!innum && !outnum) || (innum==1 && outnum==1)))puts("Ordering is possible.");
        else puts("The door cannot be opened.");
    }
    return 0;
}

有關（半）尤拉圖的代價問題： HDU 3018 Ant Trip

Description:

給出一張無向圖，求最少幾筆能畫完這張圖。

首先，我們需要知道一些性質：

1. 孤立點，代價為0$0$畫。
2. （半）尤拉圖，代價為1$1$畫。
3. 非（半）尤拉圖，代為為奇數度的點數/2畫。

Prove:

• 首先，（半）尤拉圖中點的度數都位偶數，那麼就會有出度等於入度，故為1畫；
• 其次，非（半）尤拉圖中存在點的度數為奇數，
• 對於每1畫，我們都會使一個連通量中的2$2$個奇數度點為偶數，
• 當最後一筆的時候我們必然消除所有的點的度數(包括剩下的兩個奇點,因為最後一筆就必然是尤拉路徑)。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t)for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define SREP(i,f,t)for(int i=(f),i##_end_=(t);i<i##_end_;i++)
#define DREP(i,f,t)for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define db double
#define LL long long 
#define INF 0x3f3f3f3f
#define inf 0x3f3f3f3f3f3f3f
#define Sz(a)sizeof(a)
#define mcl(a,b)memset(a,b,Sz(a))
#define mcp(a,b)memcpy(a,b,Sz(b))
#define pb push_back
#define fi first
#define se second
template<class T>inline bool chkmin(T&x,T y){return y<x?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
inline LL Max(LL x,LL y){return x>y?x:y;}
inline LL Min(LL x,LL y){return x<y?x:y;}
typedef pair<int,int>PII;

#define N 100002

/*
    此題我們可以知道一些性質:
    1.孤立點 -> 0 畫
    2.(半)尤拉圖 -> 1 畫
    3.非(半)尤拉圖 -> 奇數度的點個數/2 畫
*/

int n,m;
int fa[N];
int degree[N];
int sum[N],cnt[N];
// sum[i]表示該聯通量的點數 
// cnt[i]表示該聯通量的奇數度點數 

int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}

void Clear(){
    mcl(degree,0);
    mcl(sum,0);
    mcl(cnt,0); 
    REP(i,1,n)fa[i]=i;
}

int main(){
    while(~scanf("%d%d",&n,&m)){

        Clear();

        REP(i,1,m){
            int x,y;
            scanf("%d%d",&x,&y);
            degree[x]++,degree[y]++;
            x=find(x),y=find(y);
            if(x!=y)fa[x]=y;
        }

        REP(i,1,n){
            int root=find(i);
            sum[root]++;
            cnt[root]+=(degree[i]&1);
        }
        int ans=0;
        REP(i,1,n){
            if(sum[i]<2)continue;
            ans+=(!cnt[i])?1:(cnt[i]>>1);
        }
        printf("%d\n",ans);
    }
    return 0;
}

有關生成尤拉圖的方案問題：HDU 5348 MZL’s endless loop

Description:

給一個無向圖，讓你指定邊的方向，比如 a→b 為 1，a←b 為 0，在給所有邊指定方向後，對無向圖上的每個點，如果滿足|出度-入度|<2,那麼輸出任意一種方案。

Solution:

• 因為我們要滿足條件，
• 那麼就要儘可能有多的尤拉路徑，
• 那麼我們就根據入度與出度的大小關係，
• 進行dfs傳遞到該尤拉路徑中。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t)for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define SREP(i,f,t)for(int i=(f),i##_end_=(t);i<i##_end_;i++)
#define DREP(i,f,t)for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define db double
#define LL long long 
#define INF 0x3f3f3f3f
#define inf 0x3f3f3f3f3f3f3f
#define Sz(a)sizeof(a)
#define mcl(a,b)memset(a,b,Sz(a))
#define mcp(a,b)memcpy(a,b,Sz(b))
#define pb push_back
#define fi first
#define se second
template<class T>inline bool chkmin(T&x,T y){return y<x?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
inline LL Max(LL x,LL y){return x>y?x:y;}
inline LL Min(LL x,LL y){return x<y?x:y;}
typedef pair<int,int>PII;

#define N 100002
#define M 300002

int n,m;

int qwq,head[N];
struct edge{
    int to,next;
}E[M<<1];
void addedge(int x,int y){E[qwq]=(edge){y,head[x]};head[x]=qwq++;}

int degree[N],du[2][N];
bool vis[M<<1];
int ans[M];

void Clear(){
    mcl(degree,0);
    mcl(du,0);
    mcl(vis,0);
    qwq=0;
    mcl(head,-1);
    mcl(ans,-1);
}

void dfs(int x,int op){
    for(int &i=head[x];~i;i=E[i].next)if(!vis[i]){
        int y=E[i].to;
        if(y!=x && du[op][y]<du[op^1][y])continue;
        vis[i]=vis[i^1]=1;
        if(i&1)ans[i>>1]=op^1;
        else ans[i>>1]=op;
        du[op][x]++;
        du[op^1][y]++;
        dfs(y,op);
        break;
    }
}

int main(){
    int cas;cin>>cas;
    while(cas--){
        scanf("%d%d",&n,&m);

        Clear();

        SREP(i,0,m){
            int x,y;
            scanf("%d%d",&x,&y);
            degree[x]++,degree[y]++;
            addedge(x,y),addedge(y,x);
        }

        REP(i,1,n) while(du[0][i]+du[1][i]<degree[i]) dfs(i,(du[0][i]<=du[1][i])?0:1);

        SREP(i,0,m)printf("%d\n",ans[i]);
    }
    return 0;
}

Summary:

• 雖說尤拉圖是一個比較冷門的考點，但是難起來還是非常玄學的…蒟蒻太菜了
• 但是為了防冷門，這裡還是初學了一些皮毛除了判定，最多再求個方案或算個代價真的沒了呀...