HDU 6386 Age of Moyu（最短路+set）

Description

给出一条$n$个点$m$条边的无向图，每条边有颜色，如果当前边的颜色与前一条边的颜色相同则当前边边权为$0$，否则为$1$，问$1$到$n$的最短路长度

Input

多组用例，每组用例首先输入两整数$n,m$表示点数和边数，之后$m$行每行输入三个整数$u,v,c$表示$u,v$之间有一条颜色为$c$的边

$(2\le n\le 10^5,0\le m\le 2\cdot 10^5,1\le c_i\le 10^6)$

Output

输出$1$到$n$的最短路径长度，如果两点间不可达则输出$-1$

Sample Input

3 3
1 2 1
1 3 2
2 3 1
2 0
3 2
1 2 1
2 3 2

Sample Output

1
-1
2

Solution

最短路，对于每个点用一个$set$记录到达该点的所有最短路径的最后一条边的颜色，每次通过边$u\rightarrow v$更新时，判断这条边的颜色是否在$u$的$set$里出现过，如果出现过那么这条边边权为$0$，否则这条边边权为$1$

Code

#include<cstdio>
#include<algorithm>
#include<queue>
#include<set>
using namespace std;
namespace fastIO 
{
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror=0;
    inline char nc() 
    {
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if(p1==pend) 
        {
            p1=buf;
            pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if(pend==p1) 
            {
                IOerror=1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) 
    {
        return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';
    }
    inline void read(int &x) 
    {
        char ch;
        while(blank(ch=nc()));
        if(IOerror)return;
        int sgn=1;
        if(ch=='-')sgn=-1;
        for(x=ch-'0';(ch=nc())>='0'&&ch<='9';x=x*10+ch-'0');
        x=sgn*x;
    }
    #undef BUF_SIZE
};
using namespace fastIO;
const int INF=0x3f3f3f3f,maxn=100005;
typedef pair<int,int>P;
struct edge
{
    int to,next,type;
}g[4*maxn];
int n,m,head[maxn],tol,dis[maxn],vis[maxn];
set<int>s[maxn];
void add(int u,int v,int c)
{
    g[tol].type=c;
    g[tol].to=v;
    g[tol].next=head[u];
    head[u]=tol++;
}
void Dijkstra()
{
    priority_queue<P>que;
    for(int i=1;i<=n;i++)dis[i]=INF;
    dis[1]=0;
    que.push(P(0,1));
    while(!que.empty())
    {
        P p=que.top();
        que.pop();
        int u=p.second,w=-p.first;
        if(dis[u]<w) continue;
        for(int i=head[u];~i;i=g[i].next)
        {
            int v=g[i].to,c=w;
            if(s[u].find(g[i].type)==s[u].end())c++;
            if(dis[v]>c)
            {
                dis[v]=c;
                s[v].clear();
                s[v].insert(g[i].type);
                que.push(P(-dis[v],v));
            }
            else if(dis[v]==c)s[v].insert(g[i].type);
        }
    }
}
void spfa()
{
    queue<int>que;
    for(int i=1;i<=n;i++)vis[i]=0,dis[i]=INF;
    dis[1]=0,vis[1]=1;
    que.push(1);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        vis[u]=0;
        for(int i=head[u];~i;i=g[i].next)
        {
            int v=g[i].to,c=dis[u];
            if(s[u].find(g[i].type)==s[u].end())c++;
            if(dis[v]>c)
            {
                dis[v]=c;
                s[v].clear();
                s[v].insert(g[i].type);
                if(!vis[v])vis[v]=1,que.push(v);
            }
            else if(dis[v]==c&&s[v].find(g[i].type)==s[v].end())
            {
                s[v].insert(g[i].type);
                if(!vis[v])vis[v]=1,que.push(v);
            }
        }
    }
}
int main()
{
    while(1)
    {
        read(n),read(m);
        if(IOerror)break;
        tol=0;
        for(int i=1;i<=n;i++)head[i]=-1,s[i].clear();
        while(m--)
        {
            int u,v,w;
            read(u),read(v),read(w);
            //scanf("%d%d%d",&u,&v,&w);
            add(u,v,w),add(v,u,w);
        }
        Dijkstra();
        //spfa();
        printf("%d\n",dis[n]==INF?-1:dis[n]);
    }
    return 0;
}