package main

import (
	"bufio"
	"container/heap"
	"io"
	"os"
	"strconv"
)

type BIT struct {
	t []int
}

func NewBIT(n int) *BIT {
	return &BIT{t: make([]int, n+2)}
}

func (b *BIT) Add(i, delta int) {
	for i < len(b.t) {
		b.t[i] += delta
		i += i & -i
	}
}

func (b *BIT) Sum(i int) int {
	s := 0
	for i > 0 {
		s += b.t[i]
		i -= i & -i
	}
	return s
}

type Item struct {
	next int
	id   int
}

type MaxHeap []Item

func (h MaxHeap) Len() int { return len(h) }

func (h MaxHeap) Less(i, j int) bool {
	if h[i].next == h[j].next {
		return h[i].id > h[j].id
	}
	return h[i].next > h[j].next
}

func (h MaxHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }

func (h *MaxHeap) Push(x interface{}) {
	*h = append(*h, x.(Item))
}

func (h *MaxHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[:n-1]
	return x
}

func readInts() []int {
	data, _ := io.ReadAll(os.Stdin)
	vals := make([]int, 0, len(data)/2)
	num := 0
	sign := 1
	inNum := false
	for _, c := range data {
		if c == '-' {
			sign = -1
		} else if c >= '0' && c <= '9' {
			num = num*10 + int(c-'0')
			inNum = true
		} else if inNum {
			vals = append(vals, sign*num)
			num = 0
			sign = 1
			inNum = false
		}
	}
	if inNum {
		vals = append(vals, sign*num)
	}
	return vals
}

func solveMoveToFront(n, q int, seq []int) []int {
	bit := NewBIT(n + q + 2)
	pos := make([]int, n+1)
	for i := 1; i <= n; i++ {
		p := q + i
		pos[i] = p
		bit.Add(p, 1)
	}
	top := q
	ans := make([]int, q)
	for i, x := range seq {
		p := pos[x]
		ans[i] = bit.Sum(p - 1)
		bit.Add(p, -1)
		bit.Add(top, 1)
		pos[x] = top
		top--
	}
	return ans
}

func solveCache(capacity, q int, seq []int) int {
	inf := q + 1
	nextPos := make([]int, q)
	last := make(map[int]int, q*2)
	for i := q - 1; i >= 0; i-- {
		x := seq[i]
		if p, ok := last[x]; ok {
			nextPos[i] = p
		} else {
			nextPos[i] = inf
		}
		last[x] = i
	}

	cur := make(map[int]int, capacity*2)
	h := &MaxHeap{}
	heap.Init(h)
	misses := 0

	for i, x := range seq {
		nxt := nextPos[i]
		if _, ok := cur[x]; ok {
			cur[x] = nxt
			heap.Push(h, Item{next: nxt, id: x})
			continue
		}

		misses++
		if len(cur) == capacity {
			for h.Len() > 0 {
				it := heap.Pop(h).(Item)
				if v, ok := cur[it.id]; ok && v == it.next {
					delete(cur, it.id)
					break
				}
			}
		}
		cur[x] = nxt
		heap.Push(h, Item{next: nxt, id: x})
	}

	return misses
}

func main() {
	vals := readInts()
	if len(vals) < 3 {
		return
	}

	a, b := vals[0], vals[1]
	rest := vals[2:]

	n, q := a, b
	if len(rest) == a && len(rest) != b {
		n, q = b, a
	}
	if q > len(rest) {
		q = len(rest)
	}
	seq := rest[:q]

	moveToFront := true
	for _, x := range seq {
		if x < 1 || x > n {
			moveToFront = false
			break
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer w.Flush()

	if moveToFront {
		ans := solveMoveToFront(n, q, seq)
		out := make([]byte, 0, q*8)
		for i, v := range ans {
			if i > 0 {
				out = append(out, ' ')
			}
			out = strconv.AppendInt(out, int64(v), 10)
		}
		out = append(out, '\n')
		w.Write(out)
	} else {
		ans := solveCache(n, q, seq)
		out := strconv.AppendInt(nil, int64(ans), 10)
		out = append(out, '\n')
		w.Write(out)
	}
}