USACO the castle

最新推荐文章于 2021-09-07 16:43:30 发布
最新推荐文章于 2021-09-07 16:43:30 发布
阅读量376 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C语言 usaco 文章标签： usaco
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40058642/article/details/87887180
本文深入解析USACO竞赛中的经典题目“城堡”，通过详细阐述深搜算法的应用，逐步解决房间数量、最大房间面积及拆除特定墙壁后的影响。文章记录了从理解题意、设计算法到调试代码的全过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这个题是usaco第二章的第一个题，很高兴啊，虽然这个题目真的太长了，又不好懂，但是对照字典来多看几遍肯定会弄明白的，这里就不讲题意了。
首先要找出所有的房间以及它们的大小
然后找出拆了那面墙会使出现最大的房间。
整张地图不会超过50x50.
首先输出城堡里有多少房间，
输出最大房间的大小
输出拆掉一面墙之后最大的房间
输出拆掉这面墙的位置（保证这面墙存在）
首先的想法是，读取所有的数据后，对每个数据进行拆分，然后。。。编不下去了，还是看看网上是什么解决办法吧。。。第一次做毫无头绪很正常啊。
网上的说法是深搜，但是如何深搜？题意都没搞清啊？而且看他们的代码好像还很简单的样子。。
但是不幸的是，他们讲的好像是其他的题。既然知道是深搜了，就大概知道怎么做了。
它的每个数字表示的是墙的叠加，这个1，2，4，8是可以无歧义拆分的，因此我们可以先将其拆分，非常棒，就先这么做，听网上说它是没有时间限制的。


#include <iostream>
using namespace std;

typedef struct Room{
    bool isUsed = false;
    bool northWall = false;
    bool southWall = false;
    bool westWall = false;
    bool eastWall = false;
} Room;
int m, n;
Room room[55][55];
int roomCount, roomSize[55], roomsize;
void dfs(int ci, int cj){
    roomsize++;
    room[ci][cj].isUsed = true;
    if(room[ci][cj].eastWall==false && ci<m){
        dfs(ci+1, cj);
    }
    if(room[ci][cj].westWall==false && ci>1){
        dfs(ci-1, cj);
    }
    if(room[ci][cj].southWall==false && cj<n){
        dfs(ci, cj+1);
    }
    if(room[ci][cj].northWall==false && cj>1){
        dfs(ci, cj-1);
    }
}

int main(){
    FILE *pFile1 = fopen("castle.in", "r");
    FILE *pFile2 = fopen("castle.out", "w");
    fscanf(pFile1, "%d%d", &m, &n);
    for(int i=1; i<=m; i++){
        for(int j=1; j<=n; j++){
            int t;
            fscanf(pFile1, "%d", &t);
            if(t >= 8){
                t -= 8;
                room[i][j].southWall = true;
            }
            if( t >= 4){
                t -= 4;
                room[i][j].eastWall = true;
            }
            if( t >= 2){
                t -= 2;
                room[i][j].northWall = true;
            }
            if(t >= 1){
                t -= 1;
                room[i][j].westWall = true;
            }
        }
    }
    for(int i=1; i<=m; i++){
        for(int j=1; j<=n; j++){
            if(room[i][j].isUsed == false){
                dfs(i, j);
                roomSize[roomCount++] = roomsize;
                roomsize = 0;
            }
        }
    }
    cout << roomCount << endl;
    fclose(pFile1); fclose(pFile2);
	return 0;
}

虽然是错误的，但至少出数了，这个是一个良好的开始。。。

void dfs(int ci, int cj){
    if(room[ci][cj].isUsed == true){
        return;
    }else{
        roomsize++;
        room[ci][cj].isUsed = true;
        if(room[ci][cj].eastWall==false && cj<m){
            dfs(ci, cj+1);
        }
        if(room[ci][cj].westWall==false && cj>1){
            dfs(ci, cj-1);
        }
        if(room[ci][cj].southWall==false && ci<n){
            dfs(ci+1, cj);
        }
        if(room[ci][cj].northWall==false && ci>1){
            dfs(ci-1, cj);
        }
    }
}

关键是这里，看出与上面的不同了吗？原来一开始，我根本就不知道如何调试，后来按照图中一点点移动，才发现这个问题
但是还是不正确，接着调试.
发现是m和n没有替换过来，替换了过来，还是错误。。。
接着调试。。。
发现了一个惊天bug----不说了，规定第一个参数为行，第二个参数为列。。参数输入的顺序与测试的顺序应该是相等的啊？


