Problem:
イルミネーション (Illumination)
問題
JOI 社の建物は図のような 1 辺 1 メートルの正六角形をつなぎ合わせた形である．クリスマスが近づいているので，JOI 社では建物の壁面をイルミネーションで飾り付けることにした．ただし，外から見えない部分にイルミネーションを施すのは無駄なので，イルミネーションは外から建物の中を通らずに行くことのできる壁面にのみ飾り付けることにした．
図: JOI 社の建物の配置の例
上の図は上空から見た JOI 社の建物の配置の例である．正六角形内の数字は座標を表す．灰色の正六角形は建物がある場所を表し，白色の正六角形は建物がない場所を表す．この例では，赤の実線で示される部分がイルミネーションで飾り付けを行う壁面となり，その壁面の長さの合計は 64 メートルとなる．
JOI 社の建物の配置を表す地図が与えられたとき，飾り付けを行う壁面の長さの合計を求めるプログラムを作成せよ．ただし，地図の外側は自由に行き来できるものとし，隣接した建物の間は通ることはできないものとする．
入力
入力ファイルの 1 行目には 2 つの整数 W, H (1 ≦ W ≦ 100，1 ≦ H ≦ 100) が空白を区切りとして書かれている．続く H 行には JOI 社の建物の配置が書かれている．i + 1 行目 (1 ≦ i ≦ H) には W 個の整数が空白を区切りとして書かれており，j 個目 (1 ≦ j ≦ W) の整数は座標 (j, i) の正六角形に建物がある時は 1 であり，ない時は 0 である．また，与えられる入力データには建物が必ず 1 つ以上ある．
地図は以下の規則によって記述されている．
地図の最も北の行の最も西の正六角形は座標 (1, 1) である．
座標 (x, y) の正六角形に隣接する東隣の正六角形は座標 (x + 1, y) である．
y が奇数の時，座標 (x, y) の正六角形に隣接する南西の正六角形の座標は (x, y + 1) である．
y が偶数の時，座標 (x, y) の正六角形に隣接する南東の正六角形の座標は (x, y + 1) である．
出力
イルミネーションで飾り付けを行う壁面の長さの合計を 1 行で出力せよ．
入出力例
入力例 1
8 4
0 1 0 1 0 1 1 1
0 1 1 0 0 1 0 0
1 0 1 0 1 1 1 1
0 1 1 0 1 0 1 0
出力例 1
64
入出力例 1 は問題文中の例に対応しており，イルミネーションで飾り付けを行う壁面の長さの合計は 64 メートルである．
入力例 2
8 5
0 1 1 1 0 1 1 1
0 1 0 0 1 1 0 0
1 0 0 1 1 1 1 1
0 1 0 1 1 0 1 0
0 1 1 0 1 1 0 0
出力例 2
56
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
long long mmin(long long &a,long long b) {
	a = min(a, b);
	return a;
}
long long mmax(long long &a,long long b) {
	a = max(a, b);
	return a;
}
int nibu(vector<int> &v, int tan) {
	int up = v.size()-1;
	int lo = 0;
	if (tan <= v[0]) {
		return 0;
	}
	while (up - lo > 1) {
		int mi = (up + lo) / 2;
		if (tan <= v[mi]) {
			up = mi;
		}
		if (v[mi] < tan) {
			lo = mi;
		}
	}
	return up;
}
int ne(int &i, int &j, int k, int ty) {
	int di = 0; int dj = 0;
	if (k % 3 == 1) {
		dj = 1;
	}
	else if (k == 2) {
		dj = -2;
	}
	else if (k == 3) {
		di = 1;
	}
	else if (k == 5) {
		di = -2;
	}
	else {
		dj = -1;
	}
	if (ty == 1) {
		dj = -dj;
	}
	i += di;
	j += dj;
	return 0;
}
int main() {
	int w, h;
	cin >> w >> h;
	vector<vector<int> > ta(h, vector<int>(w));
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			cin >> ta[i][j];
		}
	}
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			if (ta[i][j] == 0) {
				vector<vector<int> > qt = ta;
				qt[i][j] = 1;
				vector<int> nei(h*w);
				vector<int> nej(h*w);
				nei[0] = i;
				nej[0] = j;
				int up = 1;
				int lo = 0;
				int da = 0;
				while (up != lo and da == 0) {
					int qup = up;
					for (int in = lo; in < up and da == 0; in++) {
						int pi = nei[in];
						int pj = nej[in];
						if (0 < pi and pi < h - 1) {
							if (0 < pj and pj < w - 1) {
								int ty = (pi+1) % 2;
								for (int k = 0; k < 6; k++) {
									ne(pi, pj, k+1, ty);
									if (qt[pi][pj] == 0) {
										nei[qup] = pi;
										nej[qup] = pj;
										qup++;
										qt[pi][pj] = 1;
									}
								}
							}
							else {
								da = 1;
							}
						}
						else {
							da = 1;
						}
					}
					lo = up;
					up = qup;
				}
				if (da == 0) {
					ta = qt;
				}
			}
		}
	}
	vector<vector<int> > ht(h + 2, vector<int>(w + 2,0));
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			ht[i + 1][j + 1] = ta[i][j];
		}
	}
	h += 2;
	w += 2;
	int ans = 0;
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			if (j < w - 1) {
				if (ht[i][j] + ht[i][j + 1] == 1) {
					ans++;
				}
			}
			int x = j - 1+i % 2;
			if (x >= 0 and i < h - 1) {
				if (ht[i][j] + ht[i + 1][x] == 1) {
					ans++;
				}
			}
			int y = j + i % 2;
			if (y < w and i < h - 1) {
				if (ht[i][j] + ht[i + 1][y] == 1) {
					ans++;
				}
			}
		}
	}
	cout << ans << endl; 
}
accuracy: 1
time_ms: 330
memory_kb: 3280
final_rank: 17

code_snippet: #include <iostream>
#include <cstring>
#define MS memset(yet, false, sizeof(yet))

using namespace std;

int h, w, a[110][110];
bool yet[110][110];
bool dfseven (int i, int j);

bool dfsodd (int i, int j)
{
    yet[i][j]=true;
    if (a[i][j]==1) return false;
    if (i==0 || i==h+1 || j==0 || j==w+1) return true;
    if (a[i][j]==0)
    {
        if (!yet[i-1][j]) { if (dfseven(i-1, j)) return true; }
        if (!yet[i-1][j+1]) { if (dfseven(i-1, j+1)) return true; }
        if (!yet[i][j-1]) { if (dfsodd(i, j-1)) return true; }
        if (!yet[i][j+1]) { if (dfsodd(i, j+1)) return true; }
        if (!yet[i+1][j]) { if (dfseven(i+1, j)) return true; }
        if (!yet[i+1][j+1]) { if (dfseven(i+1, j+1)) return true; }
    }
    return false;
}

