2022.1.10（搜索的题）

题目描述

任何一个大于1的自然数n，总可以拆分成若干个小于n的自然数之和。现在给你一个自然数n，要求你求出n的拆分成一些数字的和。每个拆分后的序列中的数字从小到大排序。然后你需要输出这些序列，其中字典序小的序列需要优先输出。

输入格式

输入：待拆分的自然数n。

输出格式

输出：若干数的加法式子。

输入输出样例

输入 #1复制

7

输出 #1复制

1+1+1+1+1+1+1
1+1+1+1+1+2
1+1+1+1+3
1+1+1+2+2
1+1+1+4
1+1+2+3
1+1+5
1+2+2+2
1+2+4
1+3+3
1+6
2+2+3
2+5
3+4

说明/提示

用回溯做。。。。

n\le 8n≤8

代码：

#include<stdio.h>
int n,l,a[10];//n<=8
void dfs(int sum,int data)//sum表示当前总和，data表示本次调用函数sum需从data加起
{
    int i;
    if(sum == n)
    {
       for(i=0;i<l-1;i++)
        printf("%d+",a[i]);
       printf("%d\n",a[i]);//最后一个数后面没有加号
       return;//已经得到一组答案，回溯到上一步
    }
    if(sum > n)
        return;//超过了，不合适，回到上一步
    if(sum < n)
    {
        for(i=data; i<n; i++)//加的数从1开始遍历
        {
            a[l++]=i;
            dfs(sum+i,i);
            a[--l]=0;//回溯
        }
    }
    return;
}
int main()
{
    scanf("%d",&n);
    dfs(0,1);//sum起初是0，从加1开始
    return 0;
}

题目描述

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.

由于近期的降雨，雨水汇集在农民约翰的田地不同的地方。我们用一个NxM(1<=N<=100;1<=M<=100)网格图表示。每个网格中有水('W') 或是旱地('.')。一个网格与其周围的八个网格相连，而一组相连的网格视为一个水坑。约翰想弄清楚他的田地已经形成了多少水坑。给出约翰田地的示意图，确定当中有多少水坑。

输入格式

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.

第1行：两个空格隔开的整数：N 和 M 第2行到第N+1行：每行M个字符，每个字符是'W'或'.'，它们表示网格图中的一排。字符之间没有空格。

输出格式

Line 1: The number of ponds in Farmer John's field.

一行：水坑的数量

输入输出样例

输入 #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.

代码：

#include<stdio.h>
char a[101][101];//用于保存地图
int ans,n,m;
void dfs(int x,int y)
{
    //上下左右斜上方斜下方都要考虑！
    int next[9][2]={{0,0},{1,1},{-1,-1},{-1,1},{1,-1},{0,1},{1,0},{-1,0},{0,-1}};
    a[x][y]='.';//走过的地方标记为‘.’
    int dx,dy;
    for(int i=0; i<=8; i++)//搜索周围
    {
            dx=x+next[i][0];
            dy=y+next[i][1];
            if(dx>=0&&dx<=n&&dy>=0&&dy<m&&a[dx][dy]=='W')
            {
                dfs(dx,dy);
            }
    }
    return;
}
int main()
{
    //输入地图
    scanf("%d%d",&n,&m);
    for(int i=0; i<=n; i++)
    {
        scanf("%s",a[i]);//一次输入一行
    }

    for(int i=0; i<=n; i++)
    {
        for(int j=0; j<m; j++)
        {
            if(a[i][j]=='W') //遇到W开始遍历
            {
                dfs(i,j);
                ans++;
            }
        }
    }
    printf("%d",ans);
    return 0;
}

麻了，做题做麻了，还有几道没做出来但不知道原因，没什么想说的，注释也都在做的过程写代码里了 。还是看看书吧，看电脑真的看麻了。

题目描述

由数字00组成的方阵中，有一任意形状闭合圈，闭合圈由数字11构成，围圈时只走上下左右44个方向。现要求把闭合圈内的所有空间都填写成22.例如：6 \times 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 \le n \le 30)n(1≤n≤30)

接下来nn行，由00和11组成的n \times nn×n的方阵。

方阵内只有一个闭合圈，圈内至少有一个00。

//感谢黄小U饮品指出本题数据和数据格式不一样. 已修改(输入格式)

输出格式

已经填好数字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

说明/提示

1 \le n \le 301≤n≤30

我的代码（but运行错误了）（目前我也不知道为什么）

