Ruudukko

warning: unused import: `rand::prelude::*`
 --> input/code.rs:1:5
  |
1 | use rand::prelude::*;
  |     ^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `std::collections::BTreeMap`
 --> input/code.rs:2:5
  |
2 | use std::collections::BTreeMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: value assigned to `y` is never read
  --> input/code.rs:96:13
   |
96 |             y += 1;
   |             ^
   |
   = note: `#[warn(unused_assignments)]` on by default
   = help: maybe it is overwritten before being read?

warning: value assigned to `y` is never read
  --> input/code.rs:99:13
   |
99 |             y -= 1;
   |             ^
   |
   = help: maybe it is overwritten before being read?

warning: function is never used: `flip_x`
  --> input/code.rs:15:4
   |
15 | fn flip_x(path: String) -> String {
   |    ^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

use rand::prelude::*;
use std::collections::BTreeMap;
use std::io::BufRead;

fn flip_y(path: String) -> String {
    path.chars()
        .map(|c| match c {
            'U' => 'D',
            'D' => 'U',
            c => c,
        })
        .collect()
}

fn flip_x(path: String) -> String {
    path.chars()
        .map(|c| match c {
            'R' => 'L',
            'L' => 'R',
            c => c,
        })
        .collect()
}

fn solve(h: usize, w: usize, y1: usize, x1: usize, y2: usize, x2: usize) -> Option<String> {
    if y2 < y1 {
        return solve(h, w, h + 1 - y1, x1, h + 1 - y2, x2).map(flip_y);
    }
    if x2 < x1 {
        return solve(h, w, y1, w + 1 - x1, y2, w + 1 - x2).map(flip_y);
    }

    if h == 1 {
        if x1 == 1 && x2 == w {
            Some("R".repeat(w - 1))
        } else {
            None
        }
    } else if h == 2 {
        if y1 == 2 {
            return solve(h, w, h + 1 - y1, x1, h + 1 - y2, x2).map(flip_y);
        }
        assert!(y1 == 1);

        if x1 == x2 {
            if x1 == 1 {
                // Go right, down, and then back left
                return Some(format!("{}D{}", "R".repeat(w - 1), "L".repeat(w - 1)));
            } else if x1 == w {
                // Go left, down, and then back right
                return Some(format!("{}D{}", "L".repeat(w - 1), "R".repeat(w - 1)));
            } else {
                return None;
            }
        }
        assert!(x1 < x2);
        // Go first left until the left wall, then back, then fill the space in between, right and back left
        let mut res = "".to_string();
        let mut x = x1;
        while x > 1 {
            res.push('L');
            x -= 1;
        }
        res.push('D');
        while x <= x1 {
            res.push('R');
            x += 1;
        }
        // Now we need to go up and down until we reach x2, hopefully on the other side
        let mut y = 2;
        while x + 1 < x2 {
            res.push('R');
            x += 1;
            if y == 1 {
                res.push('D');
                y += 1;
            } else {
                res.push('U');
                y -= 1;
            }
        }
        // In next step we share x coordinate with x2
        res.push('R');
        x += 1;
        if y == y2 {
            // We hit end, this a failure because the other cell in this column is unvisited
            return None;
        }
        // Now we just walk right until wall, go up or down, and then walk back to x2
        while x < w {
            res.push('R');
            x += 1;
        }
        if y == 1 {
            res.push('D');
            y += 1;
        } else {
            res.push('U');
            y -= 1;
        }
        while x > x2 {
            res.push('L');
            x -= 1;
        }

        assert!(res.len() == h * w - 1);
        Some(res)
    } else {
        unimplemented!()
    }
}

fn main() {
    let stdin = std::io::stdin();
    let stdin = stdin.lock();
    let mut lines = stdin.lines();

    let t: usize = lines.next().unwrap().unwrap().parse().unwrap();
    for _ in 0..t {
        let input: Vec<usize> = lines
            .next()
            .unwrap()
            .unwrap()
            .split_whitespace()
            .map(|v| v.parse().unwrap())
            .collect();
        if let Some(res) = solve(input[0], input[1], input[2], input[3], input[4], input[5]) {
            println!("YES");
            println!("{}", res);
        } else {
            println!("NO");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
}

Test 1

Group: 1, 5

Verdict: WRONG ANSWER

Test 2

Group: 2, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'assertion failed: res.len() == h * w - 1', input/code.rs:106:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 3

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 4

Group: 4, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 5

Group: 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 6

Group: 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 7

Group: 2, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'assertion failed: res.len() == h * w - 1', input/code.rs:106:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 8

Group: 2, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'assertion failed: res.len() == h * w - 1', input/code.rs:106:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 9

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 10

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 11

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 12

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 13

Group: 4, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 14

Group: 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 15

Group: 3, 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 16

Group: 5

Verdict: RUNTIME ERROR

thread 'main' panicked at 'not implemented', input/code.rs:109:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace