codeforces contest750 New Year and Fireworks

原题链接：http://codeforces.com/contest/750/problem/D

D. New Year and Fireworks

time limit per test

2.5 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

One tradition of welcoming the New Year is launching fireworks into the sky. Usually a launched firework flies vertically upward for some period of time, then explodes, splitting into several parts flying in different directions. Sometimes those parts also explode after some period of time, splitting into even more parts, and so on.

Limak, who lives in an infinite grid, has a single firework. The behaviour of the firework is described with a recursion depth n and a duration for each level of recursion t1, t2, ..., tn. Once Limak launches the firework in some cell, the firework starts moving upward. After covering t1 cells (including the starting cell), it explodes and splits into two parts, each moving in the direction changed by 45 degrees (see the pictures below for clarification). So, one part moves in the top-left direction, while the other one moves in the top-right direction. Each part explodes again after covering t2 cells, splitting into two parts moving in directions again changed by 45 degrees. The process continues till the n-th level of recursion, when all 2n - 1 existing parts explode and disappear without creating new parts. After a few levels of recursion, it's possible that some parts will be at the same place and at the same time — it is allowed and such parts do not crash.

Before launching the firework, Limak must make sure that nobody stands in cells which will be visited at least once by the firework. Can you count the number of those cells?

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 30) — the total depth of the recursion.

The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 5). On the i-th level each of 2i - 1 parts will cover ti cells before exploding.

Output

Print one integer, denoting the number of cells which will be visited at least once by any part of the firework.

Examples

input

4
4 2 2 3

output

39

input

6
1 1 1 1 1 3

output

85

input

1
3

output

3

Note

For the first sample, the drawings below show the situation after each level of recursion. Limak launched the firework from the bottom-most red cell. It covered t1 = 4 cells (marked red), exploded and divided into two parts (their further movement is marked green). All explosions are marked with an 'X' character. On the last drawing, there are 4 red, 4 green, 8 orange and 23 pink cells. So, the total number of visited cells is 4 + 4 + 8 + 23 = 39.

For the second sample, the drawings below show the situation after levels 4, 5 and 6. The middle drawing shows directions of all parts that will move in the next level.

题意：已知烟花爆炸的次数N和每次爆炸前进的格数，求烟花在爆炸完成之后占领的全部格子。。

开始时烟花默认向上移动，每次爆炸之后，路径发生改变（以原来方向为准分别向左上和右上45度移动）。

又是一道记忆化搜索，加上方向的处理。

注意：每次移动必须一格一格的移动，保证走过的map所有节点全部标记，而且标记数组dp也必须记录每次前进的个数（开始时我没有记录），这样避免在向同一方向移动到同一格且爆炸的次数相同时看做重复的格子就不再执行了，实际上此时还要看前进格数forward。

题中没有给出范围，但是可以推得：每次移动不超过5格，爆炸不超过30次，所以移动半径在150内。。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>

int a[35];
int map[310][310];
bool dp[310][310][8][5][35];//对于赋值0和1标记时，最好用bool类型（占一个字节），int很容易超内存
int dir[8][2] = { -1, 0, -1, 1, 0, 1, 1, 1, 1, 0, 1, -1, 0, -1, -1, -1 };//向上开始，依次顺时针赋值
int n;

void dfs(int x, int y, int d, int forward, int cnt)//x,y：每次移动之后的坐标，d:每次移动的方向  forward:每次前进的格数  cnt:爆炸的次数
{
	int i;
	if (dp[x][y][d][forward][cnt])
		return;
	if (cnt == n)
		return;
	dp[x][y][d][forward][cnt] = 1;
	map[x][y] = 1;
	if (forward){
		dfs(x + dir[d][0], y + dir[d][1], d, forward - 1, cnt);
	}
	else//forward==0说明本次爆炸的路径已经走完了，又开始下一次爆炸（改变爆炸之后的方向、前进格数和爆炸次数）
	{
		dfs(x, y, (d - 1 + 8) % 8, a[cnt + 1], cnt + 1);
		dfs(x, y, (d + 1) % 8, a[cnt + 1], cnt + 1);
	}
}

int main()
{
	int i, j;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
		scanf("%d", &a[i]);
	dfs(150, 150, 0, a[0] - 1, 0);
	int ans = 0;
	for (i = 0; i <= 300; i++)
		for (j = 0; j <= 300; j++)
			if (map[i][j])
				ans++;
	printf("%d\n", ans);
	return 0;
}