sgu 185 Two shortest(最短路+最大流)

一开始读错题啦，以为是求所有的最短路。原来是求边不重复的最短路条数。

这样的话就和hdu 3599一样一样的了。建图：点击打开链接

唯一不同的是，需要输出两个方案来。

那么就作两次DFS就好了，第一次DFS访问顶点时，同时将访问的边给删掉。

一开始WA on test 6，原因是新建图的时候忘了加Map[i][j]!=0的条件，导致有的两个顶点本没有边，结果也给加到新建的图里去了_(:3 」∠)_

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define maxn 405
#define inf 0x3f3f3f3f
struct Edge
{
    int to,cap,next;
}edge[160005];

int cnt,head[maxn],d[maxn],low[maxn],s,t,Map[maxn][maxn],n;
inline void add(int u,int v,int w)
{
    edge[cnt].to=v;
    edge[cnt].cap=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

inline bool bfs()   //BFS构造层次图
{
    int u,i;
    queue<int> q;
    q.push(s);
    memset(d,0,sizeof(d));
    d[s]=1;
    while(!q.empty())
    {
        u=q.front();q.pop();
        if(u==t) return true;   //汇点的层次被算出即可停止，因为根据DFS的规则，和汇点同层或更下一层的结点是不可能走到汇点的。
        for(i=head[u];~i;i=edge[i].next){
            int v=edge[i].to;
            if(!d[v]&&edge[i].cap)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int a)  //当前结点、目前为止所有弧的最小残量
{
    int flow=0,f,i;
    if(u==t||a==0) return a;
    for(i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(edge[i].cap&&d[v]==d[u]+1)   //满足容量不为0且另一端是下一层次
        {
            f=dfs(v,min(a,edge[i].cap));
            edge[i].cap-=f; //削减路径上各边的容量
            edge[i^1].cap+=f;//添加反向边
            flow+=f;    //增加总流量
            a-=f;   //该结点之前的弧的最小残量削减f后的值
            if(!a) break;   //若为0，则无需再从该结点寻找增广路，因为位于该结点之前的某条弧削减f后会为0，导致无法从源点经过该结点再增广到汇点
        }
    }
    if(flow==0) d[u]=0; //从该点出发找不到增广路，则将该点从层次图中去掉
    return flow;
}

int dinic()
{
    for(int i=1;i<=n;++i)
        for(int j=1;j<=n;++j)
            if(i!=j&&Map[i][j]&&low[i]+Map[i][j]==low[j]) add(i,j,1);
    int ans=0;
    while(bfs()) ans+=dfs(s,inf);
    return ans;
}

bool vis[maxn];
void spfa()
{
    memset(vis,0,sizeof(vis));
    memset(low,inf,sizeof(low));
    low[1]=0;
    vis[1]=1;
    queue<int> q;
    q.push(1);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        vis[u]=0;
        for(int v=1;v<=n;++v)
        {
            if(Map[u][v]&&low[v]>low[u]+Map[u][v])
            {
                low[v]=low[u]+Map[u][v];
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}

bool flag;
void DFS(int u)
{
    if(flag) return;
    if(u==n){
        printf("%d\n",u);
        flag=1;
        return;
    }
    printf("%d ",u);
    for(int i=head[u];(~i)&&!flag;i=edge[i].next)
    {
        int v=edge[i].to;
        if((i%2==0)&&edge[i].cap==0){
            edge[i].cap=-1;
            DFS(v);
        }
    }
}

int main()
{
    int a,b,c,m;
    while(~scanf("%d%d",&n,&m)){
        s=1,t=n;
        cnt=0;
        flag=0;
        memset(head,-1,sizeof(head));
        memset(Map,0,sizeof(Map));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            Map[a][b]=c;
            Map[b][a]=c;
        }
        spfa();
        if(dinic()>=2)
        {
            DFS(1);
            flag=0;
            DFS(1);
        }
        else puts("No solution");
    }
    return 0;
}