各类AI工具编程能力测试对比

101. 孤岛的总面积

题目链接：101. 孤岛的总面积

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。

解题思路：

代码：

#include<iostream>
#include<vector>
using namespace std;
 
int count;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};
 
void dfs(vector<vector<int>>& matrix,vector<vector<int>>& visited,int r, int c)
{
    matrix[r][c] = 0;
    visited[r][c] = true;
    count++;
    for(int i = 0; i < 4; i++)
    {
        int x = r + dx[i], y = c + dy[i];
        if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
        if(matrix[x][y] == 1 && !visited[x][y])
            dfs(matrix,visited,x,y);
    }
}
 
int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>> matrix(n+2,vector<int>(m+2));
    vector<vector<int>> visited(n+2,vector<int>(m+2));
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j++)
            cin >> matrix[i][j];
     
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(i == 1 || i == n || j == 1 || j == m)
                if(matrix[i][j] == 1 && visited[i][j] == false)
                    dfs(matrix,visited,i,j);
        }
    }
     
    int area = 0;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(matrix[i][j] == 1 && !visited[i][j])
            {
                count = 0;
                dfs(matrix,visited,i,j);
                area += count;
            }
        }
    }
     
    cout << area << endl;
    return 0;
}

102. 沉没孤岛

题目链接：102. 沉没孤岛

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。

解题思路：

代码：

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

int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};

void dfs(vector<vector<int>>& matrix,vector<vector<bool>>& visited,int r, int c)
{
    visited[r][c] = true;
    matrix[r][c] = 2;
    for(int i = 0; i < 4; i++)
    {
        int x = r + dx[i], y = c + dy[i];
        if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
        if(matrix[x][y] == 1 && !visited[x][y])
            dfs(matrix,visited,x,y);
    }
    
}

int main()
{
    int n , m;
    cin >> n >> m;
    vector<vector<int>> matrix(n+2,vector<int>(m+2));
    vector<vector<bool>> visited(n+2,vector<bool>(n+2));
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            cin >> matrix[i][j];
            
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(i == 1 || i == n || j == 1 || j == m)
            {
                if(matrix[i][j] == 1 && !visited[i][j])
                    dfs(matrix,visited,i,j);
            }
        }
    }
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            if(matrix[i][j] == 1) matrix[i][j] = 0;
            
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(matrix[i][j] == 2) matrix[i][j] = 1;
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

103. 水流问题

题目链接：103. 水流问题

题目描述：

现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。

矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。

优化思路：

代码：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
 
int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};
 
void dfs(vector<vector<int>>& matrix,vector<vector<bool>>& visited,int r, int c)
{
    visited[r][c] = true;
    for(int i = 0; i < 4; i++)
    {
        int x = r + dx[i], y = c + dy[i];
        if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
        if(matrix[x][y] >= matrix[r][c] && !visited[x][y])
            dfs(matrix,visited,x,y);
    }
    return;
}
 
int main()
{
    int n,m;
    cin >> n >> m;
    vector<vector<int>> matrix(n,vector<int>(m));
    vector<vector<bool>> firstbound(n,vector<bool>(m,false));
    vector<vector<bool>> secondbound(n,vector<bool>(m,false));
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> matrix[i][j];
             
    for(int i = 0; i < n; i++)
    {
        dfs(matrix,firstbound,i,0);
        dfs(matrix,secondbound,i,m-1);
    }
     
    for(int j = 0; j < m; j++)
    {
        dfs(matrix,firstbound,0,j);
        dfs(matrix,secondbound,n-1,j);
    }
     
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            if(firstbound[i][j] && secondbound[i][j]) 
                cout << i << " " << j << endl;
     
    return 0;
}

104.建造最大岛屿

题目链接：104. 建造最大岛屿

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。

岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。

优化思路：

代码：

#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<algorithm>
using namespace std;

int dx[4] = {-1,0,0,1};
int dy[4] = {0,-1,1,0};
int cnt;

void dfs(vector<vector<int>>& grid, int r, int c, int target)
{
    cnt ++;
    grid[r][c] = target;
    for(int i = 0; i < 4; i++)
    {
        int x = r + dx[i], y = c + dy[i];
        if(x < 0 || y < 0 || x >= grid.size() || y >= grid[0].size()) continue;
        if(grid[x][y] == 1) dfs(grid,x,y,target);
    }
}


int main()
{
    int n , m;
    cin >> n >> m;
    vector<vector<int>> grid(n,vector<int>(m));
    unordered_map<int,int> area;
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> grid[i][j];
    
    int target = 2;
    bool isAllGrid = true; // 标记是否整个地图都是陆地
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            if(grid[i][j] == 0) isAllGrid = false;
            if(grid[i][j] == 1)
            {
                cnt = 0;
                dfs(grid,i,j,target);
                area[target] = cnt;
                target++;
            }   
        }
    }
    
    int maxArea = 0;
    if(isAllGrid) maxArea = n * m; 
    else
    {
        unordered_set<int> visitedGrid;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                visitedGrid.clear();
                if(grid[i][j] == 0)
                {
                    int sum = 0;
                    for(int k = 0; k < 4; k++)
                    {
                        int x = i + dx[k], y = j + dy[k];
                        if(x < 0 || y < 0 || x >= n || y >= m) continue;
                        if(grid[x][y] && !visitedGrid.count(grid[x][y])) 
                        {
                            sum += area[grid[x][y]];
                            visitedGrid.insert(grid[x][y]);
                        }
                    }
                    maxArea = max(maxArea,sum + 1);
                }
            }
        }
    }
    
    cout << maxArea << endl;
    return 0;
}