bool dfseven (int i, int j)
{
    yet[i][j]=true;
    if (a[i][j]==1) return false;
    if (i==0 || i==h+1 || j==0 || j==w+1) return true;
    if (a[i][j]==0)
    {
        if (!yet[i-1][j-1]) { if (dfsodd(i-1, j-1)) return true; }
        if (!yet[i-1][j]) { if (dfsodd(i-1, j)) return true; }
        if (!yet[i][j-1]) { if (dfseven(i, j-1)) return true; }
        if (!yet[i][j+1]) { if (dfseven(i, j+1)) return true; }
        if (!yet[i+1][j-1]) { if (dfsodd(i+1, j-1)) return true; }
        if (!yet[i+1][j]) { if (dfsodd(i+1, j)) return true; }
    }
    return false;
}

int main()
{
    int cnt, sum=0;
    bool ok;
    memset(a, 0, sizeof(a));
    cin>>w>>h;
    for (int i=1; i<=h; i++) for (int j=1; j<=w; j++) cin>>a[i][j];
    for (int i=1; i<=h; i++)
    {
        for (int j=1; j<=w; j++)
        {
            ok=false;
            if (i%2==1 && a[i][j]==0)
            {
                if (dfseven(i-1, j)) { MS; ok=true; }
                else if (dfseven(i-1, j+1)) { MS; ok=true; }
                else if (dfsodd(i, j-1)) { MS; ok=true; }
                else if (dfsodd(i, j+1)) { MS; ok=true; }
                else if (dfseven(i+1, j)) { MS; ok=true; }
                else if (dfseven(i+1, j+1)) { MS; ok=true; }
            }
            if (i%2==0 && a[i][j]==0)
            {
                if (dfsodd(i-1, j-1)) { MS; ok=true; }
                else if (dfsodd(i-1, j)) { MS; ok=true; }
                else if (dfseven(i, j-1)) { MS; ok=true; }
                else if (dfseven(i, j+1)) { MS; ok=true; }
                else if (dfsodd(i+1, j-1)) { MS; ok=true; }
                else if (dfsodd(i+1, j)) { MS; ok=true; }
            }
            if (!ok && a[i][j]==0) a[i][j]=1;
        }
    }
    for (int i=1; i<=h; i++)
    {
        for (int j=1; j<=w; j++)
        {
            cnt=6;
            if (i%2==1 && a[i][j])
            {
                if (a[i-1][j]) cnt--;
                if (a[i-1][j+1]) cnt--;
                if (a[i][j-1]) cnt--;
                if (a[i][j+1]) cnt--;
                if (a[i+1][j]) cnt--;
                if (a[i+1][j+1]) cnt--;
                sum+=cnt;
            }
            if (i%2==0 && a[i][j])
            {
                if (a[i-1][j-1]) cnt--;
                if (a[i-1][j]) cnt--;
                if (a[i][j-1]) cnt--;
                if (a[i][j+1]) cnt--;
                if (a[i+1][j-1]) cnt--;
                if (a[i+1][j]) cnt--;
                sum+=cnt;
            }
        }
    }
    cout<<sum<<'\n';
    return 0;
}
accuracy: 1
time_ms: 210
memory_kb: 3484
final_rank: 16

code_snippet: #include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct xy {
	int x, y;
};

xy a[6] = {
	{0,-1},
	{1,-1},
	{-1,0},
	{1,0},
	{0,1},
	{1,1}
};