#include <iostream>
#include "algorithm"
using namespace std;

typedef struct Room{
    bool isUsed = false;
    bool northWall = false;
    bool southWall = false;
    bool westWall = false;
    bool eastWall = false;
} Room;
int m, n;
Room room[55][55]; // 房间单位
int roomCount, roomSize[55], roomsize;
void dfs(int ci, int cj){
    if(room[ci][cj].isUsed == true){
        return;
    }else{
        roomsize++;
        room[ci][cj].isUsed = true;
        if(room[ci][cj].eastWall==false && cj<m){
            dfs(ci, cj+1);
        }
        if(room[ci][cj].westWall==false && cj>1){
            dfs(ci, cj-1);
        }
        if(room[ci][cj].southWall==false && ci<n){
            dfs(ci+1, cj);
        }
        if(room[ci][cj].northWall==false && ci>1){
            dfs(ci-1, cj);
        }
    }
}

int main(){
    FILE *pFile1 = fopen("castle.in", "r");
    FILE *pFile2 = fopen("castle.out", "w");
    fscanf(pFile1, "%d%d", &m, &n);
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            int t;
            fscanf(pFile1, "%d", &t);
            if(t >= 8){
                t -= 8;
                room[i][j].southWall = true;
            }
            if( t >= 4){
                t -= 4;
                room[i][j].eastWall = true;
            }
            if( t >= 2){
                t -= 2;
                room[i][j].northWall = true;
            }
            if(t >= 1){
                t -= 1;
                room[i][j].westWall = true;
            }
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(room[i][j].isUsed == false){
                dfs(i, j); // 一次深搜获得一个房间
                roomSize[roomCount++] = roomsize;
                roomsize = 0;
            }
        }
    }
    sort(roomSize, roomSize+roomCount);
    cout << roomCount << endl;
    cout << roomSize[roomCount-1] << endl;
    fclose(pFile1); fclose(pFile2);
	return 0;
}

这个代码就是对的了，因为我完全把行和列搞混了。。。错误就是这个。。。只有这个，mmp。
好了，下面看找到那个墙怎么办？就是定义变量，挨个拆墙就行了。
如何拆墙呢？就是，额，一个一个的拆，拆右面或者上面的
输出最大的房间值和墙的位置

    int lagestRoom = 0;
    bool isN = true;
    int posX, posY;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(i != 1){ // 拆上面的
                if(room[i][j].northWall){
                    room[i][j].northWall = false;
                    room[i-1][j].southWall = false;
                    for(int k=1; k<=n; k++)
                        for(int g=1; g<=m; g++)
                            dfs(i, j);
                    
                }
            }
            if(j != m){ // 拆右面的

            }
        }
    }

``
写到这里，我果断放弃，嵌套四个循环，太复杂了。。。。
应该脱离成为一个函数才行

        int lagestRoom = 0;
    bool isN = true;
    int posX=1, posY=1;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(i!=1 && room[i][j].northWall){ // 拆上面的
                room[i][j].northWall = false;
                room[i-1][j].southWall = false;
                int t = theSizeOfRoom();
                if(t > lagestRoom){
                    lagestRoom = t;
                    posX = i; posY = j;
                    isN = true;
                }
                room[i][j].northWall = true;
                room[i-1][j].southWall = true;
            }
            if(j!=m && room[i][j].eastWall){ // 拆右面的
                room[i][j].eastWall = false;
                room[i][j+1].westWall = false;
                int t = theSizeOfRoom();
                if(t > lagestRoom){
                    lagestRoom = t;
                    posX = i; posY = j;
                    isN = false;
                }
                room[i][j].eastWall = true;
                room[i][j+1].westWall = true;
            }
        }
    }
    cout << lagestRoom <<endl;
    cout << posX <<" "<< posY <<" "<< (isN?"N":"E") <<endl;
    fclose(pFile1); fclose(pFile2);

