SDU_Week4_可怕的宇宙射线（图论+记忆化剪枝）

题目描述

众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天 生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁 人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的 左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂 次，每次分裂后会在分裂方向前进 个单位长度。 现在瑞神要带着他的小弟们挑战苟狗，但是瑞神不想让自己的智商降到普通本科生 那么菜的水平，所以瑞神来请求你帮他计算出共有多 少个位置会被"降智打击"。

输入描述

输入第一行包含一个正整数 ，表示宇宙射线会分裂 次 第二行包含n个正整数 ，第 个数 表示第 次分裂的宇宙射线会在它原方向上继续走多少个单位长度。

输出描述

输出一个数 ，表示有多少个位置会被降智打击

样例输入

4
4 2 2 3

样例输出

39

数据点说明

数据点	n
10%	<=10
40%	<=20
100%	<=30

样例解释

下图描绘了样例中宇宙射线分裂的全过程，仅做参考。

题目分析

这道题是图论搜索递归问题，可谓是花费了我两个晚上时间优化，说到底还是能力太差，亟待提高。下面分5阶段总结这个题目。

一、pair数据结构

pair数据结构存在于奇怪头文件——#include <utility>这个头文件加进去之后，在第一次提交的时候，CE了。。。这在CSP考试中可是大忌！所以以后需要数对的地方就用srtuct结构体，或者直接开二维数组，不要用pair。

二、声明

编译声明不是随便加的，一股脑把所有声明都加进去必定gg。先编译的函数不能放在声明里，而在先编译的函数里用到的函数（且未出现）一定要声明。

三、重复记录

修改后本题在test3的地方wa了，经过测试，某些数据得出的答案比正确答案多1，画图发现，是一开始那条线直接加上步长了，没有判断是否被标记。所有要记住图论问题在每个需要修改答案的地方都要检查标记。

四、记忆化剪枝

修改过后，在test6的地方T掉了。所以开始优化，考虑到二维图论问题，常用记忆化剪枝，本题开辟四维数组，分别记录x，y，方向，递归层数。四维数组的选取规则是记录唯一的某种状态，从而避免后继者重复无用功。
然而第一次剪枝时记录了X，Y，方向，步长，误认为这四个参数可以唯一标记一种状态，殊不知可以在当前状态相同，但之后的步长不同导致状态不同！只有记录递归层数才可以唯一标记某种状态。这个问题找了一晚上没看出来，逻辑上出大问题，一定要长记性。

代码

#define _CRT_SECURE_NO_WARNINGS
#define _ ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)

#include<iostream>
#include<string>
#include<string.h>
#include<cmath>
#include<algorithm>

using namespace std;

bool map[500][500];
int step[31];
int n;
int ans = 0;

//3.0 test6 T掉了，新增剪枝操作(记忆化剪枝)
//bool cut[500][500][9][6];//X，Y，方向，步长,方向从up开始逆时针排序
bool cut[500][500][9][31];//4.0 剪完枝WA了一晚上，后来发现自己智障了，逻辑上严重失误，因为相同姿态走相同步长只能保证当此路径一样，而后路径不一定，四维数组应该记录层数

//1.0 一定要看编译顺序添加声明！长记性！
void upleft(int time, int a, int x, int y);
void upright(int time, int a, int x, int y);
void downleft(int time, int a, int x, int y);
void downright(int time, int a, int x, int y);

//4.0调整return和标记的顺序，逻辑上更通顺
void up(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][1][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x - i][y + i] != true) {
			map[x - i][y + i] = true;
			ans++;
		}
		if (map[x + i][y + i] != true) {
			map[x + i][y + i] = true;
			ans++;
		}
	}
	if (cut[x - a][y + a][2][time] != true) {
		upleft(time, step[time], x - a, y + a);
//		cut[x - a][y + a][2][step[time]] = true;
	}
	if (cut[x + a][y + a][8][time] != true) {
		upright(time, step[time], x + a, y + a);
//		cut[x + a][y + a][8][step[time]] = true;
	}
}

void down(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][5][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x - i][y - i] != true) {
			map[x - i][y - i] = true;
			ans++;
		}
		if (map[x + i][y - i] != true) {
			map[x + i][y - i] = true;
			ans++;
		}
	}
	if (cut[x - a][y - a][4][time] != true) {
		downleft(time, step[time], x - a, y - a);
//		cut[x - a][y - a][4][step[time]] = true;
	}
	if (cut[x + a][y - a][6][time] != true) {
		downright(time, step[time], x + a, y - a);
//		cut[x + a][y - a][6][step[time]] = true;
	}
}