xy b[6] = {
	{ -1,-1 },
	{ 0,-1 },
	{ -1,0 },
	{ 1,0 },
	{ -1,1 },
	{ 0,1 }
};


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

	vector<vector<int> > map(h+2, vector<int>(w+2, -1));

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			cin >> map[i + 1][j + 1];
		}
	}

	int ans = 0;

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			if (map[i + 1][j + 1] == 1 || map[i + 1][j + 1] == -1)continue;

			bool flag = false;
			vector<vector<bool> > used(h + 2, vector<bool>(w + 2, false));
			used[i + 1][j + 1] = true;
			xy pos = { j + 1,i + 1 };
			queue<xy> q;
			q.push(pos);

			vector<xy> root;
			while (!q.empty()) {
				xy u = q.front(); q.pop();
				if (u.y % 2 == 0) {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + b[k].y][u.x + b[k].x] == 0 && used[u.y + b[k].y][u.x + b[k].x] == false) {
							xy temp = { u.x + b[k].x , u.y + b[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + b[k].y][u.x + b[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
				else {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + a[k].y][u.x + a[k].x] == 0 && used[u.y + a[k].y][u.x + a[k].x] == false) {
							xy temp = { u.x + a[k].x , u.y + a[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + a[k].y][u.x + a[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
				root.push_back(u);
			}
		loop:
			if (flag) {
				map[i + 1][j + 1] = -1;
				for (int k = 0; k < root.size(); k++) {
					map[root[k].y][root[k].x] = -1;
				}
			}
			else {
				map[i + 1][j + 1] = 1;
				for (int k = 0; k < root.size(); k++) {
					map[root[k].y][root[k].x] = 1;
				}
			}
		}
	}

	for (int i = 1; i < h + 1; i++) {
		for (int j = 1; j < w + 1; j++) {
			if (map[i][j] != 1) continue;
			for (int k = 0; k < 6; k++) {
				if (i % 2 == 0) {
					if (map[i + b[k].y][j + b[k].x] == -1) ans++;
				}
				else {
					if (map[i + a[k].y][j + a[k].x] == -1) ans++;
				}
			}
		}
	}

	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3212
final_rank: 13

code_snippet: #include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct xy {
	int x, y;
};

xy a[6] = {
	{0,-1},
	{1,-1},
	{-1,0},
	{1,0},
	{0,1},
	{1,1}
};

xy b[6] = {
	{ -1,-1 },
	{ 0,-1 },
	{ -1,0 },
	{ 1,0 },
	{ -1,1 },
	{ 0,1 }
};


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

	vector<vector<int> > map(h+2, vector<int>(w+2, -1));

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			cin >> map[i + 1][j + 1];
		}
	}

	int ans = 0;

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			if (map[i + 1][j + 1] == 1)continue;

			bool flag = false;
			vector<vector<bool> > used(h + 2, vector<bool>(w + 2, false));
			used[i + 1][j + 1] = true;
			xy pos = { j + 1,i + 1 };
			queue<xy> q;
			q.push(pos);

			vector<xy> root;
			while (!q.empty()) {
				xy u = q.front(); q.pop();
				if (u.y % 2 == 0) {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + b[k].y][u.x + b[k].x] == 0 && used[u.y + b[k].y][u.x + b[k].x] == false) {
							xy temp = { u.x + b[k].x , u.y + b[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + b[k].y][u.x + b[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
				else {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + a[k].y][u.x + a[k].x] == 0 && used[u.y + a[k].y][u.x + a[k].x] == false) {
							xy temp = { u.x + a[k].x , u.y + a[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + a[k].y][u.x + a[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
				root.push_back(u);
			}
		loop:
			if (flag) {
				map[i + 1][j + 1] = -1;
				for (int k = 0; k < root.size(); k++) {
					map[root[k].y][root[k].x] = -1;
				}
			}
			else {
				map[i + 1][j + 1] = 1;
				for (int k = 0; k < root.size(); k++) {
					map[root[k].y][root[k].x] = 1;
				}
			}
		}
	}

	for (int i = 1; i < h + 1; i++) {
		for (int j = 1; j < w + 1; j++) {
			if (map[i][j] != 1) continue;
			for (int k = 0; k < 6; k++) {
				if (i % 2 == 0) {
					if (map[i + b[k].y][j + b[k].x] == -1) ans++;
				}
				else {
					if (map[i + a[k].y][j + a[k].x] == -1) ans++;
				}
			}
		}
	}

	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3172
final_rank: 14

code_snippet: #include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct xy {
	int x, y;
};

xy a[6] = {
	{0,-1},
	{1,-1},
	{-1,0},
	{1,0},
	{0,1},
	{1,1}
};

xy b[6] = {
	{ -1,-1 },
	{ 0,-1 },
	{ -1,0 },
	{ 1,0 },
	{ -1,1 },
	{ 0,1 }
};


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

	vector<vector<int> > map(h+2, vector<int>(w+2, -1));

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			cin >> map[i + 1][j + 1];
		}
	}

	int ans = 0;

	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			if (map[i + 1][j + 1] == 1)continue;

			bool flag = false;
			vector<vector<bool> > used(h + 2, vector<bool>(w + 2, false));
			used[i + 1][j + 1] = true;
			xy pos = { j + 1,i + 1 };
			queue<xy> q;
			q.push(pos);

			while (!q.empty()) {
				xy u = q.front(); q.pop();
				if (u.y % 2 == 0) {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + b[k].y][u.x + b[k].x] == 0 && used[u.y + b[k].y][u.x + b[k].x] == false) {
							xy temp = { u.x + b[k].x , u.y + b[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + b[k].y][u.x + b[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
				else {
					for (int k = 0; k < 6; k++) {
						if (map[u.y + a[k].y][u.x + a[k].x] == 0 && used[u.y + a[k].y][u.x + a[k].x] == false) {
							xy temp = { u.x + a[k].x , u.y + a[k].y };
							q.push(temp);
							used[temp.y][temp.x] = 1;
						}
						else if (map[u.y + a[k].y][u.x + a[k].x] == -1) {
							flag = true;
							goto loop;
						}
					}
				}
			}
		loop:
			if (flag) map[i + 1][j + 1] = -1;
			else map[i + 1][j + 1] = 1;
		}
	}

	for (int i = 1; i < h + 1; i++) {
		for (int j = 1; j < w + 1; j++) {
			if (map[i][j] != 1) continue;
			for (int k = 0; k < 6; k++) {
				if (i % 2 == 0) {
					if (map[i + b[k].y][j + b[k].x] == -1) ans++;
				}
				else {
					if (map[i + a[k].y][j + a[k].x] == -1) ans++;
				}
			}
		}
	}

	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 3144
final_rank: 12

code_snippet: #include <algorithm>
#include <iostream>

#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, m, n) for (int i = m; i < n; i++)
#define nbs(y) (y % 2 ? odd_y : even_y)

int builds[102][102];
int odd_y[][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, 0}};
int even_y[][2] = {{-1, 1}, {0, 1}, {1, 0}, {0, -1}, {-1, -1}, {-1, 0}};

bool in_rng(int x, int y, int w, int h) {
    return x >= 0 && y >= 0 && w + 1 >= x && h + 1 >= y;
}
int main() {
    int w, h;
    std::cin >> w >> h;

    rep(x, 102) rep(y, 102) builds[x][y] = 0;
    repr(y, 1, h + 1) repr(x, 1, w + 1) {
        int v;
        std::cin >> v, builds[x][y] = v;
    }

    bool labeled;
    do {
        labeled = false;
        rep(x, w + 2) rep(y, h + 2) {
            if (x == 0 && y == 0)
                builds[0][0] = 2;
            else if (!builds[x][y] &&
                     std::any_of(nbs(y), nbs(y) + 6, [&](int ns[]) {
                         int p = x + ns[0], q = y + ns[1];
                         return in_rng(p, q, w, h) && builds[p][q] == 2;
                     }))
                builds[x][y] = 2, labeled = true;
        }
    } while (labeled);

    int count = 0;
    rep(x, w + 2) rep(y, h + 2) rep(i, 3) {
        int p = x + nbs(y)[i][0], q = y + nbs(y)[i][1];
        if (in_rng(p, q, w, h) && ((builds[x][y] == 1 && builds[p][q] == 2) ||
                                   (builds[x][y] == 2 && builds[p][q] == 1)))
            count++;
    }
    std::cout << count << std::endl;
}
accuracy: 1
time_ms: 70
memory_kb: 3128
final_rank: 11

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <sstream>
#include <cmath>
#include <queue>

using namespace std;

#define INF 1
#define MAX_V 50000

struct edge{
	int to;
	int cost;
};

typedef pair<int, int> P; // first??????????????¢???second??????????????????

// ?????????O(|E|log|V|)

int d[MAX_V];
vector<edge> G[MAX_V];

void shortest_path(int s, int V){ // V???????????°
	
	priority_queue<P, vector<P>, greater<P> > que;
	
	for(int i = 0; i < V; i++){
		d[i] = INF;
	}
	d[s] = 0;
	
	que.push(P(0, s));
	
	while(!que.empty()){
		
		P p = que.top();
		que.pop();
		
		int v = p.second;
		
		if(d[v] < p.first){
			continue;
		}
		
		for(int i = 0; i < G[v].size(); i++){
			edge e = G[v][i];
			if(d[e.to] > e.cost + d[v]){
				d[e.to] = d[v] + e.cost;
				que.push(P(d[e.to], e.to));
			}
		} // ????????????????°???????????????´??°
	}
}

int main(){
	
	int W, H;
	
	int map[200][200];
	
	while(true){
		cin >> W >> H;
		
		if(cin.eof()){
			break;
		}
		
		for(int i = 0; i < 200; i++){
			for(int j = 0; j < 200; j++){
				map[i][j] = 0;
			}
		}
		
		for(int i = 1; i <= H; i++){
			for(int j = 1; j <= W; j++){
				cin >> map[j][i];
			}
		}
		
		for(int i = 0; i < MAX_V; i++){
			G[i].erase(G[i].begin(), G[i].end());
		}
		
		for(int i = 0; i < 150; i++){
			for(int j = 0; j < 150; j++){
				if(map[i][j] == map[i + 1][j]){
					int index1 = i + j * 200;
					int index2 = i + 1 + j * 200;
					edge e1, e2;
					e1.cost = 0;
					e2.cost = 0;
					e1.to = index2;
					e2.to = index1;
					G[index1].push_back(e1);
					G[index2].push_back(e2);
				}
				if(map[i][j] == map[i][j + 1]){
					int index1 = i + j * 200;
					int index2 = i + (j + 1) * 200;
					edge e1, e2;
					e1.cost = 0;
					e2.cost = 0;
					e1.to = index2;
					e2.to = index1;
					G[index1].push_back(e1);
					G[index2].push_back(e2);
				}
				
				if(j % 2 == 0){
					if(i >= 1 && map[i][j] == map[i - 1][j + 1]){
						int index1 = i + j * 200;
						int index2 = i - 1 + (j + 1) * 200;
						edge e1, e2;
						e1.cost = 0;
						e2.cost = 0;
						e1.to = index2;
						e2.to = index1;
						G[index1].push_back(e1);
						G[index2].push_back(e2);
					}
				}else{
					if(map[i][j] == map[i + 1][j + 1]){
						int index1 = i + j * 200;
						int index2 = i + 1 + (j + 1) * 200;
						edge e1, e2;
						e1.cost = 0;
						e2.cost = 0;
						e1.to = index2;
						e2.to = index1;
						G[index1].push_back(e1);
						G[index2].push_back(e2);
					}
				}
				
			}
		}
		
		shortest_path(0, 40000);
		
		int ans = 0;
		
		for(int i = 0; i < 150; i++){
			for(int j = 0; j < 150; j++){
				if(d[i + j * 200] != d[i + 1 + j * 200]){
					ans++;
				}
				if(d[i + j * 200] != d[i + (j + 1) * 200]){
					ans++;
				}
				
				if(j % 2 == 0){
					if(i >= 1 && d[i + j * 200] != d[i - 1 + (j + 1) * 200]){
						ans++;
					}
				}else{
					if(d[i + j * 200] != d[i + 1 + (j + 1) * 200]){
						ans++;
					}
				}
				
			}
		}
		
		/*
		for(int i = 0; i <= H + 1; i++){
			for(int j = 0; j <= W + 1; j++){
				cout << d[i * 200 + j] << " ";
			}
			cout << endl;
		}
		*/
		cout << ans << endl;
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6272
final_rank: 18

code_snippet: #include<bits/stdc++.h>
using namespace std;
int w,h,mp[101][101];
int dy[6]={-1,-1,0,0,1,1};
int dx[2][6]={
  {0,1,-1,1,0,1},
  {-1,0,-1,1,-1,0}
};
 
 
int used[101][101];
int mark(int y,int x){
  if(x<0||y<0||x>=w||y>=h)return 0;
  if(mp[y][x]||used[y][x]++)return 1;
 
  int res=1;
  for(int i=0;i<6&&res;i++){
    int nx=x+dx[y%2][i],ny=y+dy[i];    
    res*=mark(ny,nx);
  }
  return res;
}
 
int main(){
  cin>>w>>h;
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++)cin>>mp[i][j];
   
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++){
      memset(used,0,sizeof(used));
      if(!mp[i][j])mp[i][j]=mark(i,j);
    } 
 
  int ans=0;
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++){
      int cnt=6;
      if(!mp[i][j])continue;
      for(int k=0;k<6;k++){
    int nx=j+dx[i%2][k],ny=i+dy[k];
    if(nx<0||ny<0||nx>=w||ny>=h) continue;
    cnt-=mp[ny][nx];
      }
      ans+=cnt;
    }
  cout <<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 420
memory_kb: 1468
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
int w,h,mp[101][101];
int dy[6]={-1,-1,0,0,1,1};
int dx[2][6]={
  {0,1,-1,1,0,1},
  {-1,0,-1,1,-1,0}
};


int used[101][101];
int mark(int y,int x){
  if(x<0||y<0||x>=w||y>=h)return 0;
  if(mp[y][x]||used[y][x]++)return 1;

  int res=1;
  for(int i=0;i<6&&res;i++){
    int nx=x+dx[y%2][i],ny=y+dy[i];    
    res*=mark(ny,nx);
  }
  return res;
}

int main(){
  cin>>w>>h;
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++)cin>>mp[i][j];
  
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++){
      memset(used,0,sizeof(used));
      if(!mp[i][j])mp[i][j]=mark(i,j);
    } 

  int ans=0;
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++){
      int cnt=6;
      if(!mp[i][j])continue;
      for(int k=0;k<6;k++){
	int nx=j+dx[i%2][k],ny=i+dy[k];
	if(nx<0||ny<0||nx>=w||ny>=h) continue;
	cnt-=mp[ny][nx];
      }
      ans+=cnt;
    }
  cout <<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 420
