Submission #1971649

---

Source Code Expand

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
using namespace std;

typedef pair<int, int> P;

#define FOR(i, s, e) for (int i = (s); i <= (e); i++)

int w, h;

int result = 0;

int field[110][110];

int visited[110][110];

int dx[2][6] = {{-1, -1, 0, +1, 0, -1}, {-1, 0, +1, +1, +1, 0}};
int dy[2][6] = {{0, -1, -1, 0, +1, +1}, {0, -1, -1, 0, +1, +1}};

int main()
{
    cin >> w >> h;

    FOR(i, 1, h)
    {
        FOR(j, 1, w)
        {
            cin >> field[j][i];
        }
    }

    FOR(i, 1, w)
    {
        FOR(j, 1, h)
        {
            if (visited[i][j] == 0 && field[i][j] == 0)
            {
                queue<P> q;

                q.push(P(i, j));

                bool out = false;

                while (!q.empty())
                {
                    int x = q.front().first;
                    int y = q.front().second;
                    q.pop();
                    if(visited[x][y] == 1) continue;
                    visited[x][y] = 1;
                    
                    if (x <= 1 || x >= w + 2 || y <= -1 || y >= h + 2)
                    {
                        out = true;
                        continue;
                    }

                    int mode = y % 2;

                    FOR(di, 0, 5)
                    {
                        int nex = x + dx[mode][di];
                        int ney = y + dy[mode][di];

                        if (field[nex][ney] == 0 && visited[nex][ney] == 0)
                        {
                            q.push(P(nex, ney));
                        }
                    }
                }

                if (out)
                {
                    q.push(P(i, j));
                    while (!q.empty())
                    {
                        int x = q.front().first;
                        int y = q.front().second;
                        q.pop();
                        if(field[x][y] == 2) continue;
                        field[x][y] = 2;

                        

                        int mode = y % 2;

                        FOR(di, 0, 5)
                        {
                            int nex = x + dx[mode][di];
                            int ney = y + dy[mode][di];
                            if (nex >= 0 && nex <= w + 2 && ney >= 0 && ney <= h + 2)
                                if (field[nex][ney] == 0 && field[nex][ney] != 2)
                                {
                                    q.push(P(nex, ney));
                                }
                        }
                    }
                }
            }
        }
    }

    FOR(i, 1, w)
    {
        FOR(j, 1, h)
        {
            if (field[i][j] == 1)
            {
                queue<P> que;
                que.push(P(i, j));

                while (!que.empty())
                {
                    int x = que.front().first;
                    int y = que.front().second;

                    que.pop();

                    if (visited[x][y] == 1)
                        continue;

                    visited[x][y] = 1;

                    int mode = y % 2;

                    FOR(di, 0, 5)
                    {
                        int nex = x + dx[mode][di];
                        int ney = y + dy[mode][di];

                        if (field[nex][ney] == 1 && visited[nex][ney] == 0)
                        {
                            que.push(P(nex, ney));
                        }
                        if (field[nex][ney] == 2)
                        {
                            result++;
                        }
                    }
                }
            }
        }
    }
    cout << result << endl;
    return 0;
}

Submission Info

Judge Result