HDU - 标签 - 菠菜眾長https://lruihao.cn/tags/hdu/HDU - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Fri, 12 Apr 2019 16:43:19 +0000HDU 1009 FatMouse' Trade（贪心）https://lruihao.cn/posts/hdu1009/Fri, 12 Apr 2019 16:43:19 +0000Lruihaohttps://lruihao.cn/posts/hdu1009/题目大意：

题目链接
老鼠有 M 磅猫食 , 有 N 个房间 , 每个房间前有一只猫 , 房间里有老鼠最喜欢的食品 J[i] , 若要得到房间的食物 , 必须付出相应的猫食 F[i] , 当然这只老鼠没必要每次都付出所有的 F[i]，若它付出 F[i] 的 a%， 则得到 J[i] 的 a%，求老鼠能吃到的最多的食物。

Sample Input

5 3
7 2
4 3
5 2
20 3
25 18
24 15
15 10
-1 -1

Sample Output

13.333
31.500

分析

老鼠要用最少的猫粮来换取最多的食物 , 也就是 J[i]/F[i] 越大越好 , 所以按照 J[i]/F[i] 进行降序排列 , 然后依次用猫粮来换取食物 , 当所剩下的猫粮不足以完全换取食物 , 能换多少是多少。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include<stdio.h>
#include<algorithm>
using namespace std;

struct node{
	double j;
	double f;
	double s;
}a[1005];

int cmp(node x,node y){
	return x.s>y.s;
}

int main(){
	int m,n,i;
	while(scanf("%d%d",&m,&n)&&(m!=-1&&n!=-1)){
		memset(a,0,sizeof(a));
		for(i=0;i<n;i++){
			scanf("%lf%lf",&a[i].j,&a[i].f);
			a[i].s=a[i].j/a[i].f;
		}

		sort(a,a+n,cmp);

		double sum=0;
		for(i=0;i<n;i++){
			if(m>=a[i].f){
				sum+=a[i].j;
				m-=a[i].f;
			}else{
				sum+=a[i].s*m;
				m=0;
			}
			if(m<=0)
				break;
		}
		printf("%.3lf\n",sum);
	}
	return 0;
}
]]>小希的迷宫-HDU-1272（并查集 or 树性质）https://lruihao.cn/posts/hdu1272/Wed, 01 Aug 2018 21:45:50 +0000Lruihaohttps://lruihao.cn/posts/hdu1272/题目链接：小希的迷宫

并查集：

  • 无回路
  • 单连通

并查集做，首先想到的是判断两个点是否连通，不连通就合并，已连通的话说明会形成回路，则可以判定 No，交了一发错了。
想了一下没有考虑到多个连通域的情况，该题必须只有一个连通域

树的性质：

既然单连通无回路，则这肯定是一棵树；那么 edge=v-1;

最后注意空树的情况，至于自环我这里 No 也过了，没有去验证自环 Yes 的情况了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

//并查集
#include<bits/stdc++.h>
using namespace std;

int pre[100001];

int find(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

void join(int a,int b){
    int x=find(a),y=find(b);
    if(x!=y)
        pre[y]=x;
}

int main(){
    int a,b,flag,i,sum;
	while(1)
	{
		flag = 0;
		while(~scanf("%d%d",&a,&b) && a!=0 && b!=0){
			if(a==-1 && b==-1) return 0;
            if(pre[a]==0)pre[a]=a;
			if(pre[b]==0)pre[b]=b;
			if(find(a)==find(b))flag = 1;
			else if(flag!=1)
			join(a,b);
		}
        for(sum = 0,i=1;i<100001;i++){
            if(pre[i]==i)sum++;
            pre[i] = 0;
        }
        if(sum>1 || flag == 1)
			printf("No\n");
        else
			printf("Yes\n");
	}
}
//1 2 3 4 0 0 No 没有连通
//0 0 Yes
//1 1 0 0 No（该代码）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//树性质
#include <stdio.h>
bool s[100001];
int main()
{	int a,b,i,len,num,v;
	for(i=0;i<100001;++i)	s[i]=false;
	len=0,num=0,v=0;
	while(1)
	{	scanf("%d%d",&a,&b);
		if(a==-1&&b==-1)	break;
		if(a==0&&b==0)
		{	if(v==0)
			{	printf("Yes\n");
				continue;
			}
			if(num==len-1)	//划重点！！
				printf("Yes\n");
			else printf("No\n");

			num=len=v=0;
			for(i=0;i<100001;++i)
				s[i]=false;
			continue;
		}
		v=1;
		if(s[a]==false)		len++;//点数
		if(s[b]==false)		len++;
		s[a]=s[b]=true;
		num++;//边数
	}
	return 0;
]]>How Many Answers Are Wrong-hdu3038（带权并查集）https://lruihao.cn/posts/hdu3038/Wed, 01 Aug 2018 11:45:53 +0000Lruihaohttps://lruihao.cn/posts/hdu3038/题目链接：How Many Answers Are Wrong
思路参考：本题直接参考,图文解释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
int pre[200010],ranks[200010];