memory_kb: 1472
final_rank: 9

code_snippet: #include<iostream>
#include<cstring>
using namespace std;
 
int main(){
    int n,m,a,b,x[110][110],y[110][110],sum=0;
    memset(x,0,sizeof(x));
    cin>>m>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>x[i][j];
        }
    }
    memset(y,0,sizeof(y));
	a=100;
	if(m==100){
		for(int i=1;i<=50;i++){
			if(x[2][i]==0){
				b++;
			}
		}
		if(b==50){
			a=10000;
		}
	}
    for(int i=1;i<=m;i++){
        if(x[1][i]==0){
            y[1][i]=1;
            for(int j=1;j<a;j++){
                for(int k=1;k<=n;k++){
                    for(int l=1;l<=m;l++){
                        if(x[k][l]==0 && y[k][l]==1){
                            if(x[k][l-1]==0){
                                y[k][l-1]=1;
                            }
                            if(x[k-1][l]==0){
                                y[k-1][l]=1;
                            }
                            if(k%2==0){
                                if(x[k-1][l-1]==0){
                                    y[k-1][l-1]=1;
                                }
                                if(x[k+1][l-1]==0){
                                    y[k+1][l-1]=1;
                                }
                            }
                            if(x[k][l+1]==0){
                                y[k][l+1]=1;
                            }
                            if(x[k+1][l]==0){
                                y[k+1][l]=1;
                            }
                            if(k%2==1){
                                if(x[k+1][l+1]==0){
                                    y[k+1][l+1]=1;
                                }
                                if(x[k-1][l+1]==0){
                                    y[k-1][l+1]=1;
                                }
                            }
                        }
                    }
                }
                sum=0;
            }
        }
    }
    for(int i=1;i<=m;i++){
        if(x[n][i]==0){
            y[n][i]=1;
            for(int j=1;j<a;j++){
                for(int k=1;k<=n;k++){
                    for(int l=1;l<=m;l++){
                        if(x[k][l]==0 && y[k][l]==1){
                            if(x[k][l-1]==0){
                                y[k][l-1]=1;
                            }
                            if(x[k-1][l]==0){
                                y[k-1][l]=1;
                            }
                            if(k%2==0){
                                if(x[k-1][l-1]==0){
                                    y[k-1][l-1]=1;
                                }
                                if(x[k+1][l-1]==0){
                                    y[k+1][l-1]=1;
                                }
                            }
                            if(x[k][l+1]==0){
                                y[k][l+1]=1;
                            }
                            if(x[k+1][l]==0){
                                y[k+1][l]=1;
                            }
                            if(k%2==1){
                                if(x[k+1][l+1]==0){
                                    y[k+1][l+1]=1;
                                }
                                if(x[k-1][l+1]==0){
                                    y[k-1][l+1]=1;
                                }
                            }
                        }
                    }
                }
                sum=0;
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(x[i][1]==0){
            y[i][1]=1;
            for(int j=1;j<a;j++){
                for(int k=1;k<=n;k++){
                    for(int l=1;l<=m;l++){
                        if(x[k][l]==0 && y[k][l]==1){
                            if(x[k][l-1]==0){
                                y[k][l-1]=1;
                            }
                            if(x[k-1][l]==0){
                                y[k-1][l]=1;
                            }
                            if(k%2==0){
                                if(x[k-1][l-1]==0){
                                    y[k-1][l-1]=1;
                                }
                                if(x[k+1][l-1]==0){
                                    y[k+1][l-1]=1;
                                }
                            }
                            if(x[k][l+1]==0){
                                y[k][l+1]=1;
                            }
                            if(x[k+1][l]==0){
                                y[k+1][l]=1;
                            }
                            if(k%2==1){
                                if(x[k+1][l+1]==0){
                                    y[k+1][l+1]=1;
                                }
                                if(x[k-1][l+1]==0){
                                    y[k-1][l+1]=1;
                                }
                            }
                        }
                    }
                }
                sum=0;
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(x[i][m]==0){
            y[i][m]=1;
            for(int j=1;j<a;j++){
                for(int k=1;k<=n;k++){
                    for(int l=1;l<=m;l++){
                        if(x[k][l]==0 && y[k][l]==1){
                            if(x[k][l-1]==0){
                                y[k][l-1]=1;
                            }
                            if(x[k-1][l]==0){
                                y[k-1][l]=1;
                            }
                            if(k%2==0){
                                if(x[k-1][l-1]==0){
                                    y[k-1][l-1]=1;
                                }
                                if(x[k+1][l-1]==0){
                                    y[k+1][l-1]=1;
                                }
                            }
                            if(x[k][l+1]==0){
                                y[k][l+1]=1;
                            }
                            if(x[k+1][l]==0){
                                y[k+1][l]=1;
                            }
                            if(k%2==1){
                                if(x[k+1][l+1]==0){
                                    y[k+1][l+1]=1;
                                }
                                if(x[k-1][l+1]==0){
                                    y[k-1][l+1]=1;
                                }
                            }
                        }
                    }
                }
                sum=0;
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(y[i][j]!=1){
                x[i][j]=1;
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(x[i][j]==1){
                if(x[i][j-1]==0){
                    sum++;
                }
                if(x[i][j+1]==0){
                    sum++;
                }
                if(x[i-1][j]==0){
                    sum++;
                }
                if(x[i+1][j]==0){
                    sum++;
                }
                if(i%2==0){
                    if(x[i-1][j-1]==0){
                        sum++;
                    }
                    if(x[i+1][j-1]==0){
                        sum++;
                    }
                }
                if(i%2==1){
                    if(x[i-1][j+1]==0){
                        sum++;
                    }
                    if(x[i+1][j+1]==0){
                        sum++;
                    }
                }
            }
        }
    }
    cout<<sum<<endl;
    return 0;
}
accuracy: 1
time_ms: 1040
memory_kb: 1268
final_rank: 15

code_snippet: #include<iostream>
#include<cstring>
using namespace std;

int main(){
	int n,m,x[110][110],y[110][110],sum=0;
	memset(x,0,sizeof(x));
	cin>>m>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>x[i][j];
		}
	}
	memset(y,0,sizeof(y));
	for(int i=1;i<=m;i++){
		if(x[1][i]==0){
			y[1][i]=1;
			for(int j=1;j<100;j++){
				for(int k=1;k<=n;k++){
					for(int l=1;l<=m;l++){
						if(x[k][l]==0 && y[k][l]==1){
							if(x[k][l-1]==0){
								y[k][l-1]=1;
							}
							if(x[k-1][l]==0){
								y[k-1][l]=1;
							}
							if(k%2==0){
								if(x[k-1][l-1]==0){
									y[k-1][l-1]=1;
								}
								if(x[k+1][l-1]==0){
									y[k+1][l-1]=1;
								}
							}
							if(x[k][l+1]==0){
								y[k][l+1]=1;
							}
							if(x[k+1][l]==0){
								y[k+1][l]=1;
							}
							if(k%2==1){
								if(x[k+1][l+1]==0){
									y[k+1][l+1]=1;
								}
								if(x[k-1][l+1]==0){
									y[k-1][l+1]=1;
								}
							}
						}
					}
				}
				sum=0;
			}
		}
	}
	for(int i=1;i<=m;i++){
		if(x[n][i]==0){
			y[n][i]=1;
			for(int j=1;j<100;j++){
				for(int k=1;k<=n;k++){
					for(int l=1;l<=m;l++){
						if(x[k][l]==0 && y[k][l]==1){
							if(x[k][l-1]==0){
								y[k][l-1]=1;
							}
							if(x[k-1][l]==0){
								y[k-1][l]=1;
							}
							if(k%2==0){
								if(x[k-1][l-1]==0){
									y[k-1][l-1]=1;
								}
								if(x[k+1][l-1]==0){
									y[k+1][l-1]=1;
								}
							}
							if(x[k][l+1]==0){
								y[k][l+1]=1;
							}
							if(x[k+1][l]==0){
								y[k+1][l]=1;
							}
							if(k%2==1){
								if(x[k+1][l+1]==0){
									y[k+1][l+1]=1;
								}
								if(x[k-1][l+1]==0){
									y[k-1][l+1]=1;
								}
							}
						}
					}
				}
				sum=0;
			}
		}
	}
	for(int i=1;i<=n;i++){
		if(x[i][1]==0){
			y[i][1]=1;
			for(int j=1;j<100;j++){
				for(int k=1;k<=n;k++){
					for(int l=1;l<=m;l++){
						if(x[k][l]==0 && y[k][l]==1){
							if(x[k][l-1]==0){
								y[k][l-1]=1;
							}
							if(x[k-1][l]==0){
								y[k-1][l]=1;
							}
							if(k%2==0){
								if(x[k-1][l-1]==0){
									y[k-1][l-1]=1;
								}
								if(x[k+1][l-1]==0){
									y[k+1][l-1]=1;
								}
							}
							if(x[k][l+1]==0){
								y[k][l+1]=1;
							}
							if(x[k+1][l]==0){
								y[k+1][l]=1;
							}
							if(k%2==1){
								if(x[k+1][l+1]==0){
									y[k+1][l+1]=1;
								}
								if(x[k-1][l+1]==0){
									y[k-1][l+1]=1;
								}
							}
						}
					}
				}
				sum=0;
			}
		}
	}
	for(int i=1;i<=n;i++){
		if(x[i][m]==0){
			y[i][m]=1;
			for(int j=1;j<100;j++){
				for(int k=1;k<=n;k++){
					for(int l=1;l<=m;l++){
						if(x[k][l]==0 && y[k][l]==1){
							if(x[k][l-1]==0){
								y[k][l-1]=1;
							}
							if(x[k-1][l]==0){
								y[k-1][l]=1;
							}
							if(k%2==0){
								if(x[k-1][l-1]==0){
									y[k-1][l-1]=1;
								}
								if(x[k+1][l-1]==0){
									y[k+1][l-1]=1;
								}
							}
							if(x[k][l+1]==0){
								y[k][l+1]=1;
							}
							if(x[k+1][l]==0){
								y[k+1][l]=1;
							}
							if(k%2==1){
								if(x[k+1][l+1]==0){
									y[k+1][l+1]=1;
								}
								if(x[k-1][l+1]==0){
									y[k-1][l+1]=1;
								}
							}
						}
					}
				}
				sum=0;
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(y[i][j]!=1){
				x[i][j]=1;
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(x[i][j]==1){
				if(x[i][j-1]==0){
					sum++;
				}
				if(x[i][j+1]==0){
					sum++;
				}
				if(x[i-1][j]==0){
					sum++;
				}
				if(x[i+1][j]==0){
					sum++;
				}
				if(i%2==0){
					if(x[i-1][j-1]==0){
						sum++;
					}
					if(x[i+1][j-1]==0){
						sum++;
					}
				}
				if(i%2==1){
					if(x[i-1][j+1]==0){
						sum++;
					}
					if(x[i+1][j+1]==0){
						sum++;
					}
				}
			}
		}
	}
	cout<<sum<<endl;
	return 0;
}
accuracy: 0.8
time_ms: 1060
memory_kb: 1264
final_rank: 20

code_snippet: #include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
typedef pair<int, int> P;
int W, H;
int X[102][102];
int dx1[6] = { -1, 0, 0, 1, 1, 1 };
int dy1[6] = { 0, -1, 1, -1, 0,1};
int dx2[6] = { -1, -1, -1, 0, 0, 1 };
int dy2[6] = { -1, 0, 1, -1, 1, 0 };
int main()
{
	scanf("%d%d", &W, &H);
	for (int i = 1; i <= H; i++){
		for (int j = 1; j <= W; j++){
			scanf("%d", &X[j][i]);
		}
	}
	
	for (int j = 1; j <= W; j++){
		for (int i = 1; i <= H; i++){
			if (X[j][i] == 0){
				bool F[102][102];
				for (int k = 0; k < 102; k++)for (int l = 0; l < 102; l++)F[k][l] = X[k][l]&1;
				priority_queue<P>que;
				que.push(make_pair(j,i));
				while (!que.empty()){
					P p = que.top(); que.pop();
					if (p.second == 0 || p.second == H + 1 || p.first == 0 || p.first == W + 1)goto aa;
					if (X[p.first][p.second]||F[p.first][p.second])continue;
					F[p.first][p.second] = true;
					if (p.second & 1){
						//if (i == 5 && j == 4)printf("%d %d\n", p.first, p.second);
						for (int k = 0; k < 6; k++){
							//if (i == 5 && j == 4)printf("%d %d %d\n", p.first + dx1[k], p.second + dy1[k], F[p.first+dx1[k]][p.second+dy1[k]]);


							if (!F[p.first + dx1[k]][p.second + dy1[k]]){
								que.push(make_pair(p.first + dx1[k], p.second + dy1[k]));
							}
						}
					}
					else{
						for (int k = 0; k < 6; k++){
							if (!F[p.first + dx2[k]][p.second + dy2[k]]){
								
								que.push(make_pair(p.first + dx2[k], p.second + dy2[k]));
							}
						}
					}
					//if (i == 5 && j == 4)printf("%d\n", que.size());
				}
				X[j][i] = 1; aa:;
			}
		}
	}
	
	int ans = 0;
	for (int i = 1; i <= W; i++){
		for (int j = 1; j <= H; j++){
			if (X[i][j] == 1){
				if (j & 1){
					for (int k = 0; k < 6; k++){
						if (!X[i + dx1[k]][j + dy1[k]])ans++;
					}
				}
				else{
					for (int k = 0; k < 6; k++){
						if (!X[i + dx2[k]][j + dy2[k]])ans++;
					}
				}
			}
		}
	}
	printf("%d\n", ans);
	return 0;
}
accuracy: 1
time_ms: 730
memory_kb: 1252
final_rank: 10

code_snippet: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <cstring>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;

#define rep(i,n) for(int i=0; i<n; i++)
#define FOR(i,s,n) for(int i=s; i<n; i++)
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;

int f[101][101];
int w, h;

int dx_even[] = {0, 1, -1, 1, 0, 1};
int dx_odd[]  = {-1, 0, -1, 1, -1, 0};
int dy[] = {-1, -1, 0, 0, 1, 1};

bool checked[101][101];
bool isFill[101][101];

bool check(int y, int x) {
	checked[y][x] = true;
	if(x==0 || y==0 || x+1==w || y+1==h) return false;
	rep(i, 6) {
		int ny = y + dy[i], nx = x + (y%2 ? dx_odd[i] : dx_even[i]);
		if( !checked[ny][nx] && f[ny][nx] == 0 && !check(ny,nx) ) {
			return false;
		}
	}
	return true;
}

int main() {
	cin >> w >> h;
	rep(y, h) {
		rep(x, w) {
			cin >> f[y][x];
		}
	}
	rep(y, h) {
		rep(x, w) {
			if( !f[y][x] && !checked[y][x] ) {
				memset(checked, 0, sizeof(checked));
				if( check(y,x) ) {
					rep(y, h) {
						rep(x, w) {
							if( checked[y][x] )	isFill[y][x] = true;
						}
					}
				}
			}
		}
	}
	rep(y, h) {
		rep(x, w) {
			if( isFill[y][x] ) f[y][x] = 1;
		}
	}
	ll cnt = 0;
	rep(y, h) {
		rep(x, w) {
			rep(i,6) {
				int ny = y + dy[i];
				int nx = x + (y%2 ? dx_odd[i] : dx_even[i]);
				bool oor = (nx<0 || w<=nx || ny<0 || h<=ny);
				if(f[y][x] && (oor || (!oor && f[ny][nx]==0))) {
					cnt++;
				}
			}
		}
	}
	cout << cnt << endl;
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1448
final_rank: 2

code_snippet: #include <iostream>

using namespace std;

int main(){
	int width, height, map[102][102], diff=1;
	cin >> width >> height;
	for (int i = 0; i <= width + 1; i++){
		map[height+1][i] = map[0][i] = -1;
	}
	for (int i = 0; i <= height + 1; i++){
		map[i][width+1] = map[i][0] = -1;
	}
	for (int i = 1; i <= height; i++){
		for (int j = 1; j <= width; j++){
			cin >> map[i][j];
		}
	}
	while (diff){
		diff = 0;
		for (int i = 1; i <= height; i++){
			for (int j = 1; j <= width; j++){
				if (!map[i][j]){
					if (i % 2){
						if (map[i - 1][j] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i - 1][j + 1] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i + 1][j] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i + 1][j + 1] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
					}
					else{
						if (map[i - 1][j - 1] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i - 1][j] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i + 1][j - 1] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
						else if (map[i + 1][j] == -1){
							map[i][j] = -1;
							diff++;
							continue;
						}
					}
					if (map[i][j - 1] == -1){
						map[i][j] = -1;
						diff++;
						continue;
					}
					else if (map[i][j + 1] == -1){
						map[i][j] = -1;
						diff++;
						continue;
					}
				}
			}
		}
	}
	int ans = 0;
	for (int i = 1; i <= height; i++){
		for (int j = 1; j <= width; j++){
			if (map[i][j] == 1){
				if (i % 2){
					if (map[i - 1][j] == -1){
						ans++;
					}
					if (map[i - 1][j + 1] == -1){
						ans++;
					}
					if (map[i + 1][j] == -1){
						ans++;
					}
					if (map[i + 1][j + 1] == -1){
						ans++;
					}
				}
				else{
					if (map[i - 1][j - 1] == -1){
						ans++;
					}
					if (map[i - 1][j] == -1){
						ans++;
					}
					if (map[i + 1][j - 1] == -1){
						ans++;
					}
					if (map[i + 1][j] == -1){
						ans++;
					}
				}
				if (map[i][j - 1] == -1){
					ans++;
				}
				if (map[i][j + 1] == -1){
					ans++;
				}
			}
		}
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 1200
final_rank: 1

code_snippet: #include<iostream>
#include<cstring>
#include<queue>
#include<map>
using namespace std;
int I,J,x,y,mas[110][110]={{0}};
int dy[6]={-1,-1, 0, 0, 1, 1};
int dx_k[6]={ 0, 1,-1, 1, 0, 1};
int dx_g[6]={-1, 0,-1, 1,-1, 0};
int d[110][110];
int wall=0;
long long int wall_len=0;
typedef pair<int,int>P;
int bfs();
int wall_reck(int,int);
int main(){
  cin >> x >> y;
  for(int i=1;i<y+1;i++){
    for(int j=1;j<x+1;j++){
      cin >> mas[i][j];
    }
  }
 
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      if(mas[i][j]==0){
    if(i==0 || j==0 || i==y+1 || j==x+1){
      wall_reck(i,j);
    }
    else{
      I=i;
      J=j;
      bfs();
      //帰ってきた値が1（つまり、抜けられた）、または範囲外（必ず１）なら、周り(六方)の壁の数を計算。
      if(wall == 1){
        wall=0;
        wall_reck(i,j);
      }
    }
      }
    }
  }
  cout << wall_len << endl;
}
 
int bfs(){
  queue<P>que;
  memset(d,-1,sizeof(d));
  que.push(P(I,J));
  d[I][J] = 0;
  while(!que.empty()){
    P p = que.front();
    que.pop();
    //外につながったか。
    if(p.first==0 || p.second==0 || p.first==y+1 || p.second==x+1){
      wall=1;
      break;
    }
    for(int i=0;i<6;i++){
      int ny,nx;
    ny=p.first+dy[i];
      if(!(p.first&1)){
    nx=p.second+dx_g[i];
      }
      else{
    nx=p.second+dx_k[i];
      }
      if(mas[ny][nx]==0 && d[ny][nx]==-1){
    que.push(P(ny,nx));
    d[ny][nx]=d[p.first][p.second]+1;
      }
    }
 
  }
}
 
int wall_reck(int i,int j){
  for(int k=0;k<6;k++){
    if(!(i&1)){
      if(mas[i+dy[k]][j+dx_g[k]]==1){
    wall_len++;
      }
    }
    else{
      if(mas[i+dy[k]][j+dx_k[k]]==1){
    wall_len++;
      }
    }
 
  }
}
accuracy: 1
time_ms: 280
memory_kb: 1312
final_rank: 3

code_snippet: #include<iostream>
#include<cstring>
#include<queue>
#include<map>
using namespace std;
int I,J,x,y,mas[110][110]={{0}};
int dy[6]={-1,-1, 0, 0, 1, 1};
int dx_k[6]={ 0, 1,-1, 1, 0, 1};
int dx_g[6]={-1, 0,-1, 1,-1, 0};
int d[110][110];
int wall=0;
long long int wall_len=0;
typedef pair<int,int>P;
int bfs();
int wall_reck(int,int);
int main(){
  cin >> x >> y;

  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      mas[i][j]=0;
    }
  }

  for(int i=1;i<y+1;i++){
    for(int j=1;j<x+1;j++){
      cin >> mas[i][j];
    }
  }
 
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      if(mas[i][j]==0){
    if(i==0 || j==0 || i==y+1 || j==x+1){
      wall_reck(i,j);
    }
    else{
      I=i;
      J=j;
      bfs();
      //帰ってきた値が1（つまり、抜けられた）、または範囲外（必ず１）なら、周り(六方)の壁の数を計算。
      if(wall == 1){
        wall=0;
        wall_reck(i,j);
      }
    }
      }
    }
  }
  cout << wall_len << endl;
}
 
