Käännöt

warning: unused variable: `original_list`
   --> input/code.rs:138:9
    |
138 |     let original_list = list.clone();
    |         ^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_original_list`
    |
    = note: `#[warn(unused_variables)]` on by default

warning: associated function `from_stdin` is never used
  --> input/code.rs:21:8
   |
21 |     fn from_stdin() -> Self {
   |        ^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: associated function `solve` is never used
   --> input/code.rs:124:8
    |
124 |     fn solve(&mut self) -> bool {
    |        ^^^^^

warning: panic message contains an unused formatting placeholder
  --> input/code.rs:56:48
   |
56 |             panic!("[Get] Index Out of bounds: {i}");
   |                                                ^^^
   |
   = note: this message is not used as a format string when given without arguments, but will be in Rust 2021
   = note: `#[warn(non_fmt_panics)]` on by defaul...

use std::io::*;
 
const BUFFER_SIZE: usize = 10;
 
#[derive(Clone)]
struct List {
    moves: Vec<i32>,
    buffer: [i32; BUFFER_SIZE],
    n: i32,
    k: i32,
}
 
impl List {
    #[cfg(feature = "print")]
    fn print(&self) {
        {
            println!("{:?}", self.buffer[..(self.n as usize)].to_vec());
        }
    }
 
    fn from_stdin() -> Self {
        let mut input = String::new();
        stdin().read_line(&mut input).unwrap();
 
        let mut split = input.split(" ");
        let n: i32 = split.next().unwrap().trim().parse().unwrap();
        let k: i32 = split.next().unwrap().trim().parse().unwrap();
 
        let mut list_input = String::new();
        stdin().read_line(&mut list_input).unwrap();
        let vector = list_input
            .split(" ")
            .map(|s| s.trim().parse().unwrap())
            .collect::<Vec<i32>>();
 
        let mut list = [0; BUFFER_SIZE];
        list[(0 as usize)..(n as usize)].clone_from_slice(&vector);
 
        let l = Self {
            n,
            k,
            buffer: list,
            moves: Vec::with_capacity(1_000_000),
        };
        #[cfg(feature = "print")]
        {
            println!("List created");
            l.print();
            println!("");
        }
        l
    }
 
    fn get(&self, i: i32) -> i32 {
        if i >= self.n || i < 0 {
            panic!("[Get] Index Out of bounds: {i}");
        }
        self.buffer[i as usize]
    }
 
    fn generate_all_lists(n: i32, k: i32) -> Vec<List> {
        let mut lists = Vec::new();
 
        let mut count = 1;
        for i in 0..n {
            count *= i + 1;
        }
 
        println!("Count: {count}");
 
        for i in 0..count {
            let mut list = Self {
                buffer: [0; BUFFER_SIZE],
                n,
                k,
                moves: Vec::new(),
            };
            let mut seed = i;
            for j in 0..n {
                let value = seed % (n - j) + 1;
                let mut add = 0;
                for k in 0..j {
                    if value <= list.buffer[k as usize] {
                        add += 1;
                    }
                }
                list.buffer[j as usize] = value + add;
                seed /= n;
            }
            lists.push(list);
        }
 
        lists
    }
 
    fn reverse(&mut self, i: i32) {
        #[cfg(feature = "print")]
        {
            //println!("Reverse index: {i} k: {}", self.k);
            //self.print();
        }
 
        if i + self.k > self.n || i < 0 {
            panic!("[Reverse] Index Out of Bounds: {i}");
        }
 
        self.moves.push(i);
        self.buffer[(i as usize)..((i + self.k) as usize)].reverse();
 
        #[cfg(feature = "print")]
        //self.print();
        {}
    }
 
    fn is_solved(&self) -> bool {
        for i in 0..self.n {
            if self.get(i) != i + 1 {
                return false;
            }
        }
        true
    }
 
    fn solve(&mut self) -> bool {
        true
    }
 
    fn as_usize(&mut self) -> usize {
        let mut res = 0;
        for i in 0..self.n {
            res += self.get(i) * self.n.pow(i as u32);
        }
        res as usize
    }
}
 
fn brute_force(list: &mut List) {
    let original_list = list.clone();
 
    #[cfg(feature = "print")]
    {
        println!("Brute Forcing list:");
        original_list.print();
    }
 
    let n = list.n;
    let k = list.k;
    let mut ll: Vec<List> = Vec::new();
    ll.push(list.clone());
 
    let mut is_seen = [true; 72000];
 
    loop {
        let ll2: Vec<List> = ll.drain(..).collect();
        for mut list in ll2 {
            for i in 0..(n - k) {
                if *list.moves.last().unwrap_or(&-1) != i {
                    if list.is_solved() {
                        #[cfg(feature = "print")]
                        {
                            println!("Solved!");
                            original_list.print();
                            list.print();
                        }
                        return;
                    }
                    list.reverse(i);
                }
            }
            if !is_seen[list.as_usize()] {
                is_seen[list.as_usize()] = true;
                ll.push(list);
            }
        }
    }
}
 
fn main() -> Result<()> {
    //for _ in 0..10
 
    {
        List::generate_all_lists(6, 5).iter_mut().for_each(|list| {
            brute_force(list);
        });
 
        /*
        if list.solve() {
            println!(
                "YES\n{}\n{}",
                list.moves.len(),
                list.moves
                    .iter()
                    .map(|n| (n + 1).to_string())
                    .collect::<Vec<_>>()
                    .join(" ")
            );
        } else {
            println!("NO")
        }*/
    }
 
    Ok(())
}

Test 1

Group: 1

Verdict: TIME LIMIT EXCEEDED

Test 2

Group: 1

Verdict: TIME LIMIT EXCEEDED

Test 3

Group: 1

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 1

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 1

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 25

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 26

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 28

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 29

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 30

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 31

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 32

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 33

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 34

Group: 4

Verdict: TIME LIMIT EXCEEDED