```go
package main

import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)

	constraints := make([][]int, k)
	for i := 0; i < k; i++ {
		var m int
		fmt.Scan(&m)
		c := make([]int, m)
		for j := 0; j < m; j++ {
			var idx int
			fmt.Scan(&idx)
			c[j] = idx - 1
		}
		constraints[i] = c
	}

	adj := make([][]int, n)
	for _, c := range constraints {
		for _, i := range c {
			for _, j := range c {
				if i != j {
					adj[i] = append(adj[i], j)
				}
			}
		}
	}
	for i := range adj {
		seen := make(map[int]bool)
		unique := []int{}
		for _, j := range adj[i] {
			if !seen[j] {
				seen[j] = true
				unique = append(unique, j)
			}
		}
		adj[i] = unique
	}

	for C := 1; C <= n; C++ {
		mask := uint16((1 << C) - 1)
		domains := make([]uint16, n)
		for i := range domains {
			domains[i] = mask
		}
		assignment := make([]int, n)

		var dfs func(i int) bool
		dfs = func(i int) bool {
			if i == n {
				return true
			}
			d := domains[i]
			for v := 1; v <= C; v++ {
				bit := uint16(1 << (v - 1))
				if d&bit != 0 {
					assignment[i] = v
					old := make([]uint16, n)
					copy(old, domains)
					valid := true
					for _, j := range adj[i] {
						if domains[j]&bit != 0 {
							domains[j] &^= bit
							if domains[j] == 0 {
								valid = false
								break
							}
						}
					}
					if valid {
						domains[i] = 0
						if dfs(i + 1) {
							return true
						}
					}
					copy(domains, old)
				}
			}
			assignment[i] = 0
			return false
		}

		if dfs(0) {
			for i, v := range assignment {
				if i > 0 {
					fmt.Print(" ")
				}
				fmt.Print(v)
			}
			fmt.Println()
			return
		}
	}
}
```