int bfs(){
  queue<P>que;
  memset(d,-1,sizeof(d));
  que.push(P(I,J));
  d[I][J] = 0;
  while(!que.empty()){
    P p = que.front();
    que.pop();
    //外につながったか。
    if(p.first==0 || p.second==0 || p.first==y+1 || p.second==x+1){
      wall=1;
      break;
    }
    for(int i=0;i<6;i++){
      int ny,nx;
    ny=p.first+dy[i];
      if(!(p.first&1)){
    nx=p.second+dx_g[i];
      }
      else{
    nx=p.second+dx_k[i];
      }
      if(mas[ny][nx]==0 && d[ny][nx]==-1){
    que.push(P(ny,nx));
    d[ny][nx]=d[p.first][p.second]+1;
      }
    }
 
  }
}
 
int wall_reck(int i,int j){
  for(int k=0;k<6;k++){
    if(!(i&1)){
      if(mas[i+dy[k]][j+dx_g[k]]==1){
    wall_len++;
      }
    }
    else{
      if(mas[i+dy[k]][j+dx_k[k]]==1){
    wall_len++;
      }
    }
 
  }
}
accuracy: 1
time_ms: 280
memory_kb: 1312
final_rank: 3

code_snippet: #include<iostream>
#include<cstring>
#include<queue>
#include<map>
using namespace std;
int I,J,x,y,mas[110][110]={{0}};
int dy_k[6]={-1,-1, 0, 0, 1, 1};
int dx_k[6]={ 0, 1,-1, 1, 0, 1};
int dy_g[6]={-1,-1, 0, 0, 1, 1};
int dx_g[6]={-1, 0,-1, 1,-1, 0};
int d[110][110];
int wall=0;
long long int wall_len=0;
typedef pair<int,int>P;
int bfs();
int wall_reck(int,int);
int main(){
  cin >> x >> y;
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      mas[i][j]=0;
    }
  }
 
  for(int i=1;i<y+1;i++){
    for(int j=1;j<x+1;j++){
      cin >> mas[i][j];
    }
  }
 
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      if(mas[i][j]==0){
    if(i==0 || j==0 || i==y+1 || j==x+1){
      wall_reck(i,j);
    }
    else{
      I=i;
      J=j;
      bfs();
      //帰ってきた値が1（つまり、抜けられた）、または範囲外（必ず１）なら、周り(六方)の壁の数を計算。
      if(wall == 1){
        wall=0;
        wall_reck(i,j);
      }
    }
       
  
 
      }
    }
  }
  cout << wall_len << endl;
}
 
