Ruudukko

input/code.cpp: In function 'std::string solve(int, int, std::pair<int, int>, std::pair<int, int>)':
input/code.cpp:204:9: warning: unused variable 'best' [-Wunused-variable]
  204 |     int best = n * m;
      |         ^~~~
input/code.cpp:210:9: warning: unused variable 'min_j' [-Wunused-variable]
  210 |     int min_j = min(s.x, t.x);
      |         ^~~~~
input/code.cpp:211:9: warning: unused variable 'max_j' [-Wunused-variable]
  211 |     int max_j = max(s.x, t.x);
      |         ^~~~~

#include <bits/stdc++.h>

typedef long long ll;

#define M 1000000007
#define N (1 << 18)

#define y first
#define x second

using namespace std;

map<tuple<int, int, pair<int, int>, pair<int, int>>, int> dp;

bool check_small(int h, int w, int y0, int x0, int y1, int x1) {
	if (x0 > x1 || (x0 == x1 && y0 > y1)) return check_small(h, w, y1, x1, y0, x0);
 
	if (h == 1) {
		if (x0 == 0 && x1 == w-1) return true;
		if (x0 == w-1 && x1 == 0) return true;
		return false;
	} else {
		if (x0 == x1 && 0 < x0 && x0 < w-1) return false;
		return true;
	}
}

bool works(int h, int w, int y0, int x0, int y1, int x1) {
	if (y0 == y1 && x0 == x1) return false;
	if (w < h) return works(w, h, x0, y0, x1, y1);
	if (! ((h*w ^ abs(x0 - x1) ^ abs(y0 - y1)) & 1)) return false;
	if ((h*w & 1) && ((x0 + y0) & 1)) return false;
 
	if (h <= 2) return check_small(h, w, y0, x0, y1, x1);
	if (h == 3 && (!(w & 1))) {
		if (y0 == 1) {
			if ((x0 & 1) && x1 < x0) return false;
			if (!(x0 & 1) && x1 > x0) return false;
		} else {
			if (!(x0 & 1) && (x1 < x0 - 1)) return false;
			if ((x0 & 1) && (x1 > x0 + 1)) return false;
		}
	}   
	return true;
}

bool inside(int n, int m, pair<int, int> p) {
    return p.x <= m && p.y <= n && p.x > 0 && p.y > 0;
}

bool ok(int h, int w, pair<int, int> s, pair<int, int> t) {
    return works(h, w, s.y - 1, s.x - 1, t.y - 1, t.x - 1);
}

pair<int, int> offset(pair<int, int> p, pair<int, int> off) {
    return {p.y + off.y, p.x + off.x};
}

const int cutoff = 20;

string rev(string s) {
    map<char, char> sw;
    sw['U'] = 'D';
    sw['D'] = 'U';
    sw['L'] = 'R';
    sw['R'] = 'L';

    string ans;
    for (char c : s) ans += sw[c];
    reverse(ans.begin(), ans.end());
    return ans;
}

bool vis[51][51];

string run_brute(int n, int m, pair<int, int> c, pair<int, int> t, int left) {
    if (c.x < 1 || c.x > m || c.y < 1 || c.y > n) return "X";
    if (vis[c.y][c.x]) return "X";
    if (left == 0) {
        return c == t ? "" : "X";
    }

    vis[c.y][c.x] = 1;

    string p = run_brute(n, m, {c.y - 1, c.x}, t, left - 1);
    if (p != "X") return "U" + p;

    p = run_brute(n, m, {c.y + 1, c.x}, t, left - 1);
    if (p != "X") return "D" + p;

    p = run_brute(n, m, {c.y, c.x - 1}, t, left - 1);
    if (p != "X") return "L" + p;

    p = run_brute(n, m, {c.y, c.x + 1}, t, left - 1);
    if (p != "X") return "R" + p;

    vis[c.y][c.x] = 0;
    return "X";
}

string brute(int n, int m, pair<int, int> s, pair<int, int> t) {
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) vis[i][j] = 0;
    }

    return run_brute(n, m, s, t, n * m - 1);
}

