hdu 3191 次短路

#include<iostream>
#include<cstdio>
#include<queue>
#include<string>
#include<vector>
#define INF 0x7fffffff
using namespace std;
const int V = 52;
const int E = 6005;
int n,m,s,t;
int dist[V][3],cnt[V][3];
bool hash[V][3];
struct Edge{
    int v,c;
    Edge(int vv = 0, int cc = 0):v(vv),c(cc){}
};
vector<Edge>edge[V];
struct node{
    int vexn,dist,flag;
    node(int vv = 0, int dd = 0, int ff = 0):vexn(vv),dist(dd),flag(ff){}
    bool operator<(const node &a)const
    {
        return dist != a.dist?dist > a.dist:vexn > a.vexn;
    }   
};
bool djkstra(int src,int n,int e)
{
    priority_queue<node> q;
    int i,v,k,c;
    node N;
    for(i = 0; i< n; i++)
    {
        dist[i][0] = dist[i][1] = INF;
    }
    memset(hash,false,sizeof(hash));
    cnt[src][0] = 1;
    dist[src][0] = 0;
    q.push(node(src,0,0));
    while(!q.empty())
    {
        N = q.top();
        q.pop();
        if(dist[N.vexn][N.flag] != N.dist)continue;
        if(hash[N.vexn][N.flag])continue;
        hash[N.vexn][N.flag] = true;
        for(i = 0; i < edge[N.vexn].size(); i++)
        {
            v = edge[N.vexn][i].v;
            c = edge[N.vexn][i].c;
                if(!hash[v][0] && dist[v][0] > N.dist + c)
                {
                    if(dist[v][0] != INF)
                    {
                        dist[v][1] = dist[v][0];
                        cnt[v][1] = cnt[v][0];
                        q.push(node(v,dist[v][1],1));
                    }
                    dist[v][0] = N.dist + c;
                    cnt[v][0]  = cnt[N.vexn][N.flag];
                    q.push(node(v,dist[v][0],0));
                }
                else if(!hash[v][0] && dist[v][0] == N.dist + c)
                {
                    cnt[v][0] += cnt[N.vexn][N.flag];
                }
                else if(!hash[v][1] && dist[v][1] > N.dist + c)
                {
                    dist[v][1] = N.dist + c;
                    cnt[v][1]  = cnt[N.vexn][N.flag];
                    q.push(node(v,dist[v][1],1));
                }
                else if(!hash[v][1] && dist[v][1] == N.dist + c)
                {
                    cnt[v][1] += cnt[N.vexn][N.flag];
                }
        //    }
        }
    }
    if(dist[e][0] == INF)
    return false;
    return true;
}
void solve()
{
    int ss;
    Edge tem;
    for(int i = 0; i<= n; i++)
    {
        cnt[i][0] = cnt[i][1] = 0;
        edge[i].clear();
    }
    for(int i = 1; i<= m; i++)
    {
        scanf("%d %d %d",&ss, &tem.v, &tem.c);
        edge[ss].push_back(tem);       
    }
    djkstra(s,n,t);
    printf("%d %d/n",dist[t][1],cnt[t][1]);
}
int main()
{
    while(scanf("%d

%d %d %d",&n, &m, &s, &t) != EOF)
    {
        solve();
    }
}

//朴素dij

#include<iostream>
#include<cstdio>
#include<queue>
#include<string>
#include<vector>
#define INF 0x7fffffff
using namespace std;
const int V = 52;
const int E = 6005;
int n,m,s,t;
int dist[V][3],cnt[V][3];
bool hash[V][3];
struct Edge{
    int v,c;
    Edge(int vv = 0, int cc = 0):v(vv),c(cc){}
};
vector<Edge>edge[V];
bool djkstra(int src,int n,int e)
{
    int i,v,k,c;
    for(i = 0; i< n; i++)
    {
        dist[i][0] = dist[i][1] = INF;
    }
    memset(hash,false,sizeof(hash));
    cnt[src][0] = 1;
    dist[src][0] = 0;
    int Min,u,flag;
    for(i = 0; i <2 * n; i++)
    {
        Min = INF;
        u = -1;
        for(int j = 0; j < n; j++)
        {
            if(!hash[j][0] && dist[j][0] < Min)
            {
                u = j;
                Min = dist[j][0];
                flag = 0;
            }
            if(!hash[j][1] && dist[j][1] < Min)
            {
                u = j;
                Min = dist[j][1];
                flag = 1;
            }
        }
        if(u == -1)
        return false;
        hash[u][flag] = true;
        for(i = 0; i < edge[u].size(); i++)
        {
            v = edge[u][i].v;
            c = edge[u][i].c;
            if(!hash[v][0] && dist[v][0] > Min + c)
            {
                    dist[v][1] = dist[v][0];
                    cnt[v][1] = cnt[v][0];
                    dist[v][0] = Min + c;
                    cnt[v][0]  = cnt[u][flag];
            }
            else if(!hash[v][0] && dist[v][0] == Min + c)
            {
                cnt[v][0] += cnt[u][flag];
            }
            else if(!hash[v][1] && dist[v][1] > Min + c)
            {
                dist[v][1] = Min + c;
                cnt[v][1]  = cnt[u][flag];
            }
            else if(!hash[v][1] && dist[v][1] == Min + c)
            {
                cnt[v][1] += cnt[u][flag];
            }
        }
    }
    if(dist[e][0] == INF)
    return false;
    return true;
}
void solve()
{
    int ss;
    Edge tem;
    for(int i = 0; i<= n; i++)
    {
        cnt[i][0] = cnt[i][1] = 0;
        edge[i].clear();
    }
    for(int i = 1; i<= m; i++)
    {
        scanf("%d %d %d",&ss, &tem.v, &tem.c);
        edge[ss].push_back(tem);       
    }
    djkstra(s,n,t);
    printf("%d %d/n",dist[t][1],cnt[t][1]);
}
int main()
{
    while(scanf("%d %d %d %d",&n, &m, &s, &t) != EOF)
    {
        solve();
    }
}