JOJ 2414 && POJ 1637 Sightseeing tour（混合欧拉回路）

 

用的邻接阵的最一般的方法EK算法跑了0.22s 是JOJ最慢的。。。

#include <cstdio>
#include <string.h>
#define min(a,b) ((a)>(b))?(b):(a)

using namespace std ;

const int maxn=205;
const int maxm=1005;
const int Inf=0x7fffffff;
int cap[maxn][maxn],flow[maxn][maxn],p[maxn],minflow[maxn],q[maxn];
int deg[maxn];
int n,m;

int maxflow(int s , int t)
{
    int f=0,u,v,rear,head;
    memset(flow , 0 , sizeof(flow));
    while (true)
    {
       memset(minflow , 0 , sizeof(minflow));
       minflow[s]=Inf;
       head=0;
       rear=1;
       q[head]=s;
       while (rear>head)
       {
            u=q[head];head++;
            for (v=s ; v<=t ; ++v)
            {
                 if(!minflow[v] && cap[u][v]>flow[u][v])
                 {
                    p[v]=u;
                    q[rear]=v;rear++;
                    minflow[v]=min(minflow[u],cap[u][v]-flow[u][v]);
                 }
            }
       }
       //printf("mint=%d\n",minflow[t]);
       if(!minflow[t])break;
       for (u=t ; u!=s ; u=p[u])
       {
            flow[u][p[u]]-=minflow[t];
            flow[p[u]][u]+=minflow[t];
       }
       f+=minflow[t];
    }
    return f;
}

int main ()
{
    int cas,i,j,u,v,d,sum;
    //freopen ("in.txt","r",stdin);
    //freopen ("out.txt","w",stdout);
    scanf("%d",&cas);
    while (cas--)
    {
        memset (cap , 0 , sizeof(cap));
        memset (deg , 0 , sizeof(deg));
        sum=0;
        scanf("%d%d",&n,&m);
        for (i=0 ; i<m ; ++i)
        {
            scanf("%d%d%d",&u,&v,&d);
            if(v!=u)
            deg[v]++,deg[u]--;
            if(!d)cap[u][v]+=1;
        }
        const int t=n+1;
        bool flag=true;
        for (i=1 ; i<=n  ; ++i)
        {
            //printf("%d\n",deg[i]);
            if(deg[i]&1){flag=false ; break; }
            deg[i]>>=1;
            if(deg[i]>0)cap[i][t]=deg[i],sum+=deg[i];
            if(deg[i]<0)cap[0][i]=-deg[i];
        }
        if(flag)
        {
            int ans=maxflow(0,t);
            //printf("%d %d\n",ans , sum);
            if(ans==sum)printf("possible\n");
            else printf("impossible\n");
        }
        else printf("impossible\n");
    }
    return 0;
}

之后引用了达哥的模板 SAP的GAP优化 果断到了0.05s

不过模板归模板，毕竟不是自己的东西，还是有几行没看懂

达哥解释是gap[dist[p]]==0，有一层为0，就是断层，
dist[0]>n  说明水回流超过顶部，所以返回-1

 代码还是太精炼很难看懂

#include <cstdio>
#include <string.h>
#define min(a,b) ((a)>(b))?(b):(a)

using namespace std ;

const int maxn=205;
const int maxm=1005;
const int Inf=0x4fffffff;
int cap[maxn][maxn],dist[maxn],gap[maxn];
int deg[maxn];
int n,m;

