#include <iostream>

 #include <vector>

 #include <algorithm>

 #include <string>

 #include <string.h>

 #include <stdio.h>

 #include <math.h>

 #include <stdlib.h>

 #include <queue>

 #include <stack>

 #include <map>

 #include <set>

 #include <ctime>

 #include <cassert>

 using namespace std;

 const int N=2e5+;

 const int INF=0x3f3f3f3f;

 struct Node {

     int u,v,w;

     int id;

     bool operator < (const Node &o) const {

         return w<o.w;

     }

 }node[N];

 struct Edge{

     int to,next,w;

 }edge[N<<];

 int idx,head[N];

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

     ++idx;

     edge[idx].to=v;

     edge[idx].next=head[u];

     edge[idx].w=w;

     head[u]=idx;

 }

 int dep[N];

 int par[N][];

 int dis[N][];

 void dfs(int u,int f,int d){

     dep[u]=d;

     for (int k=head[u];k;k=edge[k].next){

         int v=edge[k].to;

         if (v==f) continue;

         par[v][]=u;

         dis[v][]=edge[k].w;

         dfs(v,u,d+);

     }

 }

 int kthA(int u,int k) {

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

         if (k>=(<<i)) {

             k-=(<<i);

             u=par[u][i];

         }

     }

     return u;

 }

 int kthD(int u,int k) {

     int ret=;

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

         if (k>=(<<i)) {

             k-=(<<i);

             ret=max(ret,dis[u][i]);

             u=par[u][i];

         }

     }

     return ret;

 }

 void calc(int n) {

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

         int k=<<(i-);

         for (int j=;j<=n;j++) {

             par[j][i]=par[par[j][i-]][i-];

             dis[j][i]=max(dis[j][i-],dis[par[j][i-]][i-]);

         }

     }

 }

 int get(int u,int v){

     if(dep[u]<dep[v])swap(u,v);

     int ret=kthD(u,dep[u]-dep[v]);

     u=kthA(u,dep[u]-dep[v]);

     if(u==v)return ret;

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

         if(par[u][i]==par[v][i])continue;

         ret=max(ret,dis[u][i]);

         ret=max(ret,dis[v][i]);

         u=par[u][i];

         v=par[v][i];

     }

     ret=max(ret,dis[u][]);

     ret=max(ret,dis[v][]);

     return ret;

 }

 int fa[N];

 int find(int x) {

     if (fa[x]==x)

         return x;

     return fa[x]=find(fa[x]);

 }

 bool mark[N];

 long long ret[N];

 int main () {

     ios_base::sync_with_stdio(false);

     int n,m;

     while (cin>>n>>m) {

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

             cin>>node[i].u>>node[i].v>>node[i].w;

             node[i].id=i;

             mark[i]=false;

         }

         sort(node+,node++m);

         long long sum=;

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

             fa[i]=i;

         idx=;memset(head,,sizeof head);

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

             int u=node[i].u;

             int v=node[i].v;

             int w=node[i].w;

             int id=node[i].id;

             int fu=find(u);

             int fv=find(v);

             if (fu==fv) continue;

             fa[fu]=fv;

             sum+=w;

             mark[id]=true;

             addedge(u,v,w);

             addedge(v,u,w);

         }

         dfs(,-,);

         calc(n);

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

             int id=node[i].id;

             int u=node[i].u;

             int v=node[i].v;

             int w=node[i].w;

             if (mark[id]) ret[id]=sum;

             else {

                 int mx=get(u,v);

                 ret[id]=sum+w-mx;

             }

         }

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

             cout<<ret[i]<<endl;

     }

     return ;

 }