int find(int root){
    if(pre[root] != root)
    {
        int f = pre[root];
        pre[root] = find(pre[root]);//递归路径压缩
        ranks[root] += ranks[f];
        /*精髓假如一开始没关系，那么用 rank 数组来表示 a，b 各自到各自祖先的距离。
        那么在把 a 的祖先给 b 的祖先当父亲之后，那么 b 到祖先的距离也就是 rank[b] 就要再加上 b 原本的祖先到 a 的祖先的距离，更新一下，
        其中 find 函数（找根节点的函数）里 rank[x]+=rank[pre[x]]（这里 pre 数组存的是对应数的父节点）*/
    }
    return pre[root];
}

int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        int ans=0;
        for(int i=1; i<=n; i++)
            pre[i]=i;
        memset(ranks,0,sizeof(ranks));
        while(m--){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            a--;//[a,b]~~(a--,b]
            int fa=find(a);
            int fb=find(b);
            if(fa!=fb){
                pre[fb]=fa;//注意合并顺序，反过来下面的也要改
                ranks[fb]=ranks[a]-ranks[b]+c;//更新距离
            }
            else {
                if(ranks[b]-ranks[a]!=c)
                    ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
]]>how many tables-HDU-1213（并查集求连通域数目）https://lruihao.cn/posts/how-tables/Tue, 31 Jul 2018 11:12:10 +0000Lruihaohttps://lruihao.cn/posts/how-tables/并查集求连通域数目，初始化 sum=n； 题目链接： how many tables

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include<bits/stdc++.h>
using namespace std;

int pre[1005];

int find(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

int main(){
    int n,m,t,sum,root1,root2;
    cin>>t;
    while(t--){
        cin>>n>>m;
        sum=n;
        for(int i=1;i<=n;i++)
            pre[i]=i;
        for(int i=0;i<m;i++){
            cin>>root1>>root2;
            int xx=find(root1);
            int yy=find(root2);
            if(xx!=yy){
                pre[xx]=yy;
                sum--;
            }
        }
        cout<<sum<<endl;
    }
	return 0;
}
]]>畅通工程-HDU-1232（并查集经典模板）https://lruihao.cn/posts/%E7%95%85%E9%80%9A%E5%B7%A5%E7%A8%8B/Tue, 31 Jul 2018 11:08:43 +0000Lruihaohttps://lruihao.cn/posts/%E7%95%85%E9%80%9A%E5%B7%A5%E7%A8%8B/并查集入门推荐：超有爱的并查集~

题目链接：畅通工程

题意分析：

首先在地图上给你若干个城镇，这些城镇都可以看作点，然后告诉你哪些对城镇之间是有道路直接相连的。最后要解决的是整幅图的连通性问题。比如随意给你两个点，让你判断它们是否连通，或者问你整幅图一共有几个连通分支，也就是被分成了几个互相独立的块。像畅通工程这题，问还需要修几条路，实质就是求有几个连通分支。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include<iostream>
#include<cstdio>
using namespace std;
int pre[1010];

