1024 Tester Program

Posted 2022-10-29 sweet-ginger-candy

描述
测试程序

对于本次比赛，我们首先设计了以下问题（请注意，您无需解决它！）：

迷宫中的另一面墙

在ACM / ICPC比赛中，您经常会看到诸如“找到这条迷宫中最短路径”之类的问题。让我们把它转过头来问“给定路径，找到给定路径是最短路径的迷宫”。我们的路径将在矩形网格的规则间隔点之间垂直和水平延伸。问题是计算一组分隔网格点的单位长度挡板（墙），迫使给定路径成为从起点到终点的唯一最短路径。为了使事情变得更有趣，我们将要求不应该构造冗余的墙壁，因为它不应该移除任何墙壁并且仍然具有给定的路径作为唯一的最短路径。以下图为例，考虑通过8的路径？顶行左侧迷宫的5格。两个迷宫中的墙壁位置（右上角）使这条路径独一无二。下排的两个迷宫有问题。
路径在左侧的路径中不是唯一的，右侧有一些冗余的墙。

输入（原问题）

输入文件的第一行包含一个整数t（1≤t≤10），测试用例的数量，后跟每个测试用例的输入数据。每个测试用例的第一行由两个整数W和H（1≤W，H≤100）组成，分别给出网格的宽度和高度。测试用例的第二行包含一个路径。路径始终从左下角开始，（0,0）。它被指定为U（向上），D（向下），L（向左）和R（向右）字符的字符串（没有嵌入的空格）。您可以假设路径保持在迷宫的边界内并且不与自身相交。它可以在迷宫中的任何地方结束（即，不一定在角落中或靠墙壁）。
输出（原问题）

第i个测试用例（从1开始）的输出的第一行应包含整数M，即解决方案中使用的墙数。在第一行之后，有M行，每行包含四个连续整数形式的墙规范，对应于两对（x，y）坐标，指定由墙隔开的相邻网格点（0≤x<W且0≤y <H）。请注意，可能的输出不是唯一的。输出中不应有空行。
样本输入（原始问题）

2
8 5
RRRUULLURRRRDDRRUUU
4 3
RRRUU
样本输出（原始问题）

19
0 0 0 1
1 0 1 1
2 0 2 1
2 1 3 1
3 0 4 0
3 1 4 1
3 2 4 2
3 2 3 3
2 2 2 3
4 2 4 3
0 3 0 4
1 3 1 4
2 3 2 4
3 3 3 4
4 3 4 4
5 3 5 4
5 3 6 3
5 2 6 2
6 1 6 2
2
2 2 3 2
2 2 2 1
这是原始问题陈述的结束！懒惰，我们不想花时间为这个问题编写测试程序，并决定让你为我们写这个！
编写一个程序，将输入和输出作为一个输入测试用例接收，并写入输出CORRECT或INCORRECT以指示输出是否正确。
输入
您从标准输入中读取原始问题的输入和输出;它在每个案例输入原始问题后立即输出每个输出。
请注意，原始输出没有格式问题，即
输出文件中的行数是正确的，并且应该是这样。
输出行中没有前导或尾随空格字符。
墙壁规格是正确的，这意味着四个数字正确地指定了迷宫边界内可能的墙壁。
输出
您的程序应该为包含单个单词CORRECT或INCORRECT的输入的每个测试用例写一行，表明原始问题是否正确地产生了该测试用例的输出。

样例输入

2
8 5
RRRUULLURRRRDDRRUUU
19
0 0 0 1
1 0 1 1
2 0 2 1
2 1 3 1
3 0 4 0
3 1 4 1
3 2 4 2
3 2 3 3
2 2 2 3
4 2 4 3
0 3 0 4
1 3 1 4
2 3 2 4
3 3 3 4
4 3 4 4
5 3 5 4
5 3 6 3
5 2 6 2
6 1 6 2
4 3
RRRUU
2
2 2 3 2
2 2 2 1

样例输出

CORRECT
INCORRECT

//////////////////////////////////////////////////////////////////////////
//        POJ1024 Tester Program
//        Memory: 368K        Time: 16MS
//        Language: C++        Result: Accepted
//////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <string>
#include <queue>
using namespace std;

struct Grid 
    bool inpath;    // 是否是路径方格
    bool uwal;      // 是否有上墙
    bool rwal;      // 是否有右墙
    int scnt;       // 到源点步数
    int dcnt;       // 到终点步数
;

