```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

const INF int64 = 1e18

type Edge struct {
	to, rev, cap, flow int
	cost               int64
	id                 int
}

type Task struct {
	u, v, c, id int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, k int
	if _, err := fmt.Fscan(in, &n, &k); err != nil {
		return
	}

	tasks := make([]Task, n)
	points := make([]int, 0, 2*n)

	for i := 0; i < n; i++ {
		var s, t, c int
		fmt.Fscan(in, &s, &t, &c)
		tasks[i] = Task{s, s + t, c, i}
		points = append(points, s, s+t)
	}

	sort.Ints(points)
	uniq := make([]int, 0, len(points))
	if len(points) > 0 {
		uniq = append(uniq, points[0])
		for i := 1; i < len(points); i++ {
			if points[i] != points[i-1] {
				uniq = append(uniq, points[i])
			}
		}
	}

	getIdx := func(val int) int {
		return sort.Search(len(uniq), func(i int) bool { return uniq[i] >= val })
	}

	numNodes := len(uniq)
	if numNodes == 0 {
		return
	}
	
	adj := make([][]Edge, numNodes)

	addEdge := func(u, v, cap, cost, id int) {
		adj[u] = append(adj[u], Edge{v, len(adj[v]), cap, 0, int64(cost), id})
		adj[v] = append(adj[v], Edge{u, len(adj[u]) - 1, 0, 0, int64(-cost), -1})
	}

	for i := 0; i < numNodes-1; i++ {
		addEdge(i, i+1, k, 0, -1)
	}

	for _, t := range tasks {
		u, v := getIdx(t.u), getIdx(t.v)
		if u < v {
			addEdge(u, v, 1, -t.c, t.id)
		}
	}

	source, sink := 0, numNodes-1
	dist := make([]int64, numNodes)
	parent := make([]int, numNodes)
	edgeIdx := make([]int, numNodes)
	inQ := make([]bool, numNodes)

	for i := 0; i < k; i++ {
		for j := range dist {
			dist[j] = INF
		}
		dist[source] = 0
		q := []int{source}
		inQ[source] = true
		head := 0
		
		for head < len(q) {
			u := q[head]
			head++
			inQ[u] = false
			for idx, e := range adj[u] {
				if e.cap > e.flow && dist[e.to] > dist[u]+e.cost {
					dist[e.to] = dist[u] + e.cost
					parent[e.to] = u
					edgeIdx[e.to] = idx
					if !inQ[e.to] {
						q = append(q, e.to)
						inQ[e.to] = true
					}
				}
			}
		}

		if dist[sink] >= 0 {
			break
		}

		curr := sink
		for curr != source {
			p := parent[curr]
			idx := edgeIdx[curr]
			adj[p][idx].flow++
			rev := adj[p][idx].rev
			adj[curr][rev].flow--
			curr = p
		}
	}

	ans := make([]int, n)
	for u := 0; u < numNodes; u++ {
		for _, e := range adj[u] {
			if e.id != -1 && e.flow == 1 {
				ans[e.id] = 1
			}
		}
	}

	for i := 0; i < n; i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, ans[i])
	}
	fmt.Fprintln(out)
}
```