int dfs (int p , int limit=Inf)
{
    if(p==n)return limit;
    for (int i=0 ; i<=n ; ++i)
    {
        if(dist[p]==dist[i]+1 && cap[p][i]>0)
        {
            int t=dfs(i,min(limit , cap[p][i]));
            if(t<0)return t;
            if(t>0)
            {
                cap[p][i]-=t;
                cap[i][p]+=t;
                return t;
            }
        }
    }
    int tmp=n+1 ;
    for (int i=0 ; i<=n ; ++i)
        if(cap[p][i]>0)
            tmp=min(tmp,dist[i]+1);
    if(--gap[dist[p]]==0 || dist[0]>n)return -1;
    ++gap[dist[p]=tmp];
    return 0;
}
int SAP()
{
    gap[0]=n+1;
    int f = 0 , t=0;
    while (~(t=dfs(0))) f+=t;
    //printf("%d\n",t);
    return f;
}
int main ()
{
    int cas,i,j,u,v,d,sum;
    //freopen ("in.txt","r",stdin);
    //freopen ("out.txt","w",stdout);
    scanf("%d",&cas);
    while (cas--)
    {
        memset (cap , 0 , sizeof(cap));
        memset (deg , 0 , sizeof(deg));
        memset (dist , 0 , sizeof(dist));
        memset (gap , 0 , sizeof(gap));
        sum=0;
        scanf("%d%d",&n,&m);
        for (i=0 ; i<m ; ++i)
        {
            scanf("%d%d%d",&u,&v,&d);
            if(v!=u)
                deg[v]++,deg[u]--;
            if(!d)cap[u][v]++;
        }
        n++;
        bool flag=true;
        for (i=1 ; i<n  ; ++i)
        {
            //printf("%d\n",deg[i]);
            if(deg[i]&1)
            {
                flag=false ;
                break;
            }
            deg[i]>>=1;
            if(deg[i]>0)cap[i][n]=deg[i],sum+=deg[i];
            if(deg[i]<0)cap[0][i]=-deg[i];
        }
        if(flag)
        {
            //printf("%d %d\n",ans , sum);
            if(sum==SAP())printf("possible\n");
            else printf("impossible\n");
        }
        else printf("impossible\n");
    }
    return 0;
}

改成邻接表之后一直是WA ， 不知道为什么

#include <cstdio>
#include <string.h>
const int maxn=205;
const int maxm=4050;//边是双向存的（注意不是无向）要开正常的2倍大
const int inf=0x7fffffff;
int head[maxn];
struct Edge{
    int v,next,w;
} edge[maxm];
int cnt,n,deg[maxn];
int s=0,t;
void addedge(int u,int v,int w)//这里存的还是一条有向边
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].v=u;
    edge[cnt].w=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;
    printf("u=%d v=%d w=%d \n",u ,v,w);
}
int SAP(){
    int pre[maxn],cur[maxn],dis[maxn],gap[maxn];
    int flow=0,aug=inf,u;
    bool flag;
    for(int i=0; i<n; i++){
        cur[i]=head[i];
        gap[i]=dis[i]=0;
        //printf("i=%d gap=%d cur = %d head=%d\n",i,gap[i],cur[i],head[i]);
    }//初始化
    gap[s]=n;
    u=pre[s]=s;
    while(dis[s]<n){
        flag=0;
        for(int &j=cur[u]; j!=-1; j=edge[j].next){
            int v=edge[j].v;
            if(edge[j].w>0&&dis[u]==dis[v]+1){
               flag=1;
               if(edge[j].w<aug) aug=edge[j].w;
               pre[v]=u;
               u=v;
               printf("u=%d  aug=%d\n" ,u,aug);
               if(u==t){
                    flow+=aug;
                    printf("%d\n",flow);
                    while(u!=s){
                       u=pre[u];
                       edge[cur[u]].w-=aug;
                       edge[cur[u]^1].w+=aug;//异或是找与其配对的边
                    }
                    aug=inf;
                }
                break;
            }
        }
        if(flag) continue;
        int mindis=n;
        for(int j=head[u]; j!=-1; j=edge[j].next){
            int v=edge[j].v;
            if(edge[j].w>0&&dis[v]<mindis){
                mindis=dis[v];
                cur[u]=j;
            }
        }
        //printf("g=%d  d=%d\n",gap[dis[u]],dis[u]);
        if((--gap[dis[u]])==0)
            break;
        gap[dis[u]=mindis+1]++;
        //printf("g=%d  d=%d\n",gap[dis[u]],mindis+1);
        u=pre[u];
    }
    return flow;
}

void init ()
{
    cnt=0;
    memset (head,-1,sizeof(head));
    memset (deg , 0 , sizeof(deg));
}