int findd(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

int main(){
    int n,m,i,sum,r1,r2,star,end1;
    while(scanf("%d",&n)&&n){
        sum=n-1;
        for(i=1;i<=n;i++)
            pre[i]=i;
        scanf("%d",&m);
        while(m--){
            scanf("%d%d",&star,&end1);
            r1=findd(star);
            r2=findd(end1);
            if(r1!=r2){
                pre[r1]=r2;
                sum--;
            }
        }
        printf("%d\n",sum);
    }
	return 0;
}

基础回顾：

find() 函数找根结点的两种写法如下：

第一种递归：

1
2
3
4

int find(int x)
{
    return x == pre[x] ? x : find(pre[x]);
}

第二种：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

int find(int x)
{
    int root, temp;
    root = x;
    while(root != pre[root])
        root = pre[root];
    while(x != root)
    {
        temp = pre[x];
        pre[temp] = root;
        x = temp;
    }
    return root;
}
合并函数
1
2
3
4
5
6

void join(int x,int y){
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        pre[fx]=fy;
}
]]>HDU-1495-非常可乐（bfs 模拟倒水 or 数论）https://lruihao.cn/posts/hdu-1495/Tue, 24 Jul 2018 15:34:00 +0000Lruihaohttps://lruihao.cn/posts/hdu-1495/非常可乐

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是 seeyou 却不这么认为。因为每次当 seeyou 买了可乐以后，阿牛就要求和 seeyou 一起分享这一瓶可乐，而且一定要喝的和 seeyou 一样多。但 seeyou 的手中只有两个杯子，它们的容量分别是 N 毫升和 M 毫升 可乐的体积为 S （S<101）毫升　（正好装满一瓶） ，它们三个之间可以相互倒可乐 （都是没有刻度的，且 S==N+M，101 ＞ S ＞ 0，N ＞ 0，M ＞ 0) 。聪明的 ACMER 你们说他们能平分吗？如果能请输出倒可乐的最少的次数，如果不能输出"NO"。

Input

三个整数 : S 可乐的体积 , N 和 M 是两个杯子的容量，以"0 0 0"结束。

Output

如果能平分的话请输出最少要倒的次数，否则输出"NO"。

Sample Input

7 4 3
4 1 3
0 0 0

Sample Output

NO
3

模拟一下倒水的过程，一共有三种倒法，a 向 bc，b 向 ac，c 向 ab。（相当于一共六个方向）搜索并记录搜索过的过程就好了。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#include<bits/stdc++.h>
using namespace std;

int a,b,c;
int used[111][111][111];
struct node
{
	int x,y,z;
	int step;
}m,n;

int bfs()
{
	queue<node>q;
	m.x = a;
	m.y = 0;
	m.z = 0;
	m.step = 0;
	used[a][0][0] = 1;
	q.push(m);
	while (!q.empty())
	{
		int trans;		//倒水量
		m = q.front();
		q.pop();

		//成功分好的三种情况
		if ((m.x == 0 && m.y == m.z) || (m.y == 0 && m.x == m.z) || (m.z == 0 && m.x == m.y))
			return m.step;

		//下面开始 6 个搜索（由一个杯子向另外两个倒水）
		if (m.x)
		{
			//第一
			trans = min(m.x , b - m.y);//自己模拟一下倒水过程就知道了
				n.x = m.x - trans;
				n.y = m.y + trans;
				n.z = m.z;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					q.push(n);
					used[n.x][n.y][n.z] = 1;
				}

			//第二
			trans = min(m.x , c - m.z);
				n.x = m.x - trans;
				n.y = m.y;
				n.z = m.z + trans;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					q.push(n);
					used[n.x][n.y][n.z] = 1;
				}
		}
		if (m.y)
		{
			//第三
			trans = min(m.y , a - m.x);
				n.x = m.x + trans;
				n.y = m.y - trans;
				n.z = m.z;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					used[n.x][n.y][n.z] = 1;
					q.push(n);
				}

			//第四
			trans = min(m.y , c - m.z);
				n.x = m.x;
				n.y = m.y - trans;
				n.z = m.z + trans;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					used[n.x][n.y][n.z] = 1;
					q.push(n);
				}
		}
		if (m.z)
		{
			//第五
			trans = min(m.z , a - m.x);
				n.x = m.x + trans;
				n.y = m.y;
				n.z = m.z - trans;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					used[n.x][n.y][n.z] = 1;
					q.push(n);
				}

			//第六
			trans = min(m.z , b - m.y);
				n.x = m.x;
				n.y = m.y + trans;
				n.z = m.z - trans;
				n.step = m.step + 1;
				if (!used[n.x][n.y][n.z])
				{
					q.push(n);
					used[n.x][n.y][n.z] = 1;
				}
		}
	}
	return 0;
}