void left(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][3][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x - i][y - i] != true) {
			map[x - i][y - i] = true;
			ans++;
		}
		if (map[x - i][y + i] != true) {
			map[x - i][y + i] = true;
			ans++;
		}
	}
	if (cut[x - a][y + a][2][time] != true) {
		upleft(time, step[time], x - a, y + a);
//		cut[x - a][y + a][2][step[time]] = true;
	}
	if (cut[x - a][y - a][4][time] != true) {
		downleft(time, step[time], x - a, y - a);
//		cut[x - a][y - a][4][step[time]] = true;
	}
}

void right(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][7][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x + i][y - i] != true) {
			map[x + i][y - i] = true;
			ans++;
		}
		if (map[x + i][y + i] != true) {
			map[x + i][y + i] = true;
			ans++;
		}
	}
	if (cut[x + a][y + a][8][time] != true) {
		upright(time, step[time], x + a, y + a);
//		cut[x + a][y + a][8][step[time]] = true;
	}
	if (cut[x + a][y - a][6][time] != true) {
		downright(time, step[time], x + a, y - a);
//		cut[x + a][y - a][6][step[time]] = true;
	}
}

void upleft(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][2][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x - i][y] != true) {
			map[x - i][y] = true;
			ans++;
		}
		if (map[x][y + i] != true) {
			map[x][y + i] = true;
			ans++;
		}
	}
	if (cut[x - a][y][3][time] != true) {
		left(time, step[time], x - a, y);
//		cut[x - a][y][3][step[time]] = true;
	}
	if (cut[x][y + a][1][time] != true) {
		up(time, step[time], x, y + a);
//		cut[x][y + a][1][step[time]] = true;
	}
}

void upright(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][8][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x][y + i] != true) {
			map[x][y + i] = true;
			ans++;
		}
		if (map[x + i][y] != true) {
			map[x + i][y] = true;
			ans++;
		}
	}
	if (cut[x][y + a][1][time] != true) {
		up(time, step[time], x, y + a);
//		cut[x][y + a][1][step[time]] = true;
	}
	if (cut[x+a][y][7][time] != true) {
		right(time, step[time], x + a, y);
//		cut[x +a][y][7][step[time]] = true;
	}
}

void downleft(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][4][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x - i][y] != true) {
			map[x - i][y] = true;
			ans++;
		}
		if (map[x][y - i] != true) {
			map[x][y - i] = true;
			ans++;
		}
	}
	if (cut[x - a][y][3][time] != true) {
		left(time, step[time], x - a, y);
//		cut[x - a][y][3][step[time]] = true;
	}
	if (cut[x ][y-a][5][time] != true) {
		down(time, step[time], x, y - a);
//		cut[x][y - a][5][step[time]] = true;
	}
}

void downright(int time, int a, int x, int y) {
	if (time > n)return;
	cut[x][y][6][time] = true;

	time++;
	for (int i = 1; i <= a; i++)
	{
		if (map[x + i][y] != true) {
			map[x + i][y] = true;
			ans++;
		}
		if (map[x][y - i] != true) {
			map[x][y - i] = true;
			ans++;
		}
	}
	if (cut[x + a][y][7][time] != true) {
		right(time, step[time], x + a, y);
//		cut[x + a][y][7][step[time]] = true;
	}
	if (cut[x][y - a][5][time] != true) {
		down(time, step[time], x, y - a);
//		cut[x][y - a][5][step[time]] = true;
	}
}

int main()
{
	memset(map, 0, sizeof(map));
	memset(step, 0, sizeof(step));
	memset(cut, 0, sizeof(cut));
	cin >> n;//分裂次数，真实分裂为n-1次
	for (int i = 1; i <= n; i++) {
		cin >> step[i];
	}

	int xstart = 250;
	int ystart = 250;
	for (int i = 0; i < step[1]; i++) {//2.0 之前全1情况从9开始出错，因为起始线被无条件加入了。
		if (map[xstart][ystart + i] != true) {
			map[xstart][ystart + i] = true; 
			ans++; //如果第一步的线上没被标记，ans++
		}
	}
	up(2, step[2], xstart, ystart+step[1]-1);
	cout << ans;
//	cout << ans + step[1];//加上第一次走的步数,*错误回顾*
	return 0;
}