int bfs(){
  queue<P>que;
  memset(d,-1,sizeof(d));
  que.push(P(I,J));
  d[I][J] = 0;
  while(!que.empty()){
    P p = que.front();
    que.pop();
    //外につながったか。
    if(p.first==0 || p.second==0 || p.first==y+1 || p.second==x+1){
      wall=1;
      break;
    }
    for(int i=0;i<6;i++){
      int ny,nx;
      if(!(p.first&1)){
    ny=p.first+dy_g[i];
    nx=p.second+dx_g[i];
      }
      else{
    ny=p.first+dy_k[i];
    nx=p.second+dx_k[i];
      }
      if(mas[ny][nx]==0 && d[ny][nx]==-1){
    que.push(P(ny,nx));
    d[ny][nx]=d[p.first][p.second]+1;
      }
    }
 
  }
}
 
int wall_reck(int i,int j){
  for(int k=0;k<6;k++){
    if(!(i&1)){
      if(mas[i+dy_g[k]][j+dx_g[k]]==1){
    wall_len++;
      }
    }
    else{
      if(mas[i+dy_k[k]][j+dx_k[k]]==1){
    wall_len++;
      }
    }
 
  }
}
accuracy: 1
time_ms: 290
memory_kb: 1316
final_rank: 6

code_snippet: #include<iostream>
#include<cstring>
#include<queue>
#include<map>
using namespace std;
int I,J,x,y,mas[110][110]={{0}};
int dy_k[6]={-1,-1, 0, 0, 1, 1};
int dx_k[6]={ 0, 1,-1, 1, 0, 1};
int dy_g[6]={-1,-1, 0, 0, 1, 1};
int dx_g[6]={-1, 0,-1, 1,-1, 0};
int d[110][110];
int wall=0;
long long int wall_len=0;
typedef pair<int,int>P;
int bfs();
int wall_reck(int,int);
int main(){
  cin >> x >> y;
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      mas[i][j]=0;
    }
  }

  for(int i=1;i<y+1;i++){
    for(int j=1;j<x+1;j++){
      cin >> mas[i][j];
    }
  }

  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      if(mas[i][j]==0){
	if(i==0 || j==0 || i==y+1 || j==x+1){
	  wall_reck(i,j);
	}
	else{
	  I=i;
	  J=j;
	  bfs();
	  //帰ってきた値が1（つまり、抜けられた）、または範囲外（必ず１）なら、周り(六方)の壁の数を計算。
	  if(wall == 1){
	    wall=0;
	    wall_reck(i,j);
	  }
	}
	  
 

      }
    }
  }
  cout << wall_len << endl;
}

