Monikulmio

warning: unused variable: `i`
  --> input/code.rs:14:9
   |
14 |     for i in 0..k {
   |         ^ help: if this is intentional, prefix it with an underscore: `_i`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `j`
  --> input/code.rs:44:17
   |
44 |             for j in 0..dy.abs() {
   |                 ^ help: if this is intentional, prefix it with an underscore: `_j`

warning: unused variable: `j`
  --> input/code.rs:51:17
   |
51 |             for j in 0..dx.abs() {
   |                 ^ help: if this is intentional, prefix it with an underscore: `_j`

warning: unused variable: `j`
  --> input/code.rs:61:17
   |
61 |             for j in 0..dx.abs() {
   |                 ^ help: if this is intentional, prefix it with an underscore: `_j`

warning: variable does not need to be mutable
  --> input/code.rs:80:25
   |
80 |                     let mut index = points.iter().position(|&a| a == (*x, *y)).unwrap();
   |                         ----^^...

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("failed to readline");
    let mut iter = input.trim().split_whitespace();
    let (n, m, k): (i32, i32, i32) = (
        iter.next().unwrap().parse().unwrap(),
        iter.next().unwrap().parse().unwrap(),
        iter.next().unwrap().parse().unwrap(),
    );
    
    let mut points: Vec<(i32, i32)> = Vec::new();
    for i in 0..k {
        let mut point = String::new();
        io::stdin().read_line(&mut point).expect("failed to readline");
        let mut iter2 = point.trim().split_whitespace();
        let (y, x): (i32, i32) = (
            iter2.next().unwrap().parse().unwrap(),
            iter2.next().unwrap().parse().unwrap(),
        );
        points.push((x, y));
    }

    let mut descending: Vec<(i32, i32)> = Vec::new();
    let mut ascending: Vec<(i32, i32)> = Vec::new();
    let mut horizontal: Vec<(i32, i32)> = Vec::new();
    let mut vertical: Vec<(i32, i32)> = Vec::new();
    
    let size = points.len();
    for (i, (px, py)) in points.clone().into_iter().enumerate() {
        let p1: (i32, i32) = (px, py);
        let p2: (i32, i32);
        if i == size - 1 {
            p2 = points[0];
        } else {
            p2 = points[i+1];
        }
        let dx = p2.0 - p1.0;
        let dy = p2.1 - p1.1;
        if dx == 0 { // Vertical
            let mut ny = p1.1;
            let step = dy/(dy.abs());
            for j in 0..dy.abs() {
                vertical.push((p1.0, ny));
                ny += step;
            }
        } else if dy == 0 { // Horizontal
            let mut nx = p1.0;
            let step = dx/(dx.abs());
            for j in 0..dx.abs() {
                horizontal.push((nx ,p1.1));
                nx += step;
            }
        } else {
            let k = dy/dx;
            let mut nx = p1.0;
            let mut ny = p1.1;
            let step_x = dx/(dx.abs());
            let step_y = dy/(dy.abs());
            for j in 0..dx.abs() {
                if k == -1 { // Ascending
                    ascending.push((nx ,ny));
                } else {
                    descending.push((nx ,ny));
                }
                nx += step_x;
                ny += step_y;
            }
        }
    }
    for i in 0..n {
        let mut inside: bool = false;
        let mut is_special: bool = false;
        let mut is_up: bool = false;
        let mut line = String::new();
        'row: for j in 0..m {
            for (x, y) in &points {
                if (j + 1, i + 1) == (*x, *y) {
                    let mut index = points.iter().position(|&a| a == (*x, *y)).unwrap();
                    let (mut p1, mut p2);
                    if index == 0 {
                        p1 = points[size - 1];
                    } else {
                        p1 = points[index - 1];
                    }

                    if index == size - 1 {
                        p2 = points[0];
                    } else {
                        p2 = points[index + 1];
                    }

                    let mut dx1 = x - p1.0;
                    let mut dx2 = x - p2.0;
                    let mut dy1 = y - p1.1;
                    let mut dy2 = y - p2.1;
                    let dx1 = if dx1 == 0 {0} else {dx1/(dx1.abs())};
                    let dx2 = if dx2 == 0 {0} else {dx2/(dx2.abs())};
                    let dy1 = if dy1 == 0 {0} else {dy1/(dy1.abs())};
                    let dy2 = if dy2 == 0 {0} else {dy2/(dy2.abs())};
                    if dx1 == dx2 && dy1 == dy2 {
                        if dx1 == 0 {
                            inside = !inside;
                        }
                    } else {
                        if dy1 != dy2 {
                            if (dy1 == 0 || dy2 == 0) && !is_special {
                                is_special = !is_special;
                                is_up = if dy1 == 1 || dy2 == 1 {true} else {false};
                                inside = !inside;
                            } else if is_special {
                                if is_up && (dy1 == 1 || dy2 == 1) {
                                    inside = !inside;
                                }
                                is_special = false;
                            } else {
                                inside = !inside;
                            }
                        }
                    }
                    line.push('*');
                    continue 'row;
                }
            }
            for (x, y) in &horizontal {
                if (j + 1, i + 1) == (*x, *y) {
                    line.push('=');
                    continue 'row;
                }
            }
            for (x, y) in &vertical {
                if (j + 1, i + 1) == (*x, *y) {
                    line.push('|');
                    inside = !inside;
                    continue 'row;
                }
            }
            for (x, y) in &ascending {
                if (j + 1, i + 1) == (*x, *y) {
                    line.push('/');
                    inside = !inside;
                    continue 'row;
                }
            }
            for (x, y) in &descending {
                if (j + 1, i + 1) == (*x, *y) {
                    line.push('\\');
                    inside = !inside;
                    continue 'row;
                }
            }
            if inside {
                line.push('#');
            } else {
                line.push('.');
            }
        }
        println!("{}", line);
    }

    
}

Test 1 (public)

Verdict: ACCEPTED

Test 2 (public)

Verdict: ACCEPTED

Test 3 (public)

Verdict: ACCEPTED

Test 4 (public)

Verdict: ACCEPTED

Test 5 (public)

Verdict: ACCEPTED

Test 6 (public)

Verdict: ACCEPTED

Test 7 (public)

Verdict: ACCEPTED

Test 8 (public)

Verdict: ACCEPTED

Test 9 (public)

Verdict: ACCEPTED

Test 10 (public)

Verdict: ACCEPTED