#include<stdio.h>
int n,a[35][35];
void dfs(int x,int y)
{
    int next[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
    int tx,ty;
    a[x][y]=-1;//把圈外的点都标记为-1
    for(int i=0; i<4; i++)//每个方向依次遍历
    {
        tx=x+next[i][0];
        ty=y+next[i][1];
        if(a[tx][ty]==0&&tx<n&&tx>=0&&tx<n&&ty>=0)//如果不在地图外且在墙内
            //关键点：a[tx][ty]==0（不能写成a[tx][ty]!=1,因为外面的点走过后会标记为-1也不为1.
        {
            //把走过的数组位置作标记。
            dfs(tx,ty);
            //a[tx][ty]=0;这里不需要回溯！！因为会先判断能不能走，不能走就不会操作
        }
    }
    return;
}
void outplace()
{
    //四个角落依次遍历
    for(int i=0; i<n; i++)
    {
        if(a[0][i]==0)//原点（0，0）往右方向
        {
            dfs(0,i);
        }
        if(a[i][0]==0)//原点（0，0）往下方向
        {
            dfs(i,0);
        }
        if(a[n-1][i]==0)//左下角（n-1，0）往右方向
        {
            dfs(n-1,i);
        }
        if(a[i][n-1]==0)//右上角（0，n-1）往下方向
        {
            dfs(i,n-1);
        }
    }
}//四角的点都走完剩下的就是被里面的

int main()
{

    scanf("%d",&n);
    //输入地图
    for(int j=0; j<n; j++)
    {
        for(int k=0; k<n; k++)
        {
            scanf("%d",&a[j][k]);
        }
    }

    outplace();//搜索标记圈外点

    //输出变化后地图
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(a[i][j]==0)//由题意1里面的点染成2
            {
                a[i][j]=2;
            }              ///注意这两个if顺序不能反，否则-1处变成0后在下一步会变成2.
            if(a[i][j]==-1)//1外面的点恢复成1
            {
                a[i][j]=0;
            }
            //不是0也不是-1的就是墙，就输出它的值'1'即可
            printf("%d ",a[i][j]);
        }
        printf("\n");//输出时输完一行要换行
    }
    return 0;
}

然后下面这道题也是，运行的都对了，但是不知道为什么所有样例都答案错误，麻了+1

-----------二次更新--------------

在小伙伴的帮助下，加了一行代码，

对了%86，但是为什么！！！还有一个样例过不了哇呜呜呜呜呜呜，心硬如铁了，要命。

 

 呜呜，暴捶自己。

--------------------------------------梅开三度更新这道题------------------------------

我终于找到问题了，哎，居然是这么小的一个细节弄错了，无奈啊。得想办法加强自己的观察力。

上面的截图加的这一行代码没错，加上这一行就能ac了，只不过我改的时候漏写了一个t，是判断扩展点tx，ty是否越界嘛我写成了x，y当前点，所以第四个样例没过，不过还是终于解决了！

------------------------------------------------------------------------------------------------

题目描述

有一个 n \times mn×m 的棋盘，在某个点 (x, y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 n, m, x, yn,m,x,y。

输出格式

一个 n \times mn×m 的矩阵，代表马到达某个点最少要走几步（左对齐，宽 55 格，不能到达则输出 -1−1）。

输入输出样例

输入 #1复制

3 3 1 1

输出 #1复制

0    3    2    
3    -1   1    
2    1    4    

说明/提示

数据规模与约定

对于全部的测试点，保证 1 \leq x \leq n \leq 4001≤x≤n≤400，1 \leq y \leq m \leq 4001≤y≤m≤400。

我的代码（我觉得没毛病啊mmmm）

#include<stdio.h>
#include<string.h>
int n,m;
int mp[410][410];//棋盘
int book[410][410];//标记是否走过
//学到了新招就是自定义check函数检查有没有越界
//而且以越界条件先判断好像可以节省时间
//(因为只要一个条件不满足就是越界了)
//就不需要一个一个判断不越界的条件是否满足
int check(int x,int y)
{
	if(x<1||x>n||y<1||y>m)
		return 0;
	return 1;//返回1或0是方便后面if条件判断
}
/*最开始下意识以为只有四个方向，定义的
数组是next[4][2],后来改的时候不记得改成
8，答案奇怪的离谱，找了半天(真的找了
久呜呜)居然是这里的问题，麻了麻了.....
*/
int next[8][2]= {{2,1}, //下右日
                {2,-1},//下左日
                {-2,1},//上右日
                {-2,-1},//上左日
                {1,2},//右下日
                {-1,2},//右上日
                {1,-2},//左下日
                {-1,-2}};//左上日
struct queue//因为是bfs，要用到队列结构体
{
    int x;
    int y;
} que[40100];
void bfs(int x,int y)//注意是广度优先搜索哦
{
    int head=0,tail=1;
    int sum=0;//步数清零
    //初始点入队
    que[1].x=x;
    que[1].y=y;
    //标记初始点
    book[x][y]=1;
    mp[x][y]=0;
    while(head<tail)
    {
        head++;
        sum=mp[que[head].x][que[head].y]+1;//深度加一

        for(int i=0; i<8; i++)
        {
            int ax=que[head].x+next[i][0];
            int ay=que[head].y+next[i][1];
            if(check(ax,ay)&&book[ax][ay] == 0)//如果未到达过
            {
                tail++;
                que[tail].x=ax;
                que[tail].y=ay;
                book[ax][ay]=1;
                mp[que[tail].x][que[tail].y]=sum;
            }
        }
    }
}
int main()
{
    int x,y;
    scanf("%d %d %d %d",&n,&m,&x,&y);
    memset(mp,-1,sizeof(mp));//全部初始化为-1
    bfs(x,y);
    //输出结果罢了
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            printf("%-5d ",mp[i][j]);
        }
        if(i!=n)
        printf("\n");
    }
    return 0;
}

 溜了，快瞎了。