```go
package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

type Edge struct {
	u, v, w int
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int {
		for p < len(data) && data[p] <= ' ' {
			p++
		}
		x := 0
		for p < len(data) && data[p] > ' ' {
			x = x*10 + int(data[p]-'0')
			p++
		}
		return x
	}

	n := nextInt()
	m := nextInt()

	edges := make([]Edge, m)
	for i := 0; i < m; i++ {
		edges[i] = Edge{nextInt(), nextInt(), nextInt()}
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].w > edges[j].w
	})

	parent := make([]int, n+1)
	size := make([]int, n+1)
	cycle := make([]bool, n+1)

	for i := 1; i <= n; i++ {
		parent[i] = i
		size[i] = 1
	}

	find := func(x int) int {
		r := x
		for parent[r] != r {
			r = parent[r]
		}
		for parent[x] != x {
			y := parent[x]
			parent[x] = r
			x = y
		}
		return r
	}

	var ans int64

	for _, e := range edges {
		ru := find(e.u)
		rv := find(e.v)

		if ru == rv {
			if !cycle[ru] {
				cycle[ru] = true
				ans += int64(e.w)
			}
			continue
		}

		if cycle[ru] && cycle[rv] {
			continue
		}

		if size[ru] < size[rv] {
			ru, rv = rv, ru
		}
		parent[rv] = ru
		size[ru] += size[rv]
		cycle[ru] = cycle[ru] || cycle[rv]
		ans += int64(e.w)
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	out.WriteString(strconv.FormatInt(ans, 10))
	out.WriteByte('\n')
	out.Flush()
}
```