数列转换(nyoj 109)

题目：点击打开链接

这题以上来我就是广搜，然后用字典树判重，写的时候就担心会超内存，结果就真的超了…………然后就没辙了……

这题用到守恒定律，看了别人讲的很好理解。

下面部分摘自：这里这里这里

我们分析一下这个题目。
操作是有先后顺序之分的。比如先对a2操作，再操作a3；先对a3操作，再
操作a2，结果就有天壤之别。
观察Sample：
(1 6 9 4 2 0)à(1 6 13 -4 6 0)à
(1 6 13 2 -6 6)à(7 -6 19 2 -6 6)
数字杂乱无章没有规律。仔细观察一下操作规则：
(a_i-1, a_i, a_i+1)à(a_i-1+a_i, -a_i, a_i+a_i+1)
直观的看，相当于把中间的数分别加到两边去，然后取反。容易发现，操作
前后的总和是不变的！
我们可能很激动的猜想：只要两个序列和相等，他们就能通过操作互达。
但是第二个sample 很快否定了这个想法：(1 2 3), (1 3 2)是不可达的。
因为(1 2 3)能进行的操作仅仅是：(3 -2 5)，再进行一次操作回到(1 2 3)。所
以永远不能变成(1 3 2)。
总和虽然不行，我们可以试着考察局部和,(即前n项和)。
(a_i-1, a_i, a_i+1) (a_i-1+a_i, -a_i, a_i+a_i+1)
S1=a_i-1 S1’=a_i-1+a_i
S2=a_i-1+ai S2’=a_i-1
S3=a_i-1+a_i+a_i+1 S3’=a_i-1+a_i+a_i+1
很容易看出S3=S3’，(S1,S2)=(S2’,S1’)。也就是说把(S1,S2,S3)中的S1和S2交换
位置就能得到(S1’,S2’,S3’)。
稍微推广一下：设Si=a1+a2+…+ai，对(a_i-1, a_i, a_i+1)操作本质上和交换S_i-1, Si
是等价的。（因为S_{i-2^{是固定不变的}}）
比如第一个Sample：
(1 6 9 4 2 0)à(1 6 13 -4 6 0)à
(1 6 13 2 -6 6)à(7 -6 19 2 -6 6)
转化成和之后：
(1 7 16 20 22 22)à(1 7 20 16 22 22)à
(1 7 20 22 16 22)à(7 1 20 22 16 22)

(加粗的是交换的两个数)
比如第二个Sample:
(1 2 3)àS(1 3 6)
(1 3 2)àS(1 4 6)
对(1 2 3)的操作实质上是不断的交换S(1 3 6)中的1, 3。无论如何也不可
能变成(1 4 6)，因为4 根本没在S(1 3 6)中出现过！
另外还有一点，参与交换的只有S1~Sn-1，Sn是雷打不动的。所以我们算法出
来了：
1、判断Sn是否相等。
2、判断{S1, S2 ,…, Sn-1}是否相等。
O(nlogn)的时间复杂度（排序复杂度）。
一个看似繁琐的题目被很轻松的解决了。
如上文所言，操作的变化过程是纷繁复杂的，可以说没任何规律。如果从
每一次操作对总体的贡献入手研究，会碰得头破血流。
但是我们把原来的数列进行了一个小小的转化：求和。正是这个求和，使得
操作的本质浮出水面，操作由令人头晕目眩的(ai-1, ai, ai+1)à(ai-1+ai, -ai, ai+ai+1)、
变成了简单的“交换Si-1和Si”。
这是一个应用守恒的经典例子。其中的守恒量是{S1,S2, …,Sn-1}，这个集合始
终保持不变，不会有新的元素生成、也不会无缘无故有元素消失；有的只是顺序
上的交换。
抛开琐碎的细节，我们抓住了本质。
为什么会想到求和呢？
因为(ai-1, ai, ai+1)à(ai-1+ai, -ai, ai+ai+1)的结构很容易让人发现它的总和守恒；进
一步联想到局部和。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int a[1100], b[1100];

int cmp(const void *a, const void *b)
{
	return (*(int *)a - *(int *)b);
}

int main (void)
{
	int n;
	scanf("%d", &n);
	while(n --)
	{
		int m, i;
		scanf("%d", &m);
		for(i = 0; i < m; i++)
			scanf("%d", &a[i]);
		for(i = 0; i < m; i++)
			scanf("%d", &b[i]);
		
		for(i = 1; i < m; i++)
		{
			a[i] += a[i - 1];
			b[i] += b[i - 1]; 
		}
		qsort(a, m , sizeof(a[0]), cmp);
		qsort(b, m, sizeof(b[0]), cmp);
		int f = 0;
		for(i = 0; i < m; i++)
		{
			if(a[i] != b[i])
			{
				f = 1;
				break;
			}
		}
		if(f == 1)
			printf("No\n");
		else
			printf("Yes\n");
		
	}
	return 0;
}

广搜超内存代码：

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

struct node
{
	int s[1010];
};
struct tree
{
	int i;
	tree* next[2010];
	tree()
	{
		for(i = 0; i < 2010; i++)
			next[i] = NULL;
	}	
};
queue <node> q;
node start, end;
int n;


int vis(tree* head, node e)
{
	tree * temp = head;
	int i;
	int t, ok = 1;
	for(i = 0; i < n; i++)
	{
		t = e.s[i] + 1000;
		if(temp ->next[t] == NULL)
		{
			ok = 0;
			tree *x = new tree;
			temp->next[t] = x;
		}
		temp = temp ->next[t];
	}
	return ok;
}

int cmp(int a[], int b[])
{
	int i;
	for(i = 0; i < n; i++)
	{
		if(a[i] != b[i])
			return 0;
	}	
	return 1;
}

int bfs()
{
	tree * head = new tree;
	int i;
	q.push(start);
	int ok = vis(head, start);
	while(!q.empty())
	{
		node e = q.front();
		q.pop();
		for(i = 1; i < n - 1; i++)
		{
			node e1 = e;
			e1.s[i - 1] = (e1.s[i]) + (e1.s[i - 1]);
			e1.s[i + 1] = (e1.s[i]) + (e1.s[i + 1]);
			e1.s[i] = -(e1.s[i]);
			if(vis(head, e1) == 0)
			{
				if(cmp(e1.s, end.s) == 1)
					return 1;
				q.push(e1);
			} 
		}	
	}
	return 0;
}

int main (void)
{
	int t;
	scanf("%d", &t);
	while(t --)
	{
		int i;
		while(!q.empty())
			q.pop();
		scanf("%d", &n);
		for(i = 0; i < n; i++)
			scanf("%d", &start.s[i]);
		for(i = 0; i < n; i ++)
			scanf("%d", &end.s[i]);
		if(bfs() == 1)
			printf("Yes\n");
		else
			printf("No\n");
	}
	return 0;
}