```go
package main

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

func main() {
	// Configure fast I/O
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, k int
	fmt.Fscan(reader, &n, &k)

	// a[0...n-1] are models, a[n] is designer
	a := make([]int, n+1)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}
	// Designer height is less than any model (models >= 1).
	a[n] = 0

	// Precompute logarithms for Sparse Table
	logs := make([]int, n+2)
	logs[1] = 0
	for i := 2; i <= n+1; i++ {
		logs[i] = logs[i/2] + 1
	}

	// Build Sparse Table for Range Minimum Query
	// K_st is the power such that 2^K_st <= n+1
	K_st := logs[n+1] + 1
	stMin := make([][]int, K_st)
	for i := range stMin {
		stMin[i] = make([]int, n+1)
	}

	for i := 0; i <= n; i++ {
		stMin[0][i] = a[i]
	}

	for j := 1; j < K_st; j++ {
		lenPart := 1 << (j - 1)
		for i := 0; i+(1<<j) <= n+1; i++ {
			v1 := stMin[j-1][i]
			v2 := stMin[j-1][i+lenPart]
			if v1 < v2 {
				stMin[j][i] = v1
			} else {
				stMin[j][i] = v2
			}
		}
	}

	// Function to query minimum in a[L...R] inclusive
	queryMin := func(L, R int) int {
		if L > R {
			return 2000000000 // Infinity
		}
		// Clamp R to n
		if R > n {
			R = n
		}
		if L > n {
			return 0 // Should not happen with correct logic
		}
		lenRange := R - L + 1
		j := logs[lenRange]
		v1 := stMin[j][L]
		v2 := stMin[j][R-(1<<j)+1]
		if v1 < v2 {
			return v1
		}
		return v2
	}

	// Compute Nearest Smaller Element (NSE) to the right for each element
	nse := make([]int, n)
	stack := []int{}
	for i := n - 1; i >= 0; i-- {
		// Maintain increasing stack
		for len(stack) > 0 && a[stack[len(stack)-1]] >= a[i] {
			stack = stack[:len(stack)-1]
		}
		if len(stack) == 0 {
			nse[i] = n // Designer is always smaller
		} else {
			nse[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}

	// Identify bad indices
	bad := []int{}
	for i := 0; i < n; i++ {
		if nse[i]-i > k {
			bad = append(bad, i)
		}
	}

	// If no bad indices, row is already nice
	if len(bad) == 0 {
		fmt.Fprintln(writer, "YES")
		return
	}

	// Range of bad indices
	iMin := bad[0]
	iMax := bad[len(bad)-1]

	// Find minimum height among bad models
	M := 2000000000
	for _, idx := range bad {
		if a[idx] < M {
			M = a[idx]
		}
	}

	// Find candidate for 'r'.
	// We need to bring a value smaller than M to the left of all bad indices.
	// r must be > iMax. We choose the first such r with a[r] < M.
	r := -1
	for i := iMax + 1; i < n; i++ {
		if a[i] < M {
			r = i
			break
		}
	}

	// If no such r exists, we can't fix the bad indices.
	if r == -1 {
		fmt.Fprintln(writer, "NO")
		return
	}

	// Check for critical indices x such that NSE[x] == r.
	// These x rely on a[r] to be "nice". If we swap a[r] away, they might become bad.
	// We must choose l such that these x are not in the range (l, r) where they lose coverage,
	// unless l covers them (l=x) or they find another smaller value.
	// For critical x, we need l >= x.
	lMinLimit := -1
	for x := 0; x < r; x++ {
		if nse[x] == r {
			// If r is removed, next smaller is first value < a[x] to the right of r
			limit := x + k
			if limit > n {
				limit = n
			}
			minVal := queryMin(r+1, limit)
			// If minVal >= a[x], then x cannot find a smaller value within k distance without r
			if minVal >= a[x] {
				// x is critical
				if x > lMinLimit {
					lMinLimit = x
				}
			}
		}
	}

	// Calculate the valid range for l: [Lstart, Lend]
	// 1. l must be > iMax (to be to the right of all bad indices that need fixing)
	Lstart := iMax + 1
	// 2. l must be >= max critical index
	if lMinLimit > Lstart {
		Lstart = lMinLimit
	}
	// 3. l itself must remain nice. a[l] becomes a[r]. New NSE for l is NSE[r].
	// Distance nse[r] - l <= k => l >= nse[r] - k
	nextSmallerThanAr := nse[r]
	if nextSmallerThanAr-k > Lstart {
		Lstart = nextSmallerThanAr - k
	}

	// 4. l must be <= iMin + k (to be close enough to fix the leftmost bad index)
	Lend := iMin + k
	// 5. l must be < r
	if r-1 < Lend {
		Lend = r - 1
	}

	if Lstart > Lend {
		fmt.Fprintln(writer, "NO")
		return
	}

	// Finally, check if the chosen swap is valid for r.
	// r receives a[l]. We need new NSE for r to be <= r + k.
	// This means there must be a value < a[l] in a[r+1 ... r+k].
	// Equivalently, a[l] > min(a[r+1 ... r+k]).
	thresholdLim := r + k
	if thresholdLim > n {
		thresholdLim = n
	}
	threshold := queryMin(r+1, thresholdLim)

	// We need to find if there is any l in [Lstart, Lend] such that a[l] > threshold.
	found := false
	for i := Lstart; i <= Lend; i++ {
		if a[i] > threshold {
			found = true
			break
		}
	}

	if found {
		fmt.Fprintln(writer, "YES")
	} else {
		fmt.Fprintln(writer, "NO")
	}
}
```