int main()
{
	while (~scanf ("%d %d %d",&a,&b,&c) && (a || b || c))
	{
		if (a&1)		//先简单的剪枝一下，奇数肯定不能平分
			printf ("NO\n");
		else
		{
			memset (used,0,sizeof (used));
			int ans = bfs();
			if (ans)
				printf ("%d\n",ans);
			else
				printf ("NO\n");
		}
	}
	return 0;
}

然后杭电上讨论板子上提供一种数论题解，但是数据存在一点问题，只不过有些数据好像不对；比如： 10 6 5 的结果应该是 1 而不是 9， 也提示我们多维思考同一个问题！

数论推导

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include<bits/stdc++.h>
using namespace std;

int main(){
    int s,n,m;
    while(cin>>s>>n>>m,s+n+m){
        s/=__gcd(n,m);
        if(s&1)//奇数
            cout<<"NO\n";
        else cout<<s-1<<endl;
    }
    return 0;
}
]]>hdu-2612-Find a way（双 bfs）https://lruihao.cn/posts/hdu-2612/Mon, 23 Jul 2018 12:34:42 +0000Lruihaohttps://lruihao.cn/posts/hdu-2612/Find a way

圣诞节要到了，坤神和瑞瑞这对基佬想一起去召唤师大峡谷开开车。百度地图一下，发现周围的召唤师大峡谷还不少，这对基佬纠结着，该去哪一个。坤神：我要去左边的这个（因为离自己比较近 哈哈~）。瑞瑞：我要去右边的这个（因为离自己比较近 嘿嘿~） …….. 这对基佬闹矛盾了，开车有危险了！ 为了不让他们去召唤师大峡谷坑人，riot 决定让他们去 X 召唤师大峡谷，保证他俩所走的路程和最短。每走一个点需要花费 11 分钟，输出他们一共花费多少时间（最短时间噢）

Input

多组测试数据

每组数据，开始一行 n，m (2<=n,m<=200)

接下来是个 n x m 的矩阵

‘Y’ 表示坤神所在的初始位置

‘M’ 表示瑞瑞所在的初始位置

‘#’ 该点禁止通行

‘.’ 该点可通行

‘@’ 召唤师大峡谷

Output

每组测试数据，输出坤神和瑞瑞到达同一个召唤师大峡谷所花费的最短时间。

Sample Input

4 4
Y.#@
....
.#..
@..M
4 4
Y.#@
....
.#..
@#.M
5 5
Y..@.
.#...
@..M.
`#...#`

Sample Output

66
88
66

Hint

对于第一组样例，坤神和瑞瑞去矩阵（4,1） 这个召唤师大峡谷，耗费的时间为 3 _ 11 + 3 _ 11 = 66， 去矩阵（1,4）这个召唤师大峡谷，耗费的时间为 5 _ 11 + 3 _ 11 = 88 。所以，最终答案：66。思路参考

写代码总是好粗心！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f     //acm 中“无穷大”的一般定义
using namespace std;

const int M=202;
char mp[M][M];            //地图
int a[M][M],b[M][M];
bool vis[M][M];           //标记数组
int n,m;
int ans;
struct node
{
    int x,y,step;
};

void init()              //初始化函数
{
    ans=inf;
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
        {
            a[i][j]=inf;
            b[i][j]=inf;
        }
}

