#include <bits/stdc++.h>

 using namespace std;

 const int INF = 0x3f3f3f3f;

 const int N = 2e5 + ;

 const int DEG = ;

 typedef long long ll;

 struct edge {

     int v, w, next;

     edge() {}

     edge(int v, int w, int next) : v(v), w(w), next(next){}

 }e[N << ];

 int head[N], tot;

 int fa[N][DEG], deg[N];

 int gx[N][DEG];

 void init() {

     memset(head, -, sizeof head);

     tot = ;

 }

 void addedge(int u, int v, int w) {

     e[tot] = edge(v, w, head[u]);

     head[u] = tot++;

 }

 void BFS(int root) {

     queue<int> que;

     deg[root] = ;

     fa[root][] = root;

     gx[root][] = ;

     que.push(root);

     while(!que.empty()) {

         int tmp = que.front();

         que.pop();

         for(int i = ; i < DEG; ++i) {

             fa[tmp][i] = fa[ fa[tmp][i - ] ][i - ];

             gx[tmp][i] = max(gx[tmp][i - ], gx[ fa[tmp][i - ] ][i - ]);

           // printf("[%d %d] ", tmp, gx[tmp][i]);

         }

        // puts("");

         for(int i = head[tmp]; ~i; i = e[i].next) {

             int v = e[i].v;

             int w = e[i].w;

             if(v == fa[tmp][]) continue;

             deg[v] = deg[tmp] + ;

             fa[v][] = tmp;

             gx[v][] = w;

             que.push(v);

         }

     }

 }

 int Mu, Mv;

 ll LCA(int u, int v) {

     Mu = Mv = -;

     if(deg[u] > deg[v]) swap(u, v);

     int hu = deg[u], hv = deg[v];

     int tu = u, tv = v;

     for(int det = hv - hu, i = ; det; det >>= , ++i)

         if(det & ) { Mv = max(Mv, gx[tv][i]); tv = fa[tv][i];  }

     if(tu == tv) return Mv;

     for(int i = DEG - ; i >= ; --i) {

         if(fa[tu][i] == fa[tv][i]) continue;

         Mu = max(Mu, gx[tu][i]);

         Mv = max(Mv, gx[tv][i]);

         tu = fa[tu][i];

         tv = fa[tv][i];

     }

     return max(max(Mu, gx[tu][]), max(Mv, gx[tv][]));

 }

 int U[N], V[N], w[N], r[N], f[N];

 int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }

 bool cmp(int a, int b) { return w[a] < w[b]; }

 ll MST;

 int n, m;

 void mst() {

     scanf("%d%d", &n, &m);

     for(int i = ; i <= m; ++i) {

         scanf("%d%d%d", &U[i], &V[i], &w[i]);

         r[i] = i;

         f[i] = i;

     }

     sort(r + , r + m + , cmp);

     MST = ;

     for(int i = ; i <= m; ++i)

     {

         int id = r[i];

         int fu = find(U[id]);

         int fv = find(V[id]);

         if(fu != fv) {

             MST += w[id];

             f[ fu ] = fv;

             addedge(U[id], V[id], w[id]);

             addedge(V[id], U[id], w[id]);

         }

     }

 }

 int main() {

     init();

     mst();

     BFS();

     for(int i = ; i <= m; ++i) {

         printf("%I64d\n", MST - LCA(U[i], V[i]) + w[i]);

     }

     return ;

 }