int bfs(){
  queue<P>que;
  memset(d,-1,sizeof(d));
  que.push(P(I,J));
  d[I][J] = 0;
  while(!que.empty()){
    P p = que.front();
    que.pop();
    //外につながったか。
    if(p.first==0 || p.second==0 || p.first==y+1 || p.second==x+1){
      wall=1;
      break;
    }
    for(int i=0;i<6;i++){
      int ny,nx;
      if(!(p.first&1)){
	ny=p.first+dy_g[i];
	nx=p.second+dx_g[i];
      }
      else{
	ny=p.first+dy_k[i];
	nx=p.second+dx_k[i];
      }
      if(mas[ny][nx]==0 && d[ny][nx]==-1){
	que.push(P(ny,nx));
	d[ny][nx]=d[p.first][p.second]+1;
      }
    }

  }
}

int wall_reck(int i,int j){
  for(int k=0;k<6;k++){
    if(!(i&1)){
      if(mas[i+dy_g[k]][j+dx_g[k]]==1){
	wall_len++;
      }
    }
    else{
      if(mas[i+dy_k[k]][j+dx_k[k]]==1){
	wall_len++;
      }
    }

  }
}
accuracy: 1
time_ms: 290
memory_kb: 1308
final_rank: 5

code_snippet: #include<iostream>
#include<cstring>
#include<queue>
#include<map>
using namespace std;
int I,J,x,y,mas[110][110]={{0}};
int dy_k[6]={-1,-1, 0, 0, 1, 1};
int dx_k[6]={ 0, 1,-1, 1, 0, 1};
int dy_g[6]={-1,-1, 0, 0, 1, 1};
int dx_g[6]={-1, 0,-1, 1,-1, 0};
int d[110][110];
int wall=0;
long long int wall_len=0;
typedef pair<int,int>P;
int bfs();
int wall_reck(int,int);
int main(){
  cin >> x >> y;
  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      mas[i][j]=0;
    }
  }

  for(int i=1;i<y+1;i++){
    for(int j=1;j<x+1;j++){
      cin >> mas[i][j];
    }
  }

  for(int i=0;i<y+2;i++){
    for(int j=0;j<x+2;j++){
      if(mas[i][j]==0){
	if(i==0 || j==0 || i==y+1 || j==x+1){
	  wall_reck(i,j);
	}
	else{
	  I=i;
	  J=j;
	  bfs();
	  //帰ってきた値が1（つまり、抜けられた）、または範囲外（必ず１）なら、周り(六方)の壁の数を計算。
	  if(wall == 1){
	    wall=0;
	    wall_reck(i,j);
	  }
	}
	  
 

      }
    }
  }
  cout << wall_len << endl;
}