int  main()
{
    int m,u,v,d,sum;
    int cas;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        init ();
        for (int i=0 ; i<m ; ++i)
        {
            scanf("%d%d%d",&u,&v,&d);
            deg[v]++,deg[u]--;
            if(!d)addedge(u,v,1),addedge(u , v , 1);
        }
        bool flag=true;
        t=++n;sum=0;
        for (int i=1 ; i<n ; ++i)
        {
            //printf("%d\n",deg[i]);
            if(deg[i]&1)
            {flag=false ; break;}
            deg[i]>>=1;
            if(deg[i]>0)addedge(i,t,deg[i]),addedge(t,i,deg[i]),sum+=deg[i];
            if(deg[i]<0)addedge(0,i,-deg[i]),addedge(i,0,-deg[i]);
            //printf("%d %d %d \n ",i , t , deg[i]);
        }
        if(flag)
        {
            int ans=SAP();
            printf("%d %d\n",sum,ans);
            if(sum==ans)printf("possible\n");
            else printf("impossible\n");
        }
        else printf("impossible\n");
    }
    return 0;
}

 

 

看到一篇不错的文章，发给大家看看：

求最大流有一种经典的算法，就是每次找增广路时用BFS找，保证找到的增广路是弧数最少的，也就是所谓的Edmonds-Karp算法。可以证明的是在使用最短路增广时增广过程不超过V*E次，每次BFS的时间都是O(E)，所以Edmonds-Karp的时间复杂度就是O(V*E^2)。

如果能让每次寻找增广路时的时间复杂度降下来，那么就能提高算法效率了，使用距离标号的最短增广路算法就是这样的。所谓距离标号，就是某个点到汇点的最少的弧的数量（另外一种距离标号是从源点到该点的最少的弧的数量，本质上没什么区别）。设点i的标号为D[i]，那么如果将满足D[i]=D[j]+1的弧(i,j)叫做允许弧，且增广时只走允许弧，那么就可以达到“怎么走都是最短路”的效果。每个点的初始标号可以在一开始用一次从汇点沿所有反向边的BFS求出，实践中可以初始设全部点的距离标号为0，问题就是如何在增广过程中维护这个距离标号。

维护距离标号的方法是这样的：当找增广路过程中发现某点出发没有允许弧时，将这个点的距离标号设为由它出发的所有弧的终点的距离标号的最小值加一。这种维护距离标号的方法的正确性我就不证了。由于距离标号的存在，由于“怎么走都是最短路”，所以就可以采用DFS找增广路，用一个栈保存当前路径的弧即可。当某个点的距离标号被改变时，栈中指向它的那条弧肯定已经不是允许弧了，所以就让它出栈，并继续用栈顶的弧的端点增广。为了使每次找增广路的时间变成均摊O(V)，还有一个重要的优化是对于每个点保存“当前弧”：初始时当前弧是邻接表的第一条弧；在邻接表中查找时从当前弧开始查找，找到了一条允许弧，就把这条弧设为当前弧；改变距离标号时，把当前弧重新设为邻接表的第一条弧，还有一种在常数上有所优化的写法是改变距离标号时把当前弧设为那条提供了最小标号的弧。当前弧的写法之所以正确就在于任何时候我们都能保证在邻接表中当前弧的前面肯定不存在允许弧。

还有一个常数优化是在每次找到路径并增广完毕之后不要将路径中所有的顶点退栈，而是只将瓶颈边以及之后的边退栈，这是借鉴了Dinic算法的思想。注意任何时候待增广的“当前点”都应该是栈顶的点的终点。这的确只是一个常数优化，由于当前边结构的存在，我们肯定可以在O(n)的时间内复原路径中瓶颈边之前的所有边。

优化：

1.邻接表优化：

如果顶点多的话，往往N^2存不下，这时候就要存边：

存每条边的出发点，终止点和价值，然后排序一下，再记录每个出发点的位置。以后要调用从出发点出发的边时候，只需要从记录的位置开始找即可（其实可以用链表）。优点是时间加快空间节省，缺点是编程复杂度将变大，所以在题目允许的情况下，建议使用邻接矩阵。

2.GAP优化：

如果一次重标号时，出现距离断层，则可以证明ST无可行流，此时则可以直接退出算法。

3.当前弧优化：

为了使每次找增广路的时间变成均摊O(V)，还有一个重要的优化是对于每个点保存“当前弧”：初始时当前弧是邻接表的第一条弧；在邻接表中查找时从当前弧开始查找，找到了一条允许弧，就把这条弧设为当前弧；改变距离标号时，把当前弧重新设为邻接表的第一条弧。

学过之后又看了算法速度的比较，发现如果写好的话SAP的速度不会输给HLPP。