Lista

warning: variable does not need to be mutable
  --> input/code.rs:10:5
   |
10 |     mut solution: &mut Vec<u32>,
   |     ----^^^^^^^^
   |     |
   |     help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
  --> input/code.rs:11:5
   |
11 |     mut solution_hash: &mut HashMap<u32, bool>,
   |     ----^^^^^^^^^^^^^
   |     |
   |     help: remove this `mut`

use std::io;
use std::collections::HashMap;


fn rec_find(
    pairs: &Vec<(u32, u32)>,
    pairs_by_first: &HashMap<u32, Vec<(u32, u32)>>,
    remaining_depth: u32,
    last_choice: Option<(u32, u32)>,
    mut solution: &mut Vec<u32>,
    mut solution_hash: &mut HashMap<u32, bool>,
    primes: &HashMap<u32, bool>,
) -> Option<Vec<u32>> {
    let mut iterator = pairs;
    match last_choice {
        Some(c) => {
            iterator = &pairs_by_first[&c.1]
        },
        None => {}
    }

    for choice in iterator {
        match last_choice {
            Some(c) => {
                if c.1 != choice.0 {
                    continue
                }
            },
            None  => {

            }
        }
        if solution_hash.contains_key(&choice.0) {
            continue
        }
        if solution_hash.contains_key(&choice.1) {
            continue
        }

        if remaining_depth == 2 {
            if primes.contains_key(&(choice.0 + choice.1)) {
                solution.push(choice.0);
                solution.push(choice.1);
                return Some(solution.clone());
            }
        } else {
            solution.push(choice.0);
            solution_hash.insert(choice.0, true);
            let ret_val = rec_find(
                pairs,
                pairs_by_first,
                remaining_depth - 1,
                Some(*choice),
                solution,
                solution_hash,
                primes,
            );
            match ret_val {
                Some(v) => {return Some(v)}
                None => {}
            }
            solution_hash.remove(&choice.0);
            solution.pop();
        }
    }
    return None
}


fn main() {
    let mut input_text = String::new();
    io::stdin()
        .read_line(&mut input_text)
        .expect("failed to read from stdin");

    let trimmed = input_text.trim();

    let n: u32 = trimmed.parse::<u32>().unwrap();
    // println!("asdf");

    // let n: u32 = 7;

    let mut primes: HashMap<u32, bool> = HashMap::new();
    for i in 2..(n * 2 + 5) {
        let mut is_prime: bool = true;

        for (prime, _) in &primes {
            if i % prime == 0 {
                is_prime = false;
                break;
            }
        }

        if is_prime {
            primes.insert(i, true);
        }
    }

    let mut pairs: Vec<(u32, u32)> = vec![];
    let mut pairs_by_first: HashMap<u32, Vec<(u32, u32)>> = HashMap::new();
    for i in 1..n+1 {
        let mut pairs_in_first: Vec<(u32, u32)> = vec![];
        for j in 1..n+1 {
            if i != j && primes.contains_key(&(i + j)) {
                pairs.push((i, j));
                pairs_in_first.push((i, j));
            }
        }
        pairs_by_first.insert(i, pairs_in_first);
    }

    // println!("n is {}", n);
    // println!("primes {:#?}", primes);

    let mut solution: Vec<u32> = vec![];
    let mut solution_hash: HashMap<u32, bool> = HashMap::new();
    match rec_find(
        &pairs,
        &pairs_by_first,
        n,
        None,
        &mut solution,
        &mut solution_hash,
        &primes,
    ) {
        Some(value) => {
            for i in value {
                print!("{} ", i)
            }
            println!("")
            // println!("FOUND {:#?}", value)
        },
        None => {println!("Not found")}
    };
    // println!("pairs {:#?}", pairs);
    // println!("pairs {:#?}", pairs_by_first);
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3

Verdict: ACCEPTED

Test 3

Group: 1, 2, 3

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3

Verdict: ACCEPTED

Test 5

Group: 1, 2, 3

Verdict: ACCEPTED

Test 6

Group: 1, 2, 3

Verdict: ACCEPTED

Test 7

Group: 1, 2, 3

Verdict: ACCEPTED

Test 8

Group: 1, 2, 3

Verdict: ACCEPTED

Test 9

Group: 1, 2, 3

Verdict: ACCEPTED

Test 10

Group: 2, 3

Verdict: ACCEPTED

Test 11

Group: 2, 3

Verdict: ACCEPTED

Test 12

Group: 2, 3

Verdict: ACCEPTED

Test 13

Group: 2, 3

Verdict: ACCEPTED

Test 14

Group: 2, 3

Verdict: ACCEPTED

Test 15

Group: 2, 3

Verdict: ACCEPTED

Test 16

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 3

Verdict: ACCEPTED

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: ACCEPTED