string c2(int n, int m, pair<int, int> s, pair<int, int> t) {
    pair<int, int> dif = {s.y - t.y, s.x - t.x};

    string ans;

    if (dif == make_pair(0, -1)) {
        ans += string(s.x - 1, 'L');
        ans += s.y == 2 ? "U" : "D";
        ans += string(m - 1, 'R');
        ans += s.y == 2 ? "D" : "U";
        ans += string(m - t.x, 'L');
    }
    if (dif == make_pair(0, 1)) {
        ans += string(m - s.x, 'R');
        ans += s.y == 2 ? "U" : "D";
        ans += string(m - 1, 'L');
        ans += s.y == 2 ? "D" : "U";
        ans += string(t.x - 1, 'R');
    }
    if (dif == make_pair(-1, 0)) {
        ans += string(s.y - 1, 'U');
        ans += s.x == 2 ? "L" : "R";
        ans += string(n - 1, 'D');
        ans += s.x == 2 ? "R" : "L";
        ans += string(n - t.y, 'U');
    }
    if (dif == make_pair(1, 0)) {
        ans += string(n - s.y, 'D');
        ans += s.x == 2 ? "L" : "R";
        ans += string(n - 1, 'U');
        ans += s.x == 2 ? "R" : "L";
        ans += string(t.y - 1, 'D');
    }

    return ans;
}

string solve(int n, int m, pair<int, int> s, pair<int, int> t);

string solve_strip(tuple<int, int, pair<int, int>, pair<int, int>> p1, tuple<int, int, pair<int, int>, pair<int, int>> p2) {
    map<char, pair<int, int>> dir_to_dif;
    dir_to_dif['U'] = {-1, 0};
    dir_to_dif['D'] = {1, 0};
    dir_to_dif['R'] = {0, 1};
    dir_to_dif['L'] = {0, -1};

    string path = solve(get<0>(p2), get<1>(p2), get<2>(p2), get<3>(p2));

    string res;

    pair<int, int> tgt = get<2>(p1);
    pair<int, int> pos = get<2>(p2);

    if (pos.x == tgt.x || pos.y == tgt.y) {
        bool begin = 0;
        if (get<3>(p1).y == 1 && path[0] == 'D') {
            begin = 1;
        } else if (get<3>(p1).y > 1 && path[0] == 'U') {
            begin = 1;
        } else if (get<3>(p1).x == 1 && path[0] == 'R') {
            begin = 1;
        } else if (get<3>(p1).x > 1 && path[0] == 'L') {
            begin = 1;
        }

        if (begin) {
            pair<int, int> dif = dir_to_dif[path[res.size()]];
            pos = make_pair(pos.y + dif.y, pos.x + dif.x);
            res += (path[res.size()]);
        }
    }

    while (pos.x != tgt.x && pos.y != tgt.y) {
        pair<int, int> dif = dir_to_dif[path[res.size()]];
        pos = make_pair(pos.y + dif.y, pos.x + dif.x);
        res += (path[res.size()]);
    }

    string end_path = path.size() > res.size() + 1 ? path.substr(res.size() + 1, 1e5) : "";

    if (get<3>(p1).y == 1) {
        res = res + "U" + c2(2, get<1>(p1), {2, pos.x}, {2, pos.x + dir_to_dif[path[res.size()]].x}) + "D";
    } else if (get<3>(p1).y > 1) {
        res = res + "D" + c2(2, get<1>(p1), {1, pos.x}, {1, pos.x + dir_to_dif[path[res.size()]].x}) + "U";
    } else if (get<3>(p1).x == 1) {
        res = res + "L" + c2(get<0>(p1), 2, {pos.y, 2}, {pos.y + dir_to_dif[path[res.size()]].y, 2}) + "R";
    } else if (get<3>(p1).x > 1) {
        res = res + "R" + c2(get<0>(p1), 2, {pos.y, 1}, {pos.y + dir_to_dif[path[res.size()]].y, 1}) + "L";
    }

    return res + end_path;
}

