#include <bits/stdc++.h>

using namespace std;

const int N = 3e5 + 5;

int n, m;
int w[N], kk[N];

struct edge{
    int a, b, s, idx;
    edge(int _a, int _b, int _s, int _idx){
        a = _a;
        b = _b;
        s = _s;
        idx = _idx;
    }
};

struct handle{
    int a, b, idx;
    handle(int _a, int _b, int _idx){
        a = _a;
        b = _b;
        idx = _idx;
    }
};

struct Comparehandle {
    bool operator()(handle const& p1, handle const& p2)
    {
        return p1.idx > p2.idx;
    }
};

struct event{
    int val, idx, to;
    event(int _val, int _to, int _idx){
        val = _val;
        to = _to;
        idx = _idx;
    }

    bool operator < (event h){
        return val > h.val;
    }
};

struct Compareevent {
    bool operator()(event const& p1, event const& p2)
    {
        return p1.val > p2.val;
    }
};

struct DSU{
    const int inf = 1e6;

    void add(int &a, int b){
        a += b;
        if (a > inf) a = inf;
    }

    vector <int> par, wei, sz;
    vector <priority_queue <event, vector<event>, Compareevent>> cur;
    priority_queue <handle, vector <handle>, Comparehandle> qu;
    DSU(int n){
        par.resize(n + 1);
        wei.resize(n + 1);
        sz.resize(n + 1);
        cur.resize(n + 1);
        for (int i = 1; i <= n; ++ i) par[i] = i, wei[i] = w[i], sz[i] = 1;
    }

    int find(int u){
        if (u == par[u]) return u;
        return par[u] = find(par[u]);
    }

    int half(int s){
        return (s + 1) / 2;
    }

    void add(edge p){
        if (w[p.a] + w[p.b] >= p.s){
            qu.push(handle(p.a, p.b, p.idx));
            return;
        }

        cur[p.a].push(event(half(p.s - w[p.a] - w[p.b]) + w[p.a], p.b, p.idx));
        cur[p.b].push(event(half(p.s - w[p.a] - w[p.b]) + w[p.b], p.a, p.idx));
    }

    void ask(int u){
        while (!cur[u].empty()){
            int v = find(cur[u].top().to);
            int lm = cur[u].top().val;
            int idx = cur[u].top().idx;
            cur[u].pop();
            if (u == v) continue;
            if (wei[u] < lm) break;
            if (wei[u] + wei[v] >= kk[idx]){
                qu.push(handle(u, v, idx));
            }
            else {
                cur[u].push(event(half(kk[idx] - wei[u] - wei[v]) + wei[u], v, idx));
                cur[v].push(event(half(kk[idx] - wei[u] - wei[v]) + wei[v], u, idx));
            }
        }
    }

    bool joint(int u, int v){
        u = find(u);
        v = find(v);
        if (u == v) return false;

        if (sz[u] < sz[v]) swap(u, v);
        par[v] = u;
        sz[u] += sz[v];
        add(wei[u], wei[v]);
        while (!cur[v].empty()){
            cur[u].push(cur[v].top());
            cur[v].pop();
        }
        ask(u);

        return true;
    }

    vector <int> ord;

    void process(){
        while (!qu.empty()){
            handle k = qu.top();
            qu.pop();
            if (joint(k.a, k.b)) ord.push_back(k.idx);
        }
    }

    void answer(){
        cout << ord.size() << '\n';
        for (int v : ord) cout << v << ' ';
    }
};

void solve(){
    cin >> n >> m;
    for (int i = 1; i <= n; ++ i) cin >> w[i];
    DSU dsu = DSU(n);
    for (int i = 1; i <= m; ++ i){
        int a, b;
        cin >> a >> b >> kk[i];
        dsu.add(edge(a, b, kk[i], i));
    }

    dsu.process();
    dsu.answer();
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();

    return 0;
}