Problem:
Score : 600 points

Problem Statement

Snuke's town has a subway system, consisting of N stations and M railway lines. The stations are numbered 1 through N. Each line is operated by a company. Each company has an identification number.

The i-th ( 1 \leq i \leq M ) line connects station p_i and q_i bidirectionally. There is no intermediate station. This line is operated by company c_i.

You can change trains at a station where multiple lines are available.

The fare system used in this subway system is a bit strange. When a passenger only uses lines that are operated by the same company, the fare is 1 yen (the currency of Japan). Whenever a passenger changes to a line that is operated by a different company from the current line, the passenger is charged an additional fare of 1 yen. In a case where a passenger who changed from some company A's line to another company's line changes to company A's line again, the additional fare is incurred again.

Snuke is now at station 1 and wants to travel to station N by subway. Find the minimum required fare.

Constraints

2 \leq N \leq 10^5

0 \leq M \leq 2×10^5

1 \leq p_i \leq N (1 \leq i \leq M)

1 \leq q_i \leq N (1 \leq i \leq M)

1 \leq c_i \leq 10^6 (1 \leq i \leq M)

p_i \neq q_i (1 \leq i \leq M)

Input

The input is given from Standard Input in the following format:

N M
p_1 q_1 c_1
:
p_M q_M c_M

Output

Print the minimum required fare. If it is impossible to get to station N by subway, print -1 instead.

Sample Input 1

3 3
1 2 1
2 3 1
3 1 2

Sample Output 1

1

Use company 1's lines: 1 → 2 → 3. The fare is 1 yen.

Sample Input 2

8 11
1 3 1
1 4 2
2 3 1
2 5 1
3 4 3
3 6 3
3 7 3
4 8 4
5 6 1
6 7 5
7 8 5

Sample Output 2

2

First, use company 1's lines: 1 → 3 → 2 → 5 → 6. Then, use company 5's lines: 6 → 7 → 8. The fare is 2 yen.

Sample Input 3

2 0

Sample Output 3

-1

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define ull unsigned long long
#define F first
#define S second
#define eps 1e-6
#define mp make_pair
const long long INF=1e18+2;
const int MX=100004;
int N, M, k;
ll arr[MX];
map<int, int> D[MX];
struct node
{
    int cost, col, n;
    node(int c1, int c2, int c3)
    {
        cost=c1;
        col=c2;
        n=c3;
    }
    bool operator <(const node &cur) const
    {
        if(cost == cur.cost)
        {
            if(col == cur.col) return n < cur.n;
            return col <= cur.col;
        }
        return cost >= cur.cost;
    }
};
set<node> st;
vector<node> G[MX];
//int D[MX];
int main()
{
    scanf("%d%d", &N, &M);
    for(int i=1; i<=M; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        G[a].pb(node(a, c, b));
        swap(a, b);
        G[a].pb(node(a, c, b));
    }
//    for(int i=1;i<=N;i++ ) D[i]=1e9+33;
//    D[1]=0;
    st.insert(node(0, -1, 1));
//    D[1][-1]++;
    while(st.size())
    {
        node cur=*st.begin();
        st.erase(st.begin());
        if(D[cur.n].find(cur.col) != D[cur.n].end())
        {
            if(D[cur.n][cur.col] <= cur.cost) continue;
        }
//        if(D[cur.n] < cur.cost) continue;
        for(int i=0; i<G[cur.n].size(); i++)
        {
            int ch=G[cur.n][i].n;
            if(ch == 1) continue;
 
            int co=0;
            if(cur.col != G[cur.n][i].col) ++co;
            if(D[ch].find(G[cur.n][i].col) == D[ch].end())
            {
                D[ch][G[cur.n][i].col]=D[cur.n][cur.col]+co;
                st.insert(node(D[ch][G[cur.n][i].col], G[cur.n][i].col, ch ));
            }
            else
            {
                if(D[ch][G[cur.n][i].col] > D[cur.n][cur.col]+co)
                {
                    D[ch][G[cur.n][i].col]=D[cur.n][cur.col]+co;
                    st.insert(node(D[ch][G[cur.n][i].col], G[cur.n][i].col, ch ));
                }
                else continue;
            }
//            if(D[ch] > D[cur.n]+co)
//            {
//                D[ch]=D[cur.n]+co;
//                st.insert(node(D[ch], G[cur.n][i].col, ch));
//            }
        }
    }
    map<int,int>::iterator it=D[N].begin();
    int mn=1e9;
    while(it != D[N].end())
    {
        mn=min(mn, it->S);
        it++;
    }
    if(mn == 1e9) mn=-1;
    cout<<mn<<" ";
//    if(D[N] == 1e9+33) D[N]=-1;
//    cout<<D[N]<<"\n";
    return 0;
}