#include <fstream>
#include <vector>
#include <algorithm>

#define NMax 10100

using namespace std;

ifstream f("online.in");
ofstream g("online.out");

int nodes, nEdges, queries, disTree[210];
struct edge {
    short int node1;
    short int node2;
    short int cost;
} newEdge;

vector<edge> edges;

bool cmp(const edge e1, const edge e2)
{
    return e1.cost < e2.cost;
}

int findFather(int node)
{

    while (disTree[node] > 0)
        node = disTree[node];

    return node;
}

void insertEdge(edge newEdge)
{
    for (int i=0; i < nEdges; i++) {
        if (newEdge.cost < edges[i].cost) {
            edges.insert(edges.begin() + i, newEdge);
            return;
        }
    }
}

int kruskal(int c) {
    int cost = 0;

    if (c == 1)
        insertEdge(newEdge);

    for (int i=1; i<=nodes; i++)
        disTree[i] = -1;

    nEdges = 0;
    for (int i=0; nEdges < nodes - 1; i++) {
        edge crtEdge = edges[i];

        int fath1 = findFather(crtEdge.node1);
        int fath2 = findFather(crtEdge.node2);

        if (fath1 != fath2) {
            if (-disTree[fath1] > -disTree[fath2]) {
                disTree[fath1] += disTree[fath2];
                disTree[fath2] = fath1;
            }
            else {
                disTree[fath2] += disTree[fath1];
                disTree[fath1] = fath2;
            }

            ++nEdges;
            edges[nEdges-1].node1 = crtEdge.node1;
            edges[nEdges-1].node2 = crtEdge.node2;
            edges[nEdges-1].cost = crtEdge.cost;

            cost += crtEdge.cost;
        }
    }

    return cost;
}

int main()
{
    f>>nodes>>nEdges;

    edge edg;
    for (int i=1; i<=nEdges; i++) {
        f>>edg.node1>>edg.node2>>edg.cost;

        edges.push_back(edg);
    }

    sort (edges.begin(), edges.end(), cmp);
    g<<kruskal(0)<<"\n";

    f>>queries;
    for (int i=1; i<=queries; i++) {
        f>>newEdge.node1>>newEdge.node2>>newEdge.cost;

        g<<kruskal(1)<<"\n";
    }

    return 0;
}