目录
刷题总结：
填涂颜色
题目描述
由数字 00 组成的方阵中，有一任意形状闭合圈，闭合圈由数字 11 构成，围圈时只走上下左右 44 个方向。现要求把闭合圈内的所有空间都填写成 22。例如：6×66×6 的方阵（n=6n=6），涂色前和涂色后的方阵如下：
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1
输入格式
每组测试数据第一行一个整数 n(1≤n≤30)n(1≤n≤30)。
接下来 nn 行，由 00 和 11 组成的 n×nn×n 的方阵。
方阵内只有一个闭合圈，圈内至少有一个 00。
输出格式
已经填好数字 22 的完整方阵。
输入输出样例
输入 #1
6 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1 1 1 1
输出 #1
0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 2 2 1 1 1 2 2 2 1 1 2 2 2 2 1 1 1 1 1 1 1
说明/提示
对于 100%100% 的数据，1≤n≤301≤n≤30。
该题基本思想：深度搜索
读题可知，输入方阵中的0分为2种，圈内和圈外，题目要求将圈内的0改为2并输出，所以我们只要找出圈外的0，并做好标记，在输出的时候就可以借助标记判断输出0还是2了，那么问题来了，怎么去标记圈外的0呢？这时就要用到深度优先搜索了。
具体请看代码：
#include<stdio.h>
int arr[31][31], n;
void dfs(int x, int y) {
if (arr[x][y] == 1 || x > n - 1 || y > n - 1 || x < 0 || y < 0 || arr[x][y] == -1) { //越界或搜索到了1即返回
return;
}
arr[x][y] = -1;//圈外的0改为-1
//搜索该点的前后左右点
dfs(x + 1, y);
dfs(x - 1, y);
dfs(x, y + 1);
dfs(x, y - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int l = 0; l < n; l++) {
scanf("%d", &arr[i][l]);
}
}
/*
6
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 1 1 1 1
1 1 1 0 1 1
*/
//要从边缘找0，为的是防止上述情况的出现
for (int i = 0; i < n; i++) {//找出一个圈外的0，并进入搜索
if (arr[0][i] == 0) {//第1行第i列
dfs(0, i);
}
if (arr[n - 1][i] == 0) {//第n-1行第i列
dfs(n - 1, i);
}
if (arr[i][0] == 0) {第i行，第1列
dfs(i, 0);
}
if (arr[i][n - 1] == 0) {第i行第n-1列
dfs(i, n - 1);
}
}
for (int i = 0; i < n; i++) {
for (int il = 0; il < n; il++) {
if (arr[i][il] == -1) {//圈外的0
printf("0 ");
} else if (arr[i][il] == 1) {//圈
printf("1 ");
} else {//是圈内的0
printf("2 ");
}
}
printf("\n");
}
return 0;
}perket
题目描述
Perket 是一种流行的美食。为了做好 Perket，厨师必须谨慎选择食材，以在保持传统风味的同时尽可能获得最全面的味道。你有 nn 种可支配的配料。对于每一种配料，我们知道它们各自的酸度 ss 和苦度 bb。当我们添加配料时，总的酸度为每一种配料的酸度总乘积；总的苦度为每一种配料的苦度的总和。
众所周知，美食应该做到口感适中，所以我们希望选取配料，以使得酸度和苦度的绝对差最小。
另外，我们必须添加至少一种配料，因为没有任何食物以水为配料的。
输入格式
第一行一个整数 nn，表示可供选用的食材种类数。
接下来 nn 行，每行 22 个整数 sisi 和 bibi，表示第 ii 种食材的酸度和苦度。
输出格式
一行一个整数，表示可能的总酸度和总苦度的最小绝对差。
输入输出样例
输入 #1
1 3 10
输出 #1
7
输入 #2
2 3 8 5 8
输出 #2
1
输入 #3
4 1 7 2 6 3 8 4 9
输出 #3
1
说明/提示
数据规模与约定
对于 100%100% 的数据，有 1≤n≤101≤n≤10，且将所有可用食材全部使用产生的总酸度和总苦度小于 1×1091×109，酸度和苦度不同时为 11 和 00。
同样要用到深度搜索
基本思路：
用深度搜索搜出每种放调料的方案（只要所放调料种类大于等于1即是一种方案），并求出该方案下的差，与当前最小酸苦度的差比较，然后更新最小酸苦度的差，搜完每种方案之后就可以输出正确值了，接下来看代码：
#include<bits/stdc++.h>//万能头文件
int n, a[13], b[13], ui[13] = {0}; //a,b分别存酸度和苦度，ui做标记
long long min = 1200012351010;
//足够大以便于后面min的更新
int x = 1; //酸度是相乘的，不能赋0，要赋1
int y = 0;
void go(int numb) { //numb记录当前所加调料总数,x,y为当前酸苦度
if (numb == n + 1) { //没得放了
return;//开始回溯
}
for (int i = 0; i < n; i++) {//循环遍历每一种调料
if (ui[i] == 0) { //此种调料还没有被选
ui[i] = 1; //标记已选
x *= a[i];
y += b[i];
numb++;
if (abs(x - y) < min) {//进行最小值更新
min = abs(x - y);
}
go(numb);//继续向下搜索
//开始回溯
numb--;//收回调料
ui[i] = 0;
x /= a[i];
y -= b[i];
}
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
}
go(0);
printf("%d", min);
return 0;
}马的遍历
题目描述
有一个 n×mn×m 的棋盘，在某个点 (x,y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。
输入格式
输入只有一行四个整数，分别为 n,m,x,yn,m,x,y。
输出格式
一个 n×mn×m 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 −1−1）。
输入输出样例
输入 #1
3 3 1 1
输出 #1
0 3 2 3 -1 1 2 1 4
说明/提示
数据规模与约定
对于全部的测试点，保证 1≤x≤n≤4001≤x≤n≤400，1≤y≤m≤4001≤y≤m≤400。
基本思路：宽度优先搜索（BFS）（不能用DFS是因为该数据过大，会超时）
#include<bits/stdc++.h>//最近新学到的万能头文件
int n, m, x, y;
int next[8][2] = {{-2, 1}, {-2, -1}, {1, 2}, {-1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}}; //马走日
int arr[401][401] ; //-1表示没走过,1表示走过
int ui[401][401];//用来记录到达这一点的最小步数
//广度的一种模板
struct qu {
int x;
int y;
int on;//当前所走步数
} all[400 * 400 + 40];
void bfs() {
int head = 0, tail = 0; //队头队尾初始化
qu now, Next;
now.x = x, now.y = y, now.on = 0; //结果数组起点设置为0;
all[tail++] = now;
while (head < tail) {
now = all[head++]; //出队
for (int i = 0; i < 8; i++) {
Next = now;
Next.x += next[i][0], Next.y += next[i][1];//下一步要走的坐标
if (Next.x > n || Next.y > m || Next.x < 1 || Next.y < 1 || arr[Next.x][Next.y] == 1 ) {
continue;
}//走过，下一个点
arr[Next.x][Next.y] = 1;
ui[Next.x][Next.y] = (++Next.on);
all[tail++] = Next;
}
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &x, &y);
for (int i = 1; i <= n; i++) {
for (int il = 1; il <= m; il++) {
ui[i][il] = 160000; //初始化，以便于最小步数的比较
arr[i][il] = -2; //初始化，-2表示该点没走到过
}
}
ui[x][y] = 0; //马的起点赋值0
//dfs(0, x, y);
bfs();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ui[i][j] ==160000) printf("-1 ");
else printf("%d ", ui[i][j]);
}
printf("\n");
}
return 0;
}虽然说深度优先搜索会超时，但我还是用深度写了代码（因为我一开始没考虑数据的大小），感兴趣的可以看下：
#include<bits/stdc++.h>//最近新学到的万能头文件
int n, m, x, y;
int next[8][2] = {{-2, 1}, {-2, -1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}}; //马走日
int arr[401][401] = {0}; //-1表示没走过,1表示走过，0表示边界
int ui[401][401];//用来记录到达这一点的最小步数
void dfs(int num, int a, int b) { //num为当前所走步数,a,b为当前坐标
if (a > n || b > m || a < 1 || b < 1 ) {
return;//越界，返回
}
arr[a][b] = 1; //标记已走
for (int i = 0; i < 8; i++) { //遍历8个方向
if (arr[a + next[i][0]][b + next[i][1]] != 1) {//没走过才走
dfs(num + 1, a + next[i][0], b + next[i][1]);
arr[a + next[i][0]][b + next[i][1]]=-1;
}
}
if (ui[a][b] > num) { //最小步数更新
ui[a][b] = num;
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &x, &y);
for (int i = 1; i <= n; i++) {
for (int il = 1; il <= m; il++) {
ui[i][il] = 160000; //初始化，以便于最小步数的比较
arr[i][il] = -2; //初始化，-2表示该点没走到过
}
}
ui[x][y] = 0; //马的起点赋值0
dfs(0, x, y);
for (int i = 1; i <= n; i++) {
for (int iu = 1; iu <= m; iu++) {
if (arr[i][iu] == -2) {
printf("-1 ");
} else {
printf("%d ", ui[i][iu]);
}
}
printf("\n");
}
return 0;
}Lake Counting S
[USACO10OCT]Lake Counting S - 洛谷
题目描述
Due to recent rains, water has pooled in various places in Farmer John's field, which is represented by a rectangle of N x M (1 <= N <= 100; 1 <= M <= 100) squares. Each square contains either water ('W') or dry land ('.'). Farmer John would like to figure out how many ponds have formed in his field. A pond is a connected set of squares with water in them, where a square is considered adjacent to all eight of its neighbors. Given a diagram of Farmer John's field, determine how many ponds he has.
输入格式
Line 1: Two space-separated integers: N and M * Lines 2..N+1: M characters per line representing one row of Farmer John's field. Each character is either 'W' or '.'. The characters do not have spaces between them.
输出格式
Line 1: The number of ponds in Farmer John's field.
题意翻译
由于近期的降雨，雨水汇集在农民约翰的田地不同的地方。我们用一个 N×M(1≤N≤100,1≤M≤100)N×M(1≤N≤100,1≤M≤100) 的网格图表示。每个网格中有水（W） 或是旱地（.）。一个网格与其周围的八个网格相连，而一组相连的网格视为一个水坑。约翰想弄清楚他的田地已经形成了多少水坑。给出约翰田地的示意图，确定当中有多少水坑。
输入第 11 行：两个空格隔开的整数：NN 和 MM。
第 22 行到第 N+1N+1 行：每行 MM 个字符，每个字符是 W 或 .，它们表示网格图中的一排。字符之间没有空格。
输出一行，表示水坑的数量。
输入输出样例
输入 #1
10 12 W........WW. .WWW.....WWW ....WW...WW. .........WW. .........W.. ..W......W.. .W.W.....WW. W.W.W.....W. .W.W......W. ..W.......W.
输出 #1
3
说明/提示
OUTPUT DETAILS: There are three ponds: one in the upper left, one in the lower left, and one along the right side.
额，好像和填涂颜色有那么一点像，填涂颜色是找外面的0，而这个题目是要找连成一片的W
基本思想：同样是深度搜索
详细思路：
用双重for循环遍历找到一个从未搜索过的W进入搜索，将搜索过的W标记,每进入一次搜索则水坑数加1
详细代码：
#include<stdio.h>
int arr[101][101], n, m; //1表示没搜过的W,-1表示搜过的，0表示.
int a[8]={1,-1,-1,1,0,0,-1,1},b[8]={-1,1,-1,1,-1,1,0,0};//方向数组
void dfs(int x, int y) {
if ( x > n - 1 || y > m - 1 || x < 0 || y < 0 || arr[x][y] == -1 || arr[x][y] == 0) { //越界或搜索过即返回
return;
}
arr[x][y] = -1;//搜过的W标记
for(int i=0;i<8;i++){//8种方向
dfs(x+a[i],y+b[i]);
}
}
int main() {
int all = 0;
scanf("%d %d", &n, &m);
getchar();//为什么这要有个换行符呢，因为输入n,m后要换行（我就是卡在这，连续错了两次）
for (int i = 0; i < n; i++) {
for (int l = 0; l < m; l++) {
char tt;
scanf("%c", &tt);
if (tt == 'W') {//1表示W,0表示.
arr[i][l] = 1;
} else {
arr[i][l] = 0;
}
}
getchar();//吸收换行符
}
for (int i = 0; i < n; i++) {
for (int l = 0; l < m; l++) {
if (arr[i][l] == 1) {
dfs(i, l);
all++;
}
}
}
printf("%d", all);
return 0;
}学习小结:
宽度优先搜索（BFS）：
与深度搜索不同，它讲究搜索的广度，又称广度优先算法，核心是先把周围的找完，再去找更深的地方,当数据过大时就用BFS;
959
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