string solve(int n, int m, pair<int, int> s, pair<int, int> t) {
    if (s > t) return rev(solve(n, m, t, s));
    int best = n * m;
    //if (best <= cutoff) return brute(n, m, s, t);

    int min_i = min(s.y, t.y);
    int max_i = max(s.y, t.y);

    int min_j = min(s.x, t.x);
    int max_j = max(s.x, t.x);

    if (min_i > 2) {
        if (ok(n - 2, m, offset(s, {-2, 0}), offset(t, {-2, 0}))) {
            auto x1 = make_tuple(2, m, make_pair(1, 0), make_pair(1,0));
            auto x2 = make_tuple(n - 2, m, offset(s, {-2, 0}), offset(t, {-2, 0}));

            return solve_strip(x1, x2);
        }
    }

    if (max_i < n - 1) {
        if (ok(n - 2, m, s, t)) {
            auto x1 = make_tuple(2, m, make_pair(n - 2, 0), make_pair(2,0));
            auto x2 = make_tuple(n - 2, m, s, t);

           return solve_strip(x1, x2);
        }
    }

    /*if (min_j > 2) {
        if (ok(n, m - 2, offset(s, {0, -2}), offset(t, {0, -2}))) {
            auto x1 = make_tuple(n, 2, make_pair(0, 1), make_pair(0,1));
            auto x2 = make_tuple(n, m - 2, offset(s, {0, -2}), offset(t, {0, -2}));

            return solve_strip(x1, x2);
        }
    }

    if (max_j < m - 1) {
        if (ok(n, m - 2, s, t)) {
            auto x1 = make_tuple(n, 2, make_pair(0, m - 2), make_pair(0,2));
            auto x2 = make_tuple(n, m - 2, s, t);

            return solve_strip(x1, x2);
        }
    }*/
    
    if (true) {
        set<int> st_j;
        st_j.insert(1);
        st_j.insert(2);
        
        if (m % 2 == 0) st_j.insert(m);
        else st_j.insert(m - 1);
        for (int j : st_j) {
            int first_n = 2;
            int second_n = n - 2;

            pair<int, int> first_e = {first_n, j};
            pair<int, int> second_e = {first_n + 1, j};

            if (inside(first_n, m, s) 
                && inside(second_n, m, offset(t, {-first_n, 0}))
                && ok(first_n, m, s, first_e) 
                && ok(second_n, m, offset(t, {-first_n, 0}), offset(second_e, {-first_n, 0}))
            ) {
                string s1 = solve(first_n, m, s, first_e);
                string s2 = solve(second_n, m, offset(second_e, {-first_n, 0}), offset(t, {-first_n, 0})); 

                return s1 + "D" + s2;
            }
        }
    }

    //cout << n << " " << m << endl;

    if (n * m <= cutoff) return brute(n, m, s, t);

    if (n > 3) exit(-1);

    return string("X", n * m - 1);
    
    /*if (m > n) {
        set<int> st_i;
        st_i.insert(1);
        st_i.insert(2);
        
        if (n % 2 == 0) st_i.insert(n);
        else st_i.insert(n - 1);
        for (int i : st_i) {
            int first_m = 2;
            int second_m = m - 2;

            pair<int, int> first_e = {i, first_m};
            pair<int, int> second_e = {i, first_m + 1};

            if (inside(n, first_m, s) 
                && inside(n, second_m, offset(t, {0, -first_m}))
                && ok(n, first_m, s, first_e) 
                && ok(n, second_m, offset(t, {0, -first_m}), offset(second_e, {0, -first_m}))
            ) { 
                string s1 = solve(n, first_m, s, first_e);
                string s2 = solve(n, second_m, offset(second_e, {0, -first_m}), offset(t, {0, -first_m}));

                return s1 + "R" + s2;
            }

            if (inside(n, first_m, t) 
                && inside(n, second_m, offset(s, {0, -first_m}))
                && ok(n, first_m, t, first_e) 
                && ok(n, second_m, offset(s, {0, -first_m}), offset(second_e, {0, -first_m}))
            ) {
                string s2 = solve(n, first_m, first_e, t);
                string s1 = solve(n, second_m, offset(s, {0, -first_m}), offset(second_e, {0, -first_m}));

                return s1 + "L" + s2;
            }
        }
    }*/
}

void test_case() {
    int n, m;
    int sy, sx;
    int ty, tx;

    cin >> n >> m >> sy >> sx >> ty >> tx;

    if (!ok(n, m, {sy, sx}, {ty, tx})) {
        cout << "NO" << endl;
        return;
    }

    cout << "YES" << endl;
    //cout << n << " " << m << " " << sy << " " << sx << " " << ty << " " << tx << endl;
    string ans = solve(n, m, {sy, sx}, {ty, tx});
    cout << ans << "\n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    cin >> t;
    for (int i = 0; i < t; ++i) {
        test_case();
    }

    return 0;
}

Test 1

Group: 1, 5

Verdict: WRONG ANSWER

Test 2

Group: 2, 5

Verdict: WRONG ANSWER

Test 3

Group: 3, 5

Verdict: WRONG ANSWER

Test 4

Group: 4, 5

Verdict: RUNTIME ERROR

Test 5

Group: 5

Verdict: RUNTIME ERROR

Test 6

Group: 5

Verdict: RUNTIME ERROR

Test 7

Group: 2, 5

Verdict: ACCEPTED

Test 8

Group: 2, 5

Verdict: ACCEPTED

Test 9

Group: 3, 5

Verdict: ACCEPTED

Test 10

Group: 3, 5

Verdict: ACCEPTED

Test 11

Group: 3, 5

Verdict: WRONG ANSWER

Test 12

Group: 3, 5

Verdict: WRONG ANSWER

Test 13

Group: 4, 5

Verdict: ACCEPTED

Test 14

Group: 5

Verdict: RUNTIME ERROR

Test 15

Group: 3, 5

Verdict: WRONG ANSWER

Test 16

Group: 5

Verdict: RUNTIME ERROR