Submission #2165569

---

Source Code Expand

#include <bits/stdc++.h>
using namespace std;

#define int long long

int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};

/*
#define cin ifs
#define cout ofs
ifstream ifs("in.txt");
ofstream ofs("out.txt");
//*/

int H, W, K, T;
int omp[30][30], nmp[30][30] = {};
int A[450], B[450], C[450], D[450];

// xorshiftを用いた乱数
unsigned int xor64(int range) {
    static unsigned int x = 88172645463325252ULL;
    x = x ^ (x << 13);
    x = x ^ (x >> 7);
    return (x = x ^ (x << 17)) % range;
}

//盤面をリセット
void reset() {
    for (int i = 0; i < 30; i++) {
        for (int j = 0; j < 30; j++) {
            omp[i][j] = nmp[i][j];
        }
    }
    for (int i = 0; i < 30; i++) {
        for (int j = 0; j < 30; j++) {
            nmp[i][j] = -1;
        }
    }
}

signed main() {
    cin >> H >> W >> K >> T;
    reset();
    for (int i = 0; i < 450; i++) {
        cin >> A[i] >> B[i] >> C[i] >> D[i];
        A[i]--;
        B[i]--;
        C[i]--;
        D[i]--;
        nmp[A[i]][B[i]] = i;
    }
    int turn = 2000;
    cout << turn << endl;
    for (int i = 0; i < turn; i++) {
        reset();
        double prob = exp(-100.0 / (turn - i + 1));
        for (int j = 0; j < 450; j++) {
            if (xor64(2) == 0) {
                int dy = (C[j] - A[j] > 0) - (C[j] - A[j] < 0);
                if (prob > xor64(1000) / 1000.0) {
                    dy = xor64(3) - 1;
                }
                if ((omp[A[j] + dy][B[j]] != -1 && omp[A[j] + dy][B[j]] != j) ||
                    nmp[A[j] + dy][B[j]] != -1 || A[j] + dy < 0 ||
                    A[j] + dy >= 30) {
                    dy = 0;
                }
                A[j] += dy;
                nmp[A[j]][B[j]] = j;
                switch (dy) {
                    case 1:
                        cout << 'D';
                        break;
                    case -1:
                        cout << 'U';
                        break;
                    case 0:
                        cout << '-';
                        break;
                }
            } else {
                int dx = (D[j] - B[j] > 0) - (D[j] - B[j] < 0);
                if (prob > xor64(1000) / 1000.0) {
                    dx = xor64(3) - 1;
                }
                if ((omp[A[j]][B[j] + dx] != -1 && omp[A[j]][B[j] + dx] != j) ||
                    nmp[A[j]][B[j] + dx] != -1 || B[j] + dx < 0 ||
                    B[j] + dx >= 30) {
                    dx = 0;
                }
                B[j] += dx;
                nmp[A[j]][B[j]] = j;
                switch (dx) {
                    case 1:
                        cout << 'R';
                        break;
                    case -1:
                        cout << 'L';
                        break;
                    case 0:
                        cout << '-';
                        break;
                }
            }
        }
        cout << endl;
    }
    return 0;
}

Submission Info

Judge Result