#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#include <time.h>
#include <stack>
#include <array>
#include <list>
#include <atcoder/all>
#define popcount __builtin_popcount
using namespace std;
using namespace atcoder;
typedef long long ll;
typedef pair<int, int> P;
int n, m;
vector<P> g[100010];
char c[200020];
int a[200020], b[200020];
int main()
{
    cin>>n>>m;
    
    for(int i=0; i<m; i++){
        cin>>a[i]>>b[i]>>c[i];
        a[i]--; b[i]--;
        g[a[i]].push_back({b[i],i});
        g[b[i]].push_back({a[i],i});
    }
    auto e0=g[0][0];
    int k=0;
    for(;k<m; k++){
        if(c[e0.second]!=c[k]) break;
    }
    if(k==m){
        cout<<-1<<endl;
        return 0;
    }
    auto calc=[&](int s, int t)->vector<int>{
        int d[100010];
        fill(d, d+n, n+1);
        queue<int> que; que.push(s);
        d[s]=0;
        while(!que.empty()){
            int x=que.front(); que.pop();
            for(auto q:g[x]){
                int y=q.first;
                if(d[y]>d[x]+1){
                    d[y]=d[x]+1;
                    que.push(y);
                }
            }
        }
        vector<int> res;
        while(s!=t){
            for(auto q:g[t]){
                if(d[t]-1==d[q.first]){
                    res.push_back(q.second);
                    t=q.first;
                    break;
                }
            }
        }
        reverse(res.begin(), res.end());
        return res;
    };
    int s=e0.first;
    auto sa=calc(s, a[k]), sb=calc(s, b[k]);
    auto bt=calc(b[k], n-1), at=calc(a[k], n-1);
    if(sa.size()+bt.size()>sb.size()+at.size()){
        swap(sa, sb), swap(bt, at);
    }
    vector<int> ans{e0.second};
    for(auto i:sa) ans.push_back(i);
    ans.push_back(k);
    for(auto i:bt) ans.push_back(i);
    for(int l=0; ; l++){
        bool ok=0;
        int K=ans.size();
        for(int i=0; i<K; i++){
            if(c[ans[i]]!=c[ans[K-1-i]]){
                ok=1;break;
            }
        }
        if(ok){
            cout<<K<<endl;
            for(auto i:ans){
                cout<<i+1<<endl;
            }
            return 0;
        }
        ans.insert(ans.begin(), e0.second);
        ans.insert(ans.begin(), e0.second);
    }

    // map<char, int> mp1, mpn;
    // for(auto e1:g[0]) mp1[c[e1.second]]=e1.second;
    // for(auto e1:g[n-1]) mpn[c[e1.second]]=e1.second;
    // for(auto p:mp1) for(auto q:mpn){
    //     if(p.first!=q.first){
    //         vector<int> ans;
    //         ans.push_back(p.second);
    //         int d[100010];
    //         fill(d, d+n, n+1);
    //         int s, t;
    //         if(a[p.second]==0){
    //             s=b[p.second];
    //         }else{
    //             s=a[p.second];
    //         }
    //         if(a[q.second]==n-1){
    //             t=b[p.second];
    //         }else{
    //             t=a[p.second];
    //         }
    //         d[s]=0;
    //         queue<int> que;
    //         que.push(s);
    //         while(!que.empty()){

    //         }
    //     }
    // }
    return 0;
}