OJ-黑百盒子

题目描述

地面上画了N*N的格子，格子只有黑白两种颜色。现规定 如果 站在 白色格子里，则可以
走到 上、下、左、右 相邻的某个黑色格子里； 如果 站在 黑色格子里， 则可以
走到 上、下、左、右 相邻的某个白色格子里。

给定一个起始位置，请问 从该起始位置开始，最多可以 到达 多少个 格子， 包含 起始格子。

输入

第一行， 一个整数 N
接下来N行，表示 每一行各方格的颜色， 0 表示黑色， 1 表示白色
再接下来一行， 一个整数 M
再接下来M行，每行2个整数 X，Y 用空格隔开（表示 起始位置，第 X 行，第Y列）

输出

M行，每行一个整数，表示 每个起始位置，对应的可达到的最大格子数。

数据范围：

1 <=N<=1000
1 <=M<=100000

样例输入

3
100
000
110
2
1 1
2 3

样例输出

4
1

提示

例子解析

M = 2
需要解 2 组数据

第一组 起始位置 1，1 ：

从 1，1 开始， 可以到达的格式 是 1,2 、 2，1 、 3 、1
所有最大格子数是4 ，包含起始位置（1，1）

第二组 起始位置 2 ，3 ：
上下左右都不能走， 所以 输出1 ， 仅包含起始位置

//黑白方块
#include <iostream>
#include <vector>
#include <cmath> // For pow function

using namespace std;

const vector<pair<int, int> > directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

bool isValid(int x, int y, int n) 
{
    return x >= 0 && x < n && y >= 0 && y < n;
}

void dfs(vector<vector<int> >& grid, vector<vector<bool> >& visited, int x, int y, int n, int color, int& count) {
    visited[x][y] = true;
    count++;
    
    for (const auto& dir : directions) 
    {
        int nx = x + dir.first;
        int ny = y + dir.second;
        if (isValid(nx, ny, n) && !visited[nx][ny] && grid[nx][ny] != color) {
            dfs(grid, visited, nx, ny, n, grid[nx][ny], count);
        }
    }
}

int maxReachableCells(vector<vector<int> >& grid, int startX, int startY) {
    int n = grid.size();
    if (n == 0) return 0;
    
    vector<vector<bool> > visited(n, vector<bool>(n, false));
    int maxCells = 0;
    
    int count = 0;
    dfs(grid, visited, startX, startY, n, grid[startX][startY], count);
    maxCells = count;
    
    return maxCells;
}

int main() 
{
    int N;
    cin >> N;
    int temp;
    
    vector<vector<int> > grid(N, vector<int>(N));
    for (int i = 0; i < N; ++i)
    {
        cin >> temp;
        for(int j = 0; j < N; j++)
        {
            cout<< "temp--" << temp<<endl;
            int number = temp / pow(10, N - j - 1);
            if(1 == number)
            {
                temp -= pow(10, N - j - 1);
            }
            cout<< "number--" << number<<endl;
            grid[i][j] = number;
        }
    }
    
    int M;
    cin >> M;
    vector<pair<int, int> > startPositions(M);
    for (int i = 0; i < M; ++i) 
    {
        int X, Y;
        cin >> X >> Y;
        startPositions[i] = {X - 1, Y - 1}; // Convert to 0-based index
    }
    
    vector<int> results(M);
    for (int i = 0; i < M; ++i) 
    {
        int startX = startPositions[i].first;
        int startY = startPositions[i].second;
        results[i] = maxReachableCells(grid, startX, startY);
    }
    
    for (int result : results) 
    {
        cout << result << endl;
    }
    
    return 0;
}