Järjestäminen

use std::io::{self, BufRead};
 
fn main() {
    let mut lines = io::BufReader::new(io::stdin()).lines();
 
    let t = lines.next().unwrap().unwrap().parse::<usize>().unwrap();
 
    let mut arrays: Vec<Vec<usize>> = Vec::new();
 
    for _ in 0..t {
        let _n = lines.next().unwrap().unwrap().parse::<usize>().unwrap();
        let array_line = lines.next().unwrap().unwrap();
        arrays.push(array_line.split_ascii_whitespace().map(|s| s.parse::<usize>().unwrap()).collect());
    }
 
    for array in &mut arrays {
        if try_sort(1, array) {
            println!("YES");
        } else {
            println!("NO");
        }
    }
}
 
fn try_sort(m: usize, array: &mut [usize]) -> bool {
    if array.len() == 1 {
        return true
    }
    if array.len() == 2 {
        return array[0] < array[1]
    }
    if array.len() == 3 {
        return array[0] < array[1] && array[1] < array[2]
    }
 
    if array.len() == 4 {
        if array[0] < array[1] && array[1] < array[2] && array[2] < array[3] {
            return true;
        }
        if array == &[m+2,m+3,m,m+1] {
            return true;
        }
        if m > 1 {
            return match (array[0] - m, array[1] - m, array[2] - m, array[3] - m) {
                (0, 1, 2, 3) => true,
                (0, 2, 3, 1) => true,
                (0, 3, 1, 2) => true,
                (0, 1, 3, 2) => false,
                (0, 2, 1, 3) => false,
                (0, 3, 2, 1) => false,
 
                (1, 0, 2, 3) => false,
                (1, 2, 3, 0) => false,
                (1, 3, 0, 2) => false,
                (1, 0, 3, 2) => true,
                (1, 2, 0, 3) => true,
                (1, 3, 2, 0) => true,
 
                (2, 0, 1, 3) => true,
                (2, 1, 3, 0) => true,
                (2, 3, 0, 1) => true,
                (2, 0, 3, 1) => false,
                (2, 1, 0, 3) => false,
                (2, 3, 1, 0) => false,
 
                (3, 0, 1, 2) => false,
                (3, 1, 2, 0) => false,
                (3, 2, 0, 1) => false,
                (3, 0, 2, 1) => true,
                (3, 1, 0, 2) => true,
                (3, 2, 1, 0) => true,
                _ => false,
            }
        }  else {
            return false;
        }
 
    }
 
    if Some(&m) == array.iter().nth(1) {
        if array.len() == 4 {
            return false;
        }
 
        let tmp1 = array[0];
        let tmp2 = array[1];
 
        array[0] = array[2];
        array[1] = array[3];
        
        array[2] = tmp1;
        array[3] = tmp2;
 
        return try_sort(m, array);
    }
 
    if Some(&m) == array.last() {
        if array.len() == 4 {
            return false;
        }
        let i = array.len() - 2;
 
        let tmp1 = array[1];
        let tmp2 = array[2];
 
        array[1] = array[i];
        array[2] = array[i+1];
        
        array[i] = tmp1;
        array[i+1] = tmp2;
 
        return try_sort(m, array);
    }
 
    if m == array[0] {
        return try_sort(m + 1, &mut array[1..])
    } else {
        let i = array.iter().position(|x| *x == m).unwrap();
 
        let tmp1 = array[0];
        let tmp2 = array[1];
 
        array[0] = array[i];
        array[1] = array[i+1];
        
        array[i] = tmp1;
        array[i+1] = tmp2;
 
        return try_sort(m + 1, &mut array[1..])
    }
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 1, 2

Verdict: ACCEPTED