Ruudukko

warning: unused variable: `x`
  --> input/code.rs:33:10
   |
33 |     for (x, row) in columns.iter().enumerate() {
   |          ^ help: if this is intentional, prefix it with an underscore: `_x`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `i`
  --> input/code.rs:71:10
   |
71 |     for (i, value) in row.iter().enumerate() {
   |          ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: 2 warnings emitted

use std::cmp::Ordering;
use std::collections::{BTreeSet, HashMap};
use std::io;

const MOD: u32 = (10_i32.pow(9) + 7) as u32;

fn main() {
    let dimension = {
        let mut input: String = String::new();
        io::stdin().read_line(&mut input).unwrap();
        input.strip_suffix("\n").unwrap().parse::<usize>().unwrap()
    };

    let mut columns: Vec<BTreeSet<(usize, Cell)>> = Vec::with_capacity(dimension);
    for _x in 0..dimension {
        columns.push(BTreeSet::new());
    }

    for _y in 0..dimension {
        let mut input: String = String::new();
        io::stdin().read_line(&mut input).unwrap();
        let input_row: Vec<u32> = input.split_whitespace().map(|str| str.parse::<u32>().unwrap()).collect();

        for (x, value) in input_row.iter().enumerate() {
            columns[x].insert((x, Cell {
                value: *value,
                possible_paths: calculate_reliably_until(input_row.clone(), value)
            }));
        }
    }

    let mut sum: u32 = 0;
    for (x, row) in columns.iter().enumerate() {
        let mut row_paths: HashMap<usize, u32> = HashMap::new();
        for (y, cell) in row {
            let value = cell.value;
            let mut path_counter = cell.possible_paths;

            // Horizontal matches
            for (other_x, other) in row {
                if other.value < value {
                    path_counter = (path_counter + 1 + row_paths.get(other_x).unwrap_or(&0_u32)) % MOD;
                }
            }

            row_paths.insert(*y, path_counter);

            sum = (sum + path_counter) % MOD;
        }
    }

    println!("{}", sum);
}

#[derive(Eq, PartialOrd, PartialEq)]
struct Cell {
    value: u32,
    possible_paths: u32,
}

impl Ord for Cell {
    fn cmp(&self, other: &Self) -> Ordering {
        self.value.cmp(&other.value)
    }
}

fn calculate_reliably_until(mut row: Vec<u32>, last_value: &u32) -> u32 {
    row.sort();
    let mut paths: Vec<u32> = Vec::new();
    let mut counter = 1;
    for (i, value) in row.iter().enumerate() {
        if value >= last_value { break; }
        let first_of_value = row.iter().position(|v| v == value).unwrap();
        let mut cell_counter = 0;
        for other in paths[0..first_of_value].iter() {
            cell_counter += 1 + other;
        }
        paths.push(cell_counter);
        counter += 1 + cell_counter;
    }
    counter
}

Test 1

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 2

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 3

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 4

Group: 2, 3

Verdict: WRONG ANSWER

Test 5

Group: 2, 3

Verdict: WRONG ANSWER

Test 6

Group: 2, 3

Verdict: WRONG ANSWER

Test 7

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 3

Verdict: TIME LIMIT EXCEEDED