忘了 if a[x,y+2]=1 then sort(x,y+2);

if a[x,y-2]=1 then sort(x,y-2);

if a[x+2,y]=1 then sort(x+2,y);

if a[x-2,y]=1 then sort(x-2,y);

这4种情况……郁闷 交了4次才发现……

咳咳。。

事实证明

这题

写DFS

用常规方法

是

不能

AC

的

program p1051;

var

a:array[-1..103,-1..103] of 0..1;

v:array[-1..103,-1..103] of boolean;

j,k,n,i,m:longint; ch:char;

procedure deal(i,j:longint);

begin

if not v then

begin

v:=true;

if a=1 then deal(i-2,j);

if a=1 then deal(i-1,j);

if a=1 then deal(i-1,j-1);

if a=1 then deal(i-1,j+1);

if a=1 then deal(i,j-2);

if a=1 then deal(i,j-1);

if a=1 then deal(i,j+1);

if a=1 then deal(i,j+2);

if a=1 then deal(i+1,j-1);

if a=1 then deal(i+1,j);

if a=1 then deal(i+1,j+1);

if a=1 then deal(i+2,j);

end;

end;

begin

readln(n,m);

fillchar(v,sizeof(v),1);

for i:=1 to n do

begin

for j:=1 to m do

begin

read(ch);

if ch='-' then a:=0 else begin a:=1; v:=false; end;

end;

readln

end;

k:=0;

for i:=1 to n do

for j:=1 to m do

if not v then begin

inc(k);

deal(i,j);

end;

write(k);

end.

注意一下边界就行了

我开了一个访问布尔数组，

其实可以把A选后清0

类似于围棋的提子程序————只不过距离大点（曼哈顿距离）。

思路是遍历整个二维数组。设置一个栈，把第一光点记录到栈中，然后遍历该栈，把每一个栈内元素周围的光点再记录到栈中，每个元素把他周围的光点都发展到栈内来，好像传销啊，呵呵。直到分析完所有栈内元素，一个图案就结束了。接着处理下一个栈吧，呵呵！

核心代码：

const int WIDTH = 100;

char lib[WIDTH][WIDTH] = {0}; //预设最大空间

bool templib[WIDTH][WIDTH] = {0};//用来存储当前位置的光点是否被处理过

int n, m;

cin >> n >> m;

for (int i=0; i lib[i][j];

if (lib[i][j] != '#')

templib[i][j] = true;

}

}

int stack[WIDTH*WIDTH][2] = {0};//存储栈内元素的坐标

int top = 0;//栈顶

int pos = 0;//当前被处理栈元素

int sum = 0; //记录图案数量

for (int i=0; i

vijos居然没有限制编译开关，于是一直202的最后一个点……

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

秒杀！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案错误...程序输出比正确答案长

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：90 有效耗时：0ms

怪异的错误，明天再来A！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：运行时错误...| 错误号: 202 | 堆栈溢出错

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：90 有效耗时：0ms

啊啊啊啊啊啊啊啊！！！！！！！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

我90分N次，还是没搞懂，最后一个点老是202！什么评测机！

测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

dfs,,貌似并查集也可以,

#include

using namespace std;

bool visit[105][105];

bool data[105][105];

short dir[15][3];

int n, m;

int ans;

void input()

{

cin >> n >> m;

for (int i = 1; i temp;

if (temp == '#') data[i][j] = true;

else data[i][j] = false;

}

for (int i = 1; i

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

哎，一开始没搞动曼哈顿距离:-(以后要仔细看清楚题目再做!!!

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

简单的搜索

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

状态不错，一次AC

floodfill,BFS

（耐心搜吧，跟做过的某题有点类似，编了1小时AC，另外那个SB说用递归出202来着？我就100）

{阿东VS燕麦 编译 含注释}

var

i,j,k,l,m,n:longint;

a:array[-5..105,-5..105] of longint;{图案}

sel:array[-5..105,-5..105] of boolean;{搜索记录}

ch:char;

procedure sc(x,y:longint);{sel搜索过程，true代表已搜索}

var g,t:longint;

begin

sel[x,y]:=true;

{递归搜索曼哈顿距离方形内的点}

if not sel[x,y-2] then if a[x,y-2]=1 then sc(x,y-2);

if not sel[x,y-1] then if a[x,y-1]=1 then sc(x,y-1);

if not sel[x,y+1] then if a[x,y+1]=1 then sc(x,y+1);

if not sel[x,y+2] then if a[x,y+2]=1 then sc(x,y+2);

if not sel[x-2,y] then if a[x-2,y]=1 then sc(x-2,y);

if not sel[x-1,y] then if a[x-1,y]=1 then sc(x-1,y);

if not sel[x+1,y] then if a[x+1,y]=1 then sc(x+1,y);

if not sel[x+2,y] then if a[x+2,y]=1 then sc(x+2,y);

if not sel[x-1,y-1] then if a[x-1,y-1]=1 then sc(x-1,y-1);

if not sel[x-1,y+1] then if a[x-1,y+1]=1 then sc(x-1,y+1);

if not sel[x+1,y-1] then if a[x+1,y-1]=1 then sc(x+1,y-1);

if not sel[x+1,y+1] then if a[x+1,y+1]=1 then sc(x+1,y+1);

end;

begin

readln(n,m);

for i:=1 to n do

begin

for j:=1 to m do

begin

read(ch);

if ch='#' then a:=1;

end;

readln;

end;{读入，1代表#，0代表-}

for i:=1 to n do

for j:=1 to m do

if (a=1) and (not sel) then

begin

inc(k);

sc(i,j);

end;{如果没有搜索过那么递归开始}

writeln(k);{输出}

end.

floodfill+bfs=一遍ac

FloodfillDFS和BFS练手!

DFS:

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：运行时错误...| 错误号: 202 | 堆栈溢出错

BFS:

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

水题~~~~~~~~

死搜就行了

枚举+并查集

做水题调节心情

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

简单的“卫星搜索”！！！！！！

so eeeeeeeeeeeeeeeeeeeeeeeeeasy!!!!!!!!!

简直是水题！！！！！！

#include

#include

using namespace std;

int p;

int t=0;

char a[201][201]={'-'};

int wxss(int i,int j)

{if(a[i][j]=='#')

{a[i][j]='-';p=0;

if(a[j]=='#')

{wxss(i+1,j);}

if(a[i][j+1]=='#')

{wxss(i,j+1);}

if(a[j]=='#')

{wxss(i-1,j);}

if(a[i][j-1]=='#')

{wxss(i,j-1);}

if(a[j]=='#')

{wxss(i+2,j);}

if(a[i][j+2]=='#')

{wxss(i,j+2);}

if(a[j]=='#')

{wxss(i-2,j);}

if(a[i][j-2]=='#')

{wxss(i,j-2);}

if(a[j+1]=='#')

{wxss(i+1,j+1);}

if(a[j-1]=='#')

{wxss(i+1,j-1);}

if(a[j+1]=='#')

{wxss(i-1,j+1);}

if(a[j-1]=='#')

{wxss(i-1,j-1);}

else

{return 0;}

}

}

main()

{int n,m,i,j,k;

cin>>n>>m;

for(i=1;ia[i][j];}

}

for(i=1;i