// An AC a day keeps the doctor away.
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#ifdef local
#define safe std::cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(args...) qqbx(#args, args)
#define orange(args...) danb(#args, args)
using std::cerr;
template <typename ...T> void qqbx(const char *s, T ...args) {
    int cnt = sizeof...(T);
    ((cerr << "\e[1;32m(" << s << ") = ("), ..., (cerr << args << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename T> void danb(const char *s, T L, T R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L) cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif // local
#define all(v) begin(v),end(v)

using namespace std;

const int K = 105;
const int maxn = 200025;

const int64_t INF = 1e18;

const pair<int64_t,int64_t> PAIR_ID = { INF, -INF };

struct Segtree {
    int n;
    vector<array<pair<int64_t,int64_t>,K>> st;
    using Data = array<pair<int64_t,int64_t>, K>;
    Data combine(const Data &lhs, const Data &rhs) {
        Data res;
        for (int j = 0; j < K; j++) {
            res[j].first = min(lhs[j].first, rhs[j].first);
            res[j].second = max(lhs[j].second, rhs[j].second);
        }
        return res;
    }
    Segtree(int t_n) : n(t_n), st(t_n * 2) {}
    void edit(int p, Data v) {
        p += n;
        st[p] = v;
        while (p >>= 1) {
            st[p] = combine(st[p << 1], st[p << 1 | 1]);
        }
    }

    Data query(int l, int r) {
        Data res;
        fill(res.begin(), res.end(), PAIR_ID);
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l & 1) res = combine(st[l++], res);
            if (r & 1) res = combine(st[--r], res);
        }
        return res;
    }
};

vector<pair<int,int>> org_g[maxn];

vector<pair<int,int64_t>> g[maxn * 2]; // to, chain_id

// chain info
int64_t chain_pos[maxn][K];
int64_t chain_tot[K];

tuple<int,int,int,int,int,int,int> chain_info[K];

int cid;
int tot;

vector<int> vertex;

void dfs_shrink(int i, int f) {
    vertex.push_back(i);
    for (auto [j, w0]: org_g[i]) {
        if (j == f) continue;

        int x = i;
        int y = j;
        int64_t pref = w0;
        while (org_g[y].size() == 2) {
            auto e = org_g[y][0].first!=x ? org_g[y][0] : org_g[y][1];
            auto [z, w] = e;
            chain_pos[y][cid] = pref;
            pref += w;
            x = y;
            y = z;
        }
        // g[y].size() != 2
        chain_tot[cid] = pref;

        int v1 = tot++, v2 = tot++;
        size_t A = g[i].size();
        g[i].emplace_back(v1, -1);
        size_t B = g[v1].size();
        g[v1].emplace_back(v2, -1);
        size_t C = g[v2].size();
        g[v2].emplace_back(y, -1);

        chain_info[cid] = { i, v1, v2, y, A, B, C };
        ++cid;

        dfs_shrink(y, x);
    }
}

int sz[maxn * 2];
void dfs(int64_t &ans, int m, int i) {
    for (auto [j, w]: g[i]) {
        dfs(ans, m, j);
        if (sz[j] != 0 && sz[j] != m) {
            ans += w;
        }
        sz[i] += sz[j];
    }
}

signed main() {

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, q;
    cin >> n >> q;
    string S;
    cin >> S;

    tot = n;

    for (int i = 0; i < n; i++)
        for (int j = 0; j < K; j++)
            chain_pos[i][j] = -1;

    for (int i = 1; i < n; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        org_g[u].emplace_back(v, w);
        org_g[v].emplace_back(u, w);
    }

    dfs_shrink(0, -1);

    Segtree sgt(n);

    const auto enable = [&](int x) {
        array<pair<int64_t,int64_t>,K> t;
        for (int j = 0; j < cid; j++) {
            if (chain_pos[x][j] != -1)
                t[j] = { chain_pos[x][j], chain_pos[x][j] };
            else
                t[j] = { INF, -INF };
        }
        sgt.edit(x, t);
    };
    const auto disable = [&](int x) {
        array<pair<int64_t,int64_t>,K> t;
        for (int j = 0; j < cid; j++) {
            t[j] = { INF, -INF };
        }
        sgt.edit(x, t);
    };

    for (int i = 0; i < n; i++)
        if (S[i] == '1')
            enable(i);
        else
            disable(i);

    while (q--) {
        int t;
        cin >> t;
        if (t == 1) {
            int x;
            cin >> x;
            --x;

            if (S[x] == '1') {
                S[x] = '0';
                disable(x);
            } else if (S[x] == '0') {
                S[x] = '1';
                enable(x);
            }

        } else {
            int l, r;
            cin >> l >> r;
            --l;

            // query [l, r)

            auto res = sgt.query(l, r);

            int cnt = 0;

            for (int j = 0; j < cid; j++) {
                auto [ i, v1, v2, y, A, B, C ] = chain_info[j];
                if (res[j] == PAIR_ID) {
                    debug("NO", j);
                    g[i][A].second = chain_tot[j];
                    g[v1][B].second = 0;
                    g[v2][C].second = 0;
                    sz[v1] = sz[v2] = 0;
                } else {
                    auto [f, s] = res[j];
                    debug("YES", j, f, s);
                    g[i][A].second = f;
                    g[v1][B].second = s - f;
                    g[v2][C].second = chain_tot[j] - s;
                    sz[v1] = sz[v2] = 1;
                    cnt += 2;
                }
            }

            for (int v: vertex) {
                if (l <= v && v < r) {
                    sz[v] = (S[v] == '1');
                    cnt += (S[v] == '1');
                } else {
                    sz[v] = 0;
                }
            }

            if (cnt == 0) {
                cout << -1 << '\n';
            } else {
                int64_t ans = 0;
                dfs(ans, cnt, 0);
                cout << ans * 2 << '\n';
            }
        }
    }
}