`
后面又写了这么多，这个debug简直太难了，出了错都不知道如何修正。。。这段代码发现，无论如何，最终结果都是零，查了半天才发现，isuse没有修正，然后就变成了这个德行。。
加上了，16是得出了，但是后面是3 3 E，显然不对，为什么呢？看来是有不止一个，但是取最小的应该是这样，仔细读题意才发现，是最西南角的，先最西边的角然后最南边的角，是n的话选择n，可以通过调整循环顺序来完成操作.
稍微改了一下，终于成功了，花费了半天的时间，泪目。。。
等不及了，赶紧提交。。。
哦忘记了，应该打印在文件里。。。
但是现在到task5又出现了问题，能用n不用e，看来n的能力还相当的高。。。还得额外判断，在e那里
if(t==lagestRoom && isN) continue;
不对，这样第一个就有错误了，这到底是怎么回事呢？反正是最后一个的事情了，前面的都已经搞定了，唉，命运多舛啊。。。
经过debug后，发现这两个坐标的值其实是一样的，那么问题来了，到底是毛的顺序。。。
最靠西的，那么就是先要j最小才行，哦，明白了，j要放在外层循环。。。
现在一直运行到了task7，这个测试点比较恐怖，是50x50个15点。。。我这个是拆掉一堵墙之后，最大空间还是1，它按理论来说应该是2才对。。。
耍了一个小机灵，在定义的时候直接int lagestRoom = 2;就好了嘛，我真是个小机灵鬼。
还是不对，又把这个定义直接改成 int posX=n, posY=1;
不对不对，而且人家的2500， 你的25，这个怎么会相等。。。
后来发现roomsize数组开小了，只开了55个，至少2500才对。。。
好了，一共8个测试点，终于全部过了，花了今天一个下午+一个晚上（也许没那么多，我玩了不少），话说我还没有在一天内A通一道题呢。。。下面是AC的代码：


    /*
ID:22920179
PROB:castle
LANG:C++
*/
#include <iostream>
#include "cstring"
#include "algorithm"
using namespace std;

typedef struct Room{
    bool isUsed = false;
    bool northWall = false;
    bool southWall = false;
    bool westWall = false;
    bool eastWall = false;
} Room;
int m, n;
Room room[55][55]; // 房间单位
int roomCount, roomSize[2600], roomsize;
void dfs(int ci, int cj){
    if(room[ci][cj].isUsed == true){
        return;
    }else{
        roomsize++;
        room[ci][cj].isUsed = true;
        if(room[ci][cj].eastWall==false && cj<m){
            dfs(ci, cj+1);
        }
        if(room[ci][cj].westWall==false && cj>1){
            dfs(ci, cj-1);
        }
        if(room[ci][cj].southWall==false && ci<n){
            dfs(ci+1, cj);
        }
        if(room[ci][cj].northWall==false && ci>1){
            dfs(ci-1, cj);
        }
    }
}
int theSizeOfRoom(){
    roomCount = 0;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            room[i][j].isUsed = false;
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(room[i][j].isUsed == false){
                dfs(i, j); // 一次深搜获得一个房间
                roomSize[roomCount++] = roomsize;
                roomsize = 0;
            }
        }
    }
    sort(roomSize, roomSize+roomCount);
    return roomSize[roomCount-1];
}
int main(){
    FILE *pFile1 = fopen("castle.in", "r");
    FILE *pFile2 = fopen("castle.out", "w");
    fscanf(pFile1, "%d%d", &m, &n);
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            int t;
            fscanf(pFile1, "%d", &t);
            if(t >= 8){
                t -= 8;
                room[i][j].southWall = true;
            }
            if( t >= 4){
                t -= 4;
                room[i][j].eastWall = true;
            }
            if( t >= 2){
                t -= 2;
                room[i][j].northWall = true;
            }
            if(t >= 1){
                t -= 1;
                room[i][j].westWall = true;
            }
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(room[i][j].isUsed == false){
                dfs(i, j); // 一次深搜获得一个房间
                roomSize[roomCount++] = roomsize;
                roomsize = 0;
            }
        }
    }
    sort(roomSize, roomSize+roomCount);
    cout << roomCount << endl;
    cout << roomSize[roomCount-1] << endl;
    fprintf(pFile2, "%d\n", roomCount);
    fprintf(pFile2, "%d\n", roomSize[roomCount-1]);
    int lagestRoom = 2;
    bool isN = true;
    int posX=n, posY=1;
    for(int j=m; j>=1; j--){
        for(int i=1; i<=n; i++){
            if(j!=m && room[i][j].eastWall){ // 拆右面的
                room[i][j].eastWall = false;
                room[i][j+1].westWall = false;
                int t = theSizeOfRoom();
                if(t >= lagestRoom){
                    lagestRoom = t;
                    posX = i; posY = j;
                    isN = false;
                }
                room[i][j].eastWall = true;
                room[i][j+1].westWall = true;
            }
            if(i!=1 && room[i][j].northWall){ // 拆上面的
                room[i][j].northWall = false;
                room[i-1][j].southWall = false;
                int t = theSizeOfRoom();
                if(t >= lagestRoom){
                    lagestRoom = t;
                    posX = i; posY = j;
                    isN = true;
                }
                room[i][j].northWall = true;
                room[i-1][j].southWall = true;
            }
        }
    }
    cout << lagestRoom <<endl;
    cout << posX <<" "<< posY <<" "<< (isN?"N":"E") <<endl;
    fprintf(pFile2, "%d\n", lagestRoom);
    fprintf(pFile2, "%d %d %s\n", posX, posY, (isN?"N":"E"));
    fclose(pFile1); fclose(pFile2);
	return 0;
}
【USACO】The Castle
DreamChaserYx的专栏
04-22 384
flood fill 方法，将整个地图按照房间进行着色，0意思是还未访问的房间。在着色同时计算最大的房间，而颜色种类就是房间的数量。最后枚举墙，如果推到墙后，对应的两个格子分属不同的房间，则将房间的size相加，并更新推倒墙后得到的最大的房间的size。/* ID : LANG: C++11 TASK: castle */ #include &lt;iostream&gt; #include ...
1020. 【USACO题库】2.1.1 The Castle城堡
最新发布
wrnxrxsb的博客
05-04 1786
题目描述以一个几乎超乎想像的运气，农民约翰在他的生日收到了一张爱尔兰博彩的奖券。这一张奖券成为了唯一中奖的奖券。农民约翰嬴得爱尔兰的乡下地方的一个传说中的城堡。吹牛在他们威斯康辛州不算什么，农民约翰想告诉他的牛所有有关城堡的事。他想知道城堡有多少房间，而且最大的房间有多大。事实上，他想去掉一面墙来制造一个更大的房间。你的任务是帮助农民约翰去了解正确房间数目和大小。城堡的平面图被分为 M(wide)*N(1 <=M,N<=50)个小正方形。
USACO Chapter2 The Castle
weixin_30872867的博客
01-10 162
The Castle IOI'94 - Day 1 In a stroke of luck almost beyond imagination, Farmer John was sent a ticket to the Irish Sweepstakes (really a lottery) for his birthday. This ticket turned out to have on...
usaco The Castle
DickensTone的博客
11-01 214
题意：给你一个矩形房间，判断有多少个房间，以及最大的房间，以及去掉一堵墙后最大的房间面积，以及是那一堵墙。 条件：输入的时候，输入的是房间的状态t，t由1或2或4或8组成。代表西，北，东，南有墙。看下二进制1 是00001， 2是00010， 4是00100， 8是01000。那么位运算很容易算出由哪些墙组成。 输出墙的时候，面积的优先级>靠西>靠南且方向只能有N和E组成，代表当要去除南边的墙
USACO 2.1.1The Castle
supersnow0622的专栏
07-31 1812
The Castle IOI'94 - Day 1 In a stroke of luck almost beyond imagination, Farmer John wassent a ticket to the Irish Sweepstakes (really a lottery) for hisbirthday. This ticket turned out to have only
【USACO题库】2.1.1 The Castle城堡 题解
Hello,I'm Proking.
03-21 3137
题目描述： 我们憨厚的USACO主人公农夫约翰(Farmer John)以无法想象的运气,在他生日那天收到了一份特别的礼物：一张“幸运爱尔兰”（一种彩票）。结果这张彩票让他获得了这次比赛唯一的奖品——坐落于爱尔兰郊外的一座梦幻般的城堡！ 喜欢吹嘘的农夫约翰立刻回到有着吹嘘传统的威斯康辛老家开始吹嘘了, 农夫约翰想要告诉他的奶牛们关于他城堡的一切。他需要做一些吹嘘前的准备工作：比如说知道城堡
P1457 [USACO2.1]城堡 The Castle题解
Noirr_的博客
09-07 368
这道题似乎还没有最短路的题解，这里给出一种dijkstradijkstradijkstra的做法（其实是最近学图论学疯了，什么都想用图论来做） 题目大意： 给出一个图，查询这个图的： 连通块的个数、 最大连通块的大小、 合并相邻连通块后最大的连通块（以及这个可以调死你的拆墙的方向） 分析： 首先看到数据范围: 1≤n,m≤501≤n,m≤501≤n,m≤50 我们给每个点一个编号，让其与相邻4个点连边；（注意这里是连单向边，因为题目给出的每个点都描述了自己周围墙的状态，所以只用连自己的那条就行了） 建图代码
USACO.zip_usaco
09-19
4. **2.1.1 The Castle**：题目可能涉及到二维空间的路径规划，要求选手编写程序找出从城堡的一点到达另一点的最短路径，这可能需要用到广度优先搜索(BFS)或Dijkstra算法。 5. **3.1.1 Agri-Net**：可能涉及到网络...
洛谷P1457 城堡 The Castle /1104 USACO 2.1 城堡 (foodfill)
weixin_45523071的博客
12-07 474
题目链接： 洛谷 学校OJ 读题 当初看到这道题时，我的内心是奔溃的： 什么魔鬼输入？！ 什么恶心要求？！ 我 *(数据删除) 算了，还是好好做题吧。 输入处理 通过观察，我们可以知道每一个数都可以这样分解 假设某行有一个数111111,我们可以:把它拆成二进制: 11= 1 0 1 1 1/表示南面有墙 0/表示东面没有墙 1/表示北面有墙 1/表示西面有墙 所以我们可以设一个布尔类型三维数组a...
USACO The Castle
01-16 211
1、这是一道94年的IOI题目，比较麻烦，主要用floodfill算法。。。 2、注意一定要标记房间的编号，否则可能“打通”墙壁后又来到原来的房间。 3、注意遍历后不能把vis恢复成false，否则会出问题。 /* ID:mrxy564 PROG:castle LANG:C++ */ #include using namespace std; struct node{   
【图论】【USACO】The Castle
liveas的专栏
06-10 2076
<br />In a stroke of luck almost beyond imagination, Farmer John was sent a ticket to the Irish Sweepstakes (really a lottery) for his birthday. This ticket turned out to have only the winning number for the lottery! Farmer John won a fabulous castle in th
USACO 2.1 The Castle (castle)
Hello World！
02-22 1990
//Main Idea //We use DFS to find the number of room and module_info[MAX][MAX] //to record the visited info and then the room the module belong to; /* ID: haolink1 PROG: castle LANG: C++ */ //#inclu
USACO 2.1.1 城堡 The Castle
蟋蟀的博客
07-23 671
题解 比较有意思的一道题目。大体概念是图搜索和洪水填充。 前两个问题用dfs就可以解决，后两问遍历对所有房间，检验N和E墙即可。 思路很清楚，但写起来还是要仔细。 代码 /* PROG:castle ID:imking022 LANG:C++ */ #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;fs...
[USACO2.1]城堡 The Castle
AAA_Ljw
12-29 1171
[USACO2.1]The Castle 题目描述 城堡有多少个房间，每个房间有多大。要把一面单独的墙（指两个单位间的墙）拆掉以形成一个更大的房间。 你的工作就是算出房间数与房间的大小。 城堡的平面图被划分成M*N(1 &lt;=M,N&lt;=50）个正方形的单位，一个这样的单位可以有0到4面墙环绕。城堡周围一定有外墙。（就是说平面图的四周一定是墙。） 请仔细研究下面这个有注解的城堡平面图： 友...
floodfill种子染色算法+实例运用
q175291788的专栏
08-25 1595
种子染色，说白点，就是将一个图里面，按照题目要求，将同一类的染成同一种颜色，然后就根据颜色的类型个数分成N种不同类型的点。 实现很简单，深搜，广搜都可以。 由于每个点都只会遍历一次，所以就不需要研究许多优化。（对于难题就另当别论了。） 给个例题（来自USACO）： 我
USACO castle
枯荣
06-20 1249
/* ID:kevin_s1 PROG:castle LANG:C++ */ #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; #define MAXM 51
usaco castle
NiaNiaJR的专栏
05-21 677
/* ID: ljracm1 LANG: C++ PROB: castle */ #include #include #include #include #define T using namespace std; int M,N; int maze[55][55]; int wall[55][55]; int vis[55][55]; int area[255]; int color=1,s
Pascal语言实现USACO Castle问题解析
资源摘要信息:"Castle问题，作为USACO（美国计算机奥林匹克竞赛）题库中的一部分，主要考察参赛者对于数据结构的理解和应用能力。本资源针对Section2.1部分，提供了Pascal语言编写的源代码解决方案。数据结构是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值