void bfs(int x,int y,bool flag){
    int dir[4][2]={-1,0,1,0,0,1,0,-1};
    node u,v;
    queue<node> q;  //初始化队列第一个元素
    u.x=x;
    u.y=y;
    u.step=0;
    vis[x][y]=true;
    q.push(u);
    while(!q.empty()){
        u=q.front();
        q.pop();
        if(mp[u.x][u.y]=='@'){
            if(!flag) a[u.x][u.y]=u.step;
            else b[u.x][u.y]=u.step;
        }
        for(int i=0;i<4;i++){
            int tx=u.x+dir[i][0];
            int ty=u.y+dir[i][1];
            if(tx>=0&&ty>=0&&tx<n&&ty<m&&!vis[tx][ty]&&mp[tx][ty]!='#'){//注意@和 M，Y 也是可以走的。
                v.x=tx;                                          //每次写搜索都忘记 vis!!!!
                v.y=ty;
                vis[tx][ty]=true;  //我总是忘记。
                v.step=u.step+1;
                q.push(v);
            }
        }
    }
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0; i<n; i++)
            scanf("%s",mp[i]);
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
            {
                if(mp[i][j]=='Y')
                {
                    memset(vis,false,sizeof(vis));
                    bfs(i,j,false);
                }
                if(mp[i][j]=='M')
                {
                    memset(vis,false,sizeof(vis));  //记得再次初始化标记数组
                    bfs(i,j,true);
                }
            }
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                if(mp[i][j]=='@')
                    ans=min(ans,a[i][j]+b[i][j]);
        printf("%d\n",ans*11);
    }
    return 0;
}
]]>hdu-1241-Oil Deposits (dfs)https://lruihao.cn/posts/hdu-1241/Sun, 22 Jul 2018 11:37:20 +0000Lruihaohttps://lruihao.cn/posts/hdu-1241/Oil Deposits

翻译
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 41406 Accepted Submission(s): 23977

Problem Description

The GeoSurvComp geologic survey company is responsible for detecting underground oil deposits. GeoSurvComp works with one large rectangular region of land at a time, and creates a grid that divides the land into numerous square plots. It then analyzes each plot separately, using sensing equipment to determine whether or not the plot contains oil. A plot containing oil is called a pocket. If two pockets are adjacent, then they are part of the same oil deposit. Oil deposits can be quite large and may contain numerous pockets. Your job is to determine how many different oil deposits are contained in a grid.

Input

The input file contains one or more grids. Each grid begins with a line containing m and n, the number of rows and columns in the grid, separated by a single space. If m = 0 it signals the end of the input; otherwise 1 <= m <= 100 and 1 <= n <= 100. Following this are m lines of n characters each (not counting the end-of-line characters). Each character corresponds to one plot, and is either ’ * ‘, representing the absence of oil, or ‘@’, representing an oil pocket.

Output

For each grid, output the number of distinct oil deposits. Two different pockets are part of the same oil deposit if they are adjacent horizontally, vertically, or diagonally. An oil deposit will not contain more than 100 pockets.

Sample Input

1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5
****@
*@@*@
*@**@
@@@*@
@@**@
0 0

Sample Output

0
1
2

Source

Mid-Central USA 1997

Recommend

Eddy | We have carefully selected several similar problems for you: 1016 1010 1312 1242 1240

思路

dfs 模板题吧，八个方向搜索；（像 i，j 这样的计数器还是写在局部比较好，我尽然被定义域的问题搞了一晚上醉了醉了。）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include<bits/stdc++.h>
using namespace std;

int n,m,s;
char maze[107][107];
int vx[8]={-1,1,0,0,-1,-1,1,1};
int vy[8]={0,0,-1,1,-1,1,1,-1};

void dfs(int x,int y){
    maze[x][y]='*';
    for(int i=0;i<8;i++){
        int tx=x+vx[i];
        int ty=y+vy[i];
        if(tx>=0&&tx<m&&ty>=0&&ty<n&&maze[tx][ty]=='@')
            dfs(tx,ty);
    }
}

int main(){
    int i,j;
    while(cin>>m>>n&&m){
        s=0;
        for(i=0;i<m;i++)
            cin>>maze[i];
        for(i=0;i<m;i++){//相当于不连通的情况
            for(j=0;j<n;j++){
                if(maze[i][j]=='@'){
                    dfs(i,j);
                    s++;
                }
            }
        }
        cout<<s<<endl;
    }
	return 0;
}
]]>