int bfs(){
  queue<P>que;
  memset(d,-1,sizeof(d));
  que.push(P(I,J));
  d[I][J] = 0;
  while(!que.empty()){
    P p = que.front();
    que.pop();
    //外につながったか。
    if(p.first==0 || p.second==0 || p.first==y+1 || p.second==x+1){
      wall=1;
      break;
    }
    for(int i=0;i<6;i++){
      int ny,nx;
      if(p.first%2==0){
	ny=p.first+dy_g[i];
	nx=p.second+dx_g[i];
      }
      else{
	ny=p.first+dy_k[i];
	nx=p.second+dx_k[i];
      }
      if(mas[ny][nx]==0 && d[ny][nx]==-1){
	que.push(P(ny,nx));
	d[ny][nx]=d[p.first][p.second]+1;
      }
    }

  }
}

int wall_reck(int i,int j){
  for(int k=0;k<6;k++){

    if(i%2==0){
      if(mas[i+dy_g[k]][j+dx_g[k]]==1){
	wall_len++;
      }
    }
    else{
      if(mas[i+dy_k[k]][j+dx_k[k]]==1){
	wall_len++;
      }
    }

  }
}
accuracy: 1
time_ms: 290
memory_kb: 1316
final_rank: 6

code_snippet: #include<iostream>
using namespace std;
bool F[102][102];
int A[102][102]={0},W,H;
int ww[2][6]={{-1,0,-1,1,-1,0},{0,1,-1,1,0,1}},hh[6]={-1,-1,0,0,1,1};

int init(){
	for(int i=0;i<102;i++)for(int j=0;j<102;j++)F[i][j]=false;
	return 1;
}

int color(int w,int h,int k){
	if(w==0||w>W||h==0||h>H)return 1;
	if(k==0)k=init();
	if(F[w][h])return 0;
	int ret=0;
	F[w][h]=true;
	if(A[w][h]==1)return ret;
	for(int i=0;i<6;i++){
		ret+=color(w+ww[h%2][i],h+hh[i],k);
	}
	return ret;
}

int main(){
	int ans=0;
	scanf("%d%d",&W,&H);
	for(int i=1;i<=H;i++)for(int j=1;j<=W;j++)scanf("%d",&A[j][i]);
	for(int i=1;i<=W;i++)for(int j=1;j<=H;j++){
		if(A[i][j]==0){
			int s=color(i,j,0);
			if(s==0)A[i][j]++;
		}
	}
	for(int i=1;i<=W;i++)for(int j=1;j<=H;j++){
		if(A[i][j]==1){
			for(int k=0;k<6;k++){
				if(A[i+ww[j%2][k]][j+hh[k]]==0){ans++; /*printf("(%d,%d),(%d,%d)\n",i,j,i+ww[j%2][k],j+hh[k]);*/}
			}
		}
	}
	printf("%d\n",ans);
}
accuracy: 1
time_ms: 2210
memory_kb: 1660
final_rank: 19