int main(void) 
    bool ok;
    int w, h, cnt, steps;   // 1 <= w, h <= 100
    string path;
    Grid grid[100][100];
    queue<pair<int, int> > q;

    int t, x, y, desx, desy, x2, y2, i;
    for (cin >> t; t > 0; --t) 
        //初始化数据
        cin >> w >> h;
        for (y = 0; y < h; ++y) 
            for (x = 0; x < w; ++x) 
                grid[y][x].inpath = false;
                grid[y][x].uwal = false;
                grid[y][x].rwal = false;
                grid[y][x].scnt = -1;
                grid[y][x].dcnt = -1;
            
        
        cin >> path;
        x = 0, y = 0;
        grid[0][0].inpath = true;
        steps = path.size();
        for (i = 0; i < steps; ++i) 
            switch (path[i]) 
            case ‘U‘: ++y; break;
            case ‘D‘: --y; break;
            case ‘L‘: --x; break;
            case ‘R‘: ++x; break;
            
            grid[y][x].inpath = true;
        
        desx = x, desy = y;
        cin >> cnt;
        for (i = 0; i < cnt; ++i) 
            cin >> x >> y >> x2 >> y2;
            if (x == x2)
                if (y + 1 == y2) grid[y][x].uwal = true;
                else grid[y2][x].uwal = true;
            else
                if (x + 1 == x2) grid[y][x].rwal = true;
                else grid[y][x2].rwal = true;
        

        //求各点到源点的最小步数（BFS）
        q.push(make_pair(0, 0));
        grid[0][0].scnt = 0;
        while (!q.empty()) 
            y = q.front().first, x = q.front().second;
            if (y < h - 1 && grid[y][x].uwal == false && grid[y + 1][x].scnt == -1) 
                grid[y + 1][x].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y + 1, x));
            
            if (0 < y && grid[y - 1][x].uwal == false && grid[y - 1][x].scnt == -1) 
                grid[y - 1][x].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y - 1, x));
            
            if (0 < x && grid[y][x - 1].rwal == false && grid[y][x - 1].scnt == -1) 
                grid[y][x - 1].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y, x - 1));
            
            if (x < w - 1 && grid[y][x].rwal == false && grid[y][x + 1].scnt == -1) 
                grid[y][x + 1].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y, x + 1));
            
            q.pop();
        

        //求各点到终点的最小步数（BFS）
        q.push(make_pair(desy, desx));
        grid[desy][desx].dcnt = 0;
        while (!q.empty()) 
            y = q.front().first, x = q.front().second;
            if (y < h - 1 && grid[y][x].uwal == false && grid[y + 1][x].dcnt == -1) 
                grid[y + 1][x].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y + 1, x));
            
            if (0 < y && grid[y - 1][x].uwal == false && grid[y - 1][x].dcnt == -1) 
                grid[y - 1][x].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y - 1, x));
            
            if (0 < x && grid[y][x - 1].rwal == false && grid[y][x - 1].dcnt == -1) 
                grid[y][x - 1].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y, x - 1));
            
            if (x < w - 1 && grid[y][x].rwal == false && grid[y][x + 1].dcnt == -1) 
                grid[y][x + 1].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y, x + 1));
            
            q.pop();
        

        //判断路径是否唯一最短，以及墙是否多余
        ok = true;
        for (y = 0; y < h && ok; ++y) 
            for (x = 0; x < w && ok; ++x) 
                if (grid[y][x].scnt == -1 || grid[y][x].dcnt == -1)
                    ok = false;     // 是否有封闭区域
                if (y < h - 1 && grid[y][x].uwal
                    && grid[y][x].scnt + grid[y + 1][x].dcnt + 1 > steps
                    && grid[y][x].dcnt + grid[y + 1][x].scnt + 1 > steps)
                    ok = false;     // 是否上墙多余
                if (x < w - 1 && grid[y][x].rwal
                    && grid[y][x].scnt + grid[y][x + 1].dcnt + 1 > steps
                    && grid[y][x].dcnt + grid[y][x + 1].scnt + 1 > steps)
                    ok = false;     // 是否右墙多余
                if (!grid[y][x].inpath && grid[y][x].scnt + grid[y][x].dcnt <= steps)
                    ok = false;     // 是否存在更短路径或另一最短路径
            
        
        if(ok) cout << "CORRECT" << endl;
        else cout << "INCORRECT" << endl;
    
    return 0;

来源：https://www.cnblogs.com/dengeven/p/3228687.html