Problem:
Problem E: Cyclic Shift Sort

Problem

長さ $N$ の順列 $P = \{ P_1, P_2, \ldots, P_N \} $ と整数 $K$ が与えられる。

以下の操作を $0$ 回以上任意の回数繰り返すことで、順列 $P$ を単調増加にすることができるかどうか判定せよ。

整数 $x \ (0 \le x \le N-K)$ を選ぶ。 $ P_{x+1}, \ldots, P_{x+K} $ を巡回右シフトする

ただし、部分列 $U=U_1, \ldots, U_M$ の巡回右シフトとは、 $U=U_1, \ldots, U_M$ を $U=U_M, U_1, \ldots, U_{M-1}$ に変更することを意味する。

Input

入力は以下の形式で与えられる。

$N$ $K$
$P_1$ $\ldots$ $P_N$

1行目に順列の長さ $N$ 、整数 $K$ が空白区切りで与えられる。

2行目に順列 $P$ の要素が空白区切りで与えられる。

Constraints

入力は以下の条件を満たす。

$2 \leq K \leq N \leq 10^5 $

$ 1 \leq P_i \leq N \ (1 \leq i \leq N) $

$ P_i \neq P_j \ (i \neq j) $

入力はすべて整数

Output

$P$ を単調増加にすることができるなら"Yes"を、できないのであれば"No"を $1$ 行に出力せよ。

Sample Input 1

3 3
2 3 1

Sample Output 1

Yes

$ x = 0 $ として操作を $1$ 回行うと、 $P$ を単調増加にすることができる。

Sample Input 2

3 2
1 2 3

Sample Output 2

Yes

$P$ が初めから単調増加である場合もある。

Sample Input 3

3 3
3 2 1

Sample Output 3

No

どのように操作を行なったとしても、 $P$ を単調増加にすることはできない。

Solution in Rust (judge verdict: Accepted)

//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

fn calc_inversion(a: &mut [u32]) -> usize {
    if a.len() == 1 {
        return 0;
    }
    let n = a.len();
    let m = n / 2;
    let mut ans = calc_inversion(&mut a[0..m]);
    ans ^= calc_inversion(&mut a[m..n]);
    let mut i = 0;
    let mut j = m;
    let mut b = vec![];
    while i < m && j < n {
        if a[i] <= a[j] {
            b.push(a[i]);
            i += 1;
        } else {
            ans ^= m - i;
            b.push(a[j]);
            j += 1;
        }
    }
    while i < m {
        b.push(a[i]);
        i += 1;
    }
    for i in 0..b.len() {
        a[i] = b[i];
    }
    ans
}

fn run() {
    input! {
        n: usize,
        k: usize,
        p: [u32; n],
    }
    if k < n {
        if k % 2 == 0 {
            println!("Yes");
            return;
        }
        let mut a = p.clone();
        if calc_inversion(&mut a) % 2 != 0 {
            println!("No");
        } else {
            println!("Yes");
        }
        return;
    }
    let mut a = vec![0; 2 * n];
    for i in 0..n {
        a[i] = p[i];
        a[i + n] = p[i];
    }
    let mut cnt = vec![0; 2 * n + 1];
    for i in 0..(2 * n - 1) {
        if a[i] > a[i + 1] {
            cnt[i] = 1;
        }
    }
    for i in (0..(2 * n - 1)).rev() {
        cnt[i] += cnt[i + 1];
    }
    for i in 0..n {
        if cnt[i] == cnt[i + n - 1] {
            println!("Yes");
            return;
        }
    }
    println!("No");
}

fn main() {
    run();
}