文章目录
前言
提示：以下是本篇文章正文内容，下面案例可供参考
一、P1683 入门
题目描述
不是任何人都可以进入桃花岛的，黄药师最讨厌象郭靖一样呆头呆脑的人。所以，他在桃花岛的唯一入口处修了一条小路，这条小路全部用正方形瓷砖铺设而成。有的瓷砖可以踩，我们认为是安全的，而有的瓷砖一踩上去就会有喷出要命的毒气，那你就死翘翘了，我们认为是不安全的。你只能从一块安全的瓷砖上走到与他相邻的四块瓷砖中的任何一个上，但它也必须是安全的才行。
由于你是黄蓉的朋友，她事先告诉你哪些砖是安全的、哪些砖是不安全的，并且她会指引你飞到第一块砖上（第一块砖可能在任意安全位置），现在她告诉你进入桃花岛的秘密就是：如果你能走过最多的瓷砖并且没有死，那么桃花岛的大门就会自动打开了，你就可以从当前位置直接飞进大门了。
注意：瓷砖可以重复走过，但不能重复计数。
输入格式
第一行两个正整数 WW 和 HH，分别表示小路的宽度和长度。
以下 HH 行为一个 H\times WH×W 的字符矩阵。每一个字符代表一块瓷砖。其中，. 代表安全的砖，# 代表不安全的砖，@ 代表第一块砖。
输出格式
输出一行，只包括一个数，即你从第一块砖开始所能安全走过的最多的砖块个数（包括第一块砖）。
输入输出样例
输入 输出
11 9 59
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
1.深搜模板一
#include <bits/stdc++.h>
using namespace std;
char a[25][25];
int vis[25][25];
int w,h,sx,sy,ans;
int d[4][2]={
{
1,0},{
0,1},{
-1,0},{
0,-1}};
void dfs(int x,int y){
for(int i=0;i<4;i++){
int ux=x+d[i][0],uy=y+d[i][1];
if(ux<=h&&uy<=w&&ux>=1&&uy>=1&&a[ux][uy]=='.'&&!vis[ux][uy]){
ans++;
vis[ux][uy]=1;
dfs(ux,uy);
}
}
}
int main()
{
cin>>w>>h;
for(int i=1;i<=h;i++)
for(int j=1;j<=w;j++){
cin>>a[i][j];
if(a[i][j]=='@') sx=i,sy=j;
}
ans++;
vis[sx][sy]=1;
dfs(sx,sy);
cout<<ans;
return 0;
}
2.深搜模板二
#include <bits/stdc++.h>
using namespace std;
char a[25][25];
bool vis[25][25];
int h,w,sx,sy,ans;
int d[4][2]={
{
0,1},{
0,-1},{
1,0},{
-1,0}};
inline void dfs(int x,int y){
if(x<1||y<1||x>w||y>h||vis[x][y]!=0||a[x][y]=='#') return ;
vis[x][y]=1;
ans++;
dfs(x-1,y);
dfs(x,y-1);
dfs(x+1,y);
dfs(x,y+1);
}
int main()
{
cin>>h>>w;
for(int i=1;i<=w;i++)
for(int j=1;j<=h;j++){
cin>>a[i][j];
if(a[i][j]=='@'){
sx=i;
sy=j;
}
}
dfs(sx,sy);
cout<<ans;
return 0;
}
二、P2404 自然数的拆分问题
题目描述
任何一个大于1的自然数n，总可以拆分成若干个小于n的自然数之和。现在给你一个自然数n，要求你求出n的拆分成一些数字的和。每个拆分后的序列中的数字从小到大排序。然后你需要输出这些序列，其中字典序小的序列需要优先输出。
输入格式
输入：待拆分的自然数n。
输出格式
输出：若干数的加法式子。
输入输出样例
输入 输出
7 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
...........
#include <iostream>
using namespace std;
int n,a[25];
void dfs(int he,int cnt,int sx){
if(he==n){
for(int i=1;i<=cnt-2;i++)
cout<<a[i]<<"+";
cout<<a[cnt-1]<<endl;
return;
}
if(he>n) return;
for(int i=sx;i<=n-1;i++){
a[cnt]=i;
dfs(he+i,cnt+1,i);
a[cnt]=0;
}
}
int main()
{
cin>>n;
dfs(0,1,1);
return 0;
}
三、P1332 血色先锋队（多起点广搜）
题目背景
巫妖王的天灾军团终于卷土重来，血色十字军组织了一支先锋军前往诺森德大陆对抗天灾军团，以及一切沾有亡灵气息的生物。孤立于联盟和部落的血色先锋军很快就遭到了天灾军团的重重包围，现在他们将主力只好聚集了起来，以抵抗天灾军团的围剿。可怕的是，他们之中有人感染上了亡灵瘟疫，如果不设法阻止瘟疫的扩散，很快就会遭到灭顶之灾。大领主阿比迪斯已经开始调查瘟疫的源头。原来是血色先锋军的内部出现了叛徒，这个叛徒已经投靠了天灾军团，想要将整个血色先锋军全部转化为天灾军团！无需惊讶，你就是那个叛徒。在你的行踪败露之前，要尽快完成巫妖王交给你的任务。
题目描述
军团是一个 nn 行 mm 列的矩阵，每个单元是一个血色先锋军的成员。感染瘟疫的人，每过一个小时，就会向四周扩散瘟疫，直到所有人全部感染上瘟疫。你已经掌握了感染源的位置，任务是算出血色先锋军的领主们感染瘟疫的时间，并且将它报告给巫妖王，以便对血色先锋军进行一轮有针对性的围剿。
输入格式
第 11 行：四个整数 nn，mm，aa，bb，表示军团矩阵有 nn 行 mm 列。有 aa 个感染源，bb 为血色敢死队中领主的数量。
接下来 aa 行：每行有两个整数 xx，yy，表示感染源在第 xx 行第 yy 列。
接下来 bb 行：每行有两个整数 xx，yy，表示领主的位置在第 xx 行第 yy 列。
输出格式
第 11 至 bb 行：每行一个整数，表示这个领主感染瘟疫的时间，输出顺序与输入顺序一致。如果某个人的位置在感染源，那么他感染瘟疫的时间为 00。
输入 输出
5 4 2 3 3
1 1 1
5 4 3
3 3
5 3
2 4
...........
#include <bits/stdc++.h>
using namespace std;
int n,m,a,b;
struct sq{
int x,y,step;
};
queue<sq> q;
int mp[520][520];
bool vis[520][520];
int d[4][2]={
{
1,0},{
0,1},{
-1,0},{
0,-1}};
void ru(int x,int y){
sq tmp={
x,y,0};
q.push(tmp);
vis[x][y]=1;
return;
}
void bfs(){
while(!q.empty()){
sq u;
for(int i=0;i<4;i++){
u=q.front();
int ux=u.x,uy=u.y;
int dx=ux+d[i][0],dy=uy+d[i][1];
if(dx<1||dy<1||dx>n||dy>m||vis[dx][dy]) continue;
vis[dx][dy]=1;
sq tmp={
dx,dy,u.step+1};
q.push(tmp);
}
mp[u.x][u.y]=u.step;
q.pop();
}
}
int main()
{
memset(vis,false,sizeof(vis));
cin>>n>>m>>a>>b;
int x,y;
for(int i=1;i<=a;i++){
cin>>x>>y;
ru(x,y);
}
bfs();
for(int i=1;i<=b;i++){
cin>>x>>y;
cout<<mp[x][y]<<endl;
}
return 0;
}
四、记忆化dfs
P1434 [SHOI2002]滑雪
题目描述
Michael 喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度会减小。在上面的例子中，一条可行的滑坡为 2424－1717－1616－11（从 2424 开始，在 11 结束）。当然 2525－2424－2323－\ldots…－33－22－11 更长。事实上，这是最长的一条。
输入格式
输入的第一行为表示区域的二维数组的行数 RR 和列数 CC。下面是 RR 行，每行有 CC 个数，代表高度(两个数字之间用 11 个空格间隔)。
输出格式
输出区域中最长滑坡的长度。
输入输出样例
输入 输出
1 2 3 4 5 25
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
#include <bits/stdc++.h>
using namespace std;
int n,m,minn=INT_MAX;
int step;
int a[105][105];
int sx[105][105];
int d[4][2]={
{
0,1},{
1,0},{
-1,0},{
0,-1}};
int dfs(int x,int y){
if(sx[x][y]) return sx[x][y];
sx[x][y]=1;
for(int i=0;i<4;i++){
int dx=x+d[i][0],dy=y+d[i][1];
if(dx>=1&&dy>=1&&dx<=n&&dy<=m&&a[dx][dy]<a[x][y]){
dfs(dx,dy);
sx[x][y]=max(sx[dx][dy]+1,sx[x][y]);
}
}
return sx[x][y];
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
cin>>a[i][j];
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
step=max(dfs(i,j),step);
cout<<step;
return 0;
}
五、单词方阵（先确定方向，再搜索）
题目描述
给一n \times nn×n的字母方阵，内可能蕴含多个“yizhong”单词。单词在方阵中是沿着同一方向连续摆放的。摆放可沿着 88 个方向的任一方向，同一单词摆放时不再改变方向，单词与单词之间可以交叉,因此有可能共用字母。输出时，将不是单词的字母用*代替，以突出显示单词。例如：
输入： 输出：
8
qyizhong *yizhong
gydthkjy gy******
nwidghji n*i*****
orbzsfgz o**z****
hhgrhwth h***h***
zzzzzozo z****o**
iwdfrgng i*****n*
yyyygggg y******g
输入格式
第一行输入一个数nn。(7 \le n \le 1007≤n≤100)。
第二行开始输入n \times nn×n的字母矩阵。
输出格式
突出显示单词的n \times nn×n矩阵。
输入输出样例
#include <bits/stdc++.h>
#define maxn 110
using namespace std;
struct node{
int x,y;
}c[maxn];
char sz[maxn][maxn],stand[]="yizhong";
int vis[maxn][maxn];
int walk[8][2]={
{
0,1},{
0,-1},{
1,0},{
-1,0},{
-1,-1},{
-1,1},{
1,-1},{
1,1}};
int n;
void dfs(int x,int y,node c[],int k,int cur){
if(cur==7){
for(int i=0;i<7;i++)
vis[c[i].x][c[i].y]=1;
}else{
int dx=x+walk[k][0],dy=y+walk[k][1];
if(cur==6||sz[dx][dy]==stand[cur+1]){
c[cur].x=x;
c[cur].y=y;
dfs(dx,dy,c,k,cur+1);
}
}
}
int main()
{
cin>>n;
memset(vis,0,sizeof(vis));
for(int i=0;i<n;i++)
scanf("%s",sz[i]);
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(sz[i][j]=='y'){
for(int k=0;k<8;k++){
int x=i+walk[k][0],y=j+walk[k][1];
if(sz[x][y]=='i'){
dfs(i,j,c,k,0);
}
}
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(vis[i][j]==1)
cout<<sz[i][j];
else cout<<"*";
}
cout<<endl;
}
return 0;
}