题目名称：油田

题目描述

输入多个m行n列的矩阵，用0 0表示输入结束。找出有多少块石油区域，用“@”代表石油，假如两个“@”在横，竖或对角线上相邻，就说它们位于同一区域，对于每个输入，输出一个数表示有几个石油区域。

输入描述

输入若干测试样例，每一个测试样例先输入两个整数m，n。（1≤m,n≤100）
接下来m行，每行n个字符，其中@表示石油区域，*表示非石油区域。

输出描述

输出若干行，每行一个整数，表示该测试样例有几个石油区域。

样例1

输入

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

输出

0 1 2 2

AC代码：

#include <iostream>
using namespace std;
#define maxn 100
int m, n;
string s[maxn];
bool vis[maxn][maxn];
 
void DFS(int u,int v)
{
    vis[u][v] = true;
    for (int i = -1; i <= 1; i++)
    {
        for (int j = -1; j <= 1; j++)
        {
            if (i != 0 || j != 0)
            {
                int ui = u + i;
                int vj = v + j;
                if (ui >= 0 && ui < m && vj >= 0 && vj < n && s[ui][vj] == '@' && !vis[ui][vj])
                {
                    DFS(ui, vj);
                }
            }
        }
    }
}
 
int main()
{
    while (cin >> m >> n && m)
    {
        fill(vis[0], vis[0] + maxn * maxn, false);
        int cnt = 0;
        for (int i = 0; i < m; i++)
        {
            cin >> s[i];
        }
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (s[i][j] == '@' && !vis[i][j])
                {
                    DFS(i, j);
                    cnt++;
                }
            }
        }
        cout << cnt << endl;
    }
 
    return 0;
}

首先，你使用了DFS（深度优先搜索）来遍历矩阵中的每个点，判断是否属于石油区域。这是一种常见的解决连通性问题的方法，但在这个问题中，我们可以使用并查集来更高效地解决。

并查集是一种用于处理集合合并和查询连通性的数据结构。我们可以将石油区域看作是一个个的集合，每个集合中的点都是相互连通的。我们可以使用并查集来维护这些集合。

具体做法是，首先初始化每个点为一个单独的集合，然后遍历矩阵中的每个点，如果该点是石油区域（'@'），则将其与上、下、左、右四个方向的点进行合并操作。最后，统计并查集中有多少个不同的根节点，即为石油区域的个数。

下面是使用并查集来优化的代码示例：

#include <iostream>
#include <vector>
using namespace std;

#define maxn 100

int m, n;
string s[maxn];
vector<int> parent(maxn * maxn); // 并查集的父节点数组

int find(int x) {
    if (parent[x] == x) {
        return x;
    }
    return parent[x] = find(parent[x]);
}

void unite(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY) {
        parent[rootX] = rootY;
    }
}

int main() {
    while (cin >> m >> n && m) {
        for (int i = 0; i < m; i++) {
            cin >> s[i];
        }

        // 初始化并查集
        for (int i = 0; i < m * n; i++) {
            parent[i] = i;
        }

        int cnt = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (s[i][j] == '@') {
                    // 合并上、下、左、右四个方向的点
                    if (i > 0 && s[i - 1][j] == '@') {
                        unite(i * n + j, (i - 1) * n + j);
                    }
                    if (i < m - 1 && s[i + 1][j] == '@') {
                        unite(i * n + j, (i + 1) * n + j);
                    }
                    if (j > 0 && s[i][j - 1] == '@') {
                        unite(i * n + j, i * n + j - 1);
                    }
                    if (j < n - 1 && s[i][j + 1] == '@') {
                        unite(i * n + j, i * n + j + 1);
                    }
                }
            }
        }

        // 统计并查集中不同的根节点个数
        for (int i = 0; i < m * n; i++) {
            if (parent[i] == i) {
                cnt++;
            }
        }

        cout << cnt << endl;
    }

    return 0;
}
这样，使用并查集的方法可以更高效地解决这个问题。希望对你有帮助！