package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const MOD int64 = 1000000007

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = res * base % MOD
		}
		base = base * base % MOD
		exp /= 2
	}
	return res
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 10*1024*1024)

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	if !scanner.Scan() {
		return
	}
	k_int, _ := strconv.Atoi(scanner.Text())
	k := int64(k_int)

	a := make([]int, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		a[i], _ = strconv.Atoi(scanner.Text())
	}

	inv := make([]int64, n+1)
	if n >= 1 {
		inv[1] = 1
	}
	for i := 2; i <= n; i++ {
		inv[i] = MOD - (MOD/int64(i))*inv[MOD%int64(i)]%MOD
	}

	fact := make([]int64, n+1)
	invFact := make([]int64, n+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= n; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
		invFact[i] = invFact[i-1] * inv[i] % MOD
	}

	Delta := make([]int64, n)
	Delta[0] = 0
	for c := 1; c < n; c++ {
		term1 := int64(c) * (k - 1) % MOD * Delta[c-1] % MOD
		term2 := int64(c) * k % MOD
		val := (term1 - term2) % MOD
		if val < 0 {
			val += MOD
		}
		Delta[c] = val * inv[n-c] % MOD
	}

	F := make([]int64, n+1)
	F[0] = 0
	for c := 1; c <= n; c++ {
		F[c] = (F[c-1] + Delta[c-1]) % MOD
	}

	invK := power(k, MOD-2)
	C := (-F[n]) % MOD
	if C < 0 {
		C += MOD
	}
	C = C * invK % MOD

	for c := 0; c <= n; c++ {
		F[c] = (F[c] + C) % MOD
	}

	m := 0
	colorFreq := make(map[int]int)
	for _, val := range a {
		if val == -1 {
			m++
		} else {
			colorFreq[val]++
		}
	}

	D := int64(len(colorFreq))
	counts := make(map[int]int64)
	counts[0] = (k - D) % MOD
	for _, f := range colorFreq {
		counts[f]++
	}

	Prob := make([]int64, m+1)
	p := power(k, MOD-2)
	q := (k - 1) % MOD * p % MOD

	p_pow := make([]int64, m+1)
	q_pow := make([]int64, m+1)
	p_pow[0] = 1
	q_pow[0] = 1
	for j := 1; j <= m; j++ {
		p_pow[j] = p_pow[j-1] * p % MOD
		q_pow[j] = q_pow[j-1] * q % MOD
	}

	for j := 0; j <= m; j++ {
		comb := fact[m] * invFact[j] % MOD * invFact[m-j] % MOD
		Prob[j] = comb * p_pow[j] % MOD * q_pow[m-j] % MOD
	}

	var ans int64 = 0
	for c, freq_of_c := range counts {
		freq_of_c %= MOD
		var exp_F uint64 = 0
		for j := 0; j <= m; j++ {
			exp_F += uint64(Prob[j]) * uint64(F[c+j])
			if j&7 == 7 {
				exp_F %= uint64(MOD)
			}
		}
		exp_F %= uint64(MOD)
		term := uint64(freq_of_c) * exp_F % uint64(MOD)
		ans = (ans + int64(term)) % MOD
	}

	fmt.Println(ans)
}