#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define fi first
#define se second
#define For(i, l, r) for (auto i = (l); i < (r); i++)
#define ForE(i, l, r) for (auto i = (l); i <= (r); i++)
#define FordE(i, l, r) for (auto i = (l); i >= (r); i--)
#define Fora(v, a) for (auto v: (a))
#define bend(a) (a).begin(), (a).end()
#define isz(a) ((signed)(a).size())

using ll = long long;
using ld = long double;
using pii = pair <int, int>;
using vi = vector <int>;
using vpii = vector <pii>;
using vvi = vector <vi>;

const int N = 2e5 + 5, K = 50, LN = 18;

int n, q;
bool a[N];
vpii adj[N];

int h[N];
ll d[N];

int sz[N];
int ctrtour, tin[N], tout[N];
int nxt[N];

void dfs_par(int u, int p = -1){
	for (auto &[v, w]: adj[u]){
		if (v == p){
			continue;
		}
		h[v] = h[u] + 1;
		d[v] = d[u] + w;
		dfs_par(v, u);
	}
	for (auto itr = adj[u].begin(); itr != adj[u].end(); itr++){
		if (itr->fi == p){
			adj[u].erase(itr);
			break;
		}
	}
}

void dfs_sz(int u){
	sz[u] = 1;
	for (auto &edge: adj[u]){
		int v = edge.fi;
		dfs_sz(v);
		sz[u] += sz[v];
		if (sz[adj[u][0].fi] < sz[v]){
			swap(adj[u][0], edge);
		}
	}
}

void dfs_tour(int u){
	tin[u] = ++ctrtour;
	for (auto &[v, w]: adj[u]){
		nxt[v] = (v == adj[u][0].fi ? nxt[u] : v);
		dfs_tour(v);
	}
	tout[u] = ctrtour;
}

int min_h(int u, int v){
	return h[u] < h[v] ? u : v;
}

int max_h(int u, int v){
	return h[u] > h[v] ? u : v;
}

int ctrtour_lca, tour_lca[N], tin_lca[N];
int sptb[LN + 1][N * 2];

void dfs_lca(int u){
	tour_lca[++ctrtour_lca] = u;
	tin_lca[u] = ctrtour_lca;
	for (auto &[v, w]: adj[u]){
		dfs_lca(v);
		tour_lca[++ctrtour_lca] = u;
	}
}

int lca(int u, int v){
	if (tin_lca[u] > tin_lca[v]){
		swap(u, v);
	}
	int z = __lg(tin_lca[v] - tin_lca[u] + 1);
	return min_h(sptb[z][tin_lca[u]], sptb[z][tin_lca[v] - (1 << z) + 1]);
}

ll dist(int u, int v){
	int w = lca(u, v);
	return d[u] + d[v] - 2 * d[w];
}

int cnt_chain = 0;
int idx_chain[N];

struct segment_tree{
	static pair <int, int> merge_pair(const pair <int, int>& lhs, const pair <int, int>& rhs){
		return pair{min_h(lhs.fi, rhs.fi), max_h(lhs.se, rhs.se)};
	}

	struct node{
		pair <int, int> mnmx[K];

		node(){
			fill(mnmx, mnmx + cnt_chain, pair{N - 1, N - 2});
		}

		friend node merge(const node& lhs, const node& rhs){
			node ans;
			For(i, 0, cnt_chain){
				ans.mnmx[i] = merge_pair(lhs.mnmx[i], rhs.mnmx[i]);
			}
			return ans;
		}
	};

	node seg[1 << 19];

	void build(int id, int l, int r){
		seg[id] = node();
		if (l == r){
			seg[id].mnmx[idx_chain[l]] = pair{a[l] ? l : N - 1, a[l] ? l : N - 2};
			return;
		}
		int mid = (l + r) >> 1;
		build(id * 2, l, mid);
		build(id * 2 + 1, mid + 1, r);
		seg[id] = merge(seg[id * 2], seg[id * 2 + 1]);
	}

	void update(int id, int l, int r, int i){
		if (l == r){
			a[l] ^= 1;
			seg[id].mnmx[idx_chain[l]] = pair{a[l] ? l : N - 1, a[l] ? l : N - 2};
			return;
		}
		int mid = (l + r) >> 1;
		if (i <= mid){
			update(id * 2, l, mid, i);
		}
		else{
			update(id * 2 + 1, mid + 1, r, i);
		}
		seg[id] = merge(seg[id * 2], seg[id * 2 + 1]);
	}

	node query(int id, int l, int r, int u, int v){
		if (u <= l and r <= v){
			return seg[id];
		}
		int mid = (l + r) >> 1;
		if (v < mid + 1){
			return query(id * 2, l, mid, u, v);
		}
		if (mid < u){
			return query(id * 2 + 1, mid + 1, r, u, v);
		}
		return merge(query(id * 2, l, mid, u, v), query(id * 2 + 1, mid + 1, r, u, v));
	}
} seg;

signed main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	// freopen("KEK.inp", "r", stdin);
	// freopen("KEK.out", "w", stdout);
	h[N - 2] = -1; h[N - 1] = N;

	cin >> n >> q;
	ForE(u, 1, n){
		char c; cin >> c;
		a[u] = c - '0';
	}
	For(i, 1, n){
		int u, v, w; cin >> u >> v >> w;
		adj[u].emplace_back(v, w);
		adj[v].emplace_back(u, w);
	}

	dfs_par(1);
	dfs_sz(1);
	nxt[1] = 1;
	dfs_tour(1);

	dfs_lca(1);
	ForE(i, 1, ctrtour_lca){
		sptb[0][i] = tour_lca[i];
	}
	For(j, 1, LN + 1){
		ForE(i, 1, ctrtour_lca - (1 << j) + 1){
			sptb[j][i] = min_h(sptb[j - 1][i], sptb[j - 1][i + (1 << (j - 1))]);
		}
	}

	ForE(u, 1, n){
		if (nxt[u] == u){
			idx_chain[u] = cnt_chain++;
		}
	}
	ForE(u, 1, n){
		idx_chain[u] = idx_chain[nxt[u]];
	}
	seg.build(1, 1, n);

	while (q--){
		int type; cin >> type;
		if (type == 1){
			int u;
			cin >> u;
			seg.update(1, 1, n, u);
		}
		else{
			int l, r;
			cin >> l >> r;
			segment_tree::node val = seg.query(1, 1, n, l, r);
			vector <int> subset;
			int w = -1;
			For(i, 0, cnt_chain){
				if (val.mnmx[i].fi == N - 1){
					continue;
				}
				w = (w == -1 ? val.mnmx[i].fi : lca(w, val.mnmx[i].fi));
				subset.emplace_back(val.mnmx[i].se);
			}
			if (w == -1){
				cout << -1 << endl;
				continue;
			}
			subset.emplace_back(w);
			sort(bend(subset), [&](int u, int v){
				return tin[u] < tin[v];
			});
			ll ans = 0;
			For(i, 0, isz(subset)){
				int j = i + 1;
				if (j == isz(subset)) j = 0;
				ans += dist(subset[i], subset[j]);
			}
			cout << ans << endl;
		}
	}
}

/*
==================================================+
INPUT                                             |
--------------------------------------------------|

--------------------------------------------------|
==================================================+
OUTPUT                                            |
--------------------------------------------------|

--------------------------------------------------|
==================================================+
*/