算法提高 盾神与条状项链（静态链表）

试题 算法提高 盾神与条状项链

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
　　有一天，盾神捡到了好多好多五颜六色的珠子！他心想这些珠子这么漂亮，可以做成一条项链然后送给他心仪的女生~于是他用其中一些珠子做成了长度为n的项链。当他准备把项链首尾相接的时候，土方进来了。
　　“哇这么恶心的项链你也做得出来！！！”
　　盾神自知审美不是他的长项，于是他很谦虚地请教土方，怎么才能把项链做得漂亮。
　　“这个嘛~ 首先你要在这里加上一个这种颜色的珠子，然后在这里去掉这个珠子，然后……，最后你看看是不是漂亮很多咧~”土方一下子说出了m个修改步骤。
　　盾神觉得这个用人工做太麻烦了，于是交给了你。
输入格式
　　第一行两个数，分别为n，m。
　　第二行n个数，表示盾神一开始的项链。第i个数表示第i颗珠子的颜色。
　　接下来m行，为以下形式之一：
　　ADD P Q：表示在颜色为P的珠子前面加上一个颜色为Q的珠子。
　　DEL P：表示把颜色为P的珠子去掉，如果它不在端点处，则需要把它旁边的两颗珠子连起来。例如某时刻项链状态为1 4 5 8，则执行DEL 4会变成1 5 8，执行DEL 1会变成4 5 8。
　　输入保证在每次操作之前，项链有颜色为P的珠子，且任意时刻珠子颜色互不相同。
输出格式
　　第一行为一个数len，为做完所有操作后，项链的长度。
　　第二行len个数，表示此时项链的状态。第i个数表示第i颗珠子的颜色。
样例输入
10 5
1 2 3 4 5 6 7 8 9 10
DEL 5
ADD 7 5
DEL 10
ADD 4 20
ADD 20 12
样例输出
11
1 2 3 12 20 4 6 5 7 8 9
数据规模和约定
　　表示颜色的数字不超过10^ 5的正数，1<=n<=10^ 4，1<=m<=10^4。

题解

一开始使用动态链表来做，因为要不停的定位到珠子来进行增减操作，而链表只能从头尾遍历，这样实现效率很低，于是转向静态链表，题目说表示颜色的数字不超过10^ 5，之前又说每个颜色的珠子只有一个，所以开一个10^ 5大小的数组node[]来模拟，这个数组是一个结构体数组，存放其左右结点的编号，每次增加或者减少珠子就只要维护数组中的几个元素就行了。

ADD操作 比如要在 … a b… 中间插入c，只要:

node[a].right=c; node[c].left=a;
node[c].right=b; node[b].left=c;
*（如果要在串首增加元素，要特殊处理，详见下面代码）*

DEL操作 比如要在 … a b c … 删除b，只要:

node[a].right=c; node[c].left=a;
*如果要严谨一点，还要加上*
node[b].left=node[b].right=-1;

AC代码如下，有清晰的注释

//算法提高 盾神与条状项链 
#include<stdio.h>
#include<cstring>
using namespace std;

const int MAXN=1e5+1;
struct Node{
	int left,right;		//存储珠子左右的编号 
	Node(){left=right=-1;}
};
Node node[MAXN];

int main(){
	char q[5];
	int n,m;		//n个珠子，m次操作 
	int p=0,c;		//p-上一次珠子  c-当前珠子编号 
	int begin,len;	//begin-串开头的珠子  len-珠子的总数量 
	
	scanf("%d%d",&n,&m);
	len=n;				//开始的时候串长为n 
	for(int i=0;i<n;i++){
		scanf("%d",&c);
		if(i==0){		//当输入第一个珠子时，特殊处理 
			begin=c;
			p=c;
			continue;	
		}
		node[p].right=c;	//更改前一个珠子的右边（下一个）珠子的编号 
		node[c].left=p;		//更改当前珠子的左边（前一个）珠子的编号 
		p=c;				//更新p 
	}
	while(m--){
		scanf("%s",q);
		if(!strcmp(q,"ADD")){		//添加操作 
			len++;				//串长度加 1 
			int a,b;
			scanf("%d%d",&a,&b);
			if(node[a].left==-1){		//如果是在第一个珠子前面增加 
				begin=b;			//更改串首珠子的编号 
				node[b].right=a;
				node[a].left=b;
				continue;
			} 
				//把b插在a和a左边珠子中间 
			node[node[a].left].right=b;		//原本a左边珠子的右边为b 
			node[b].left=node[a].left;		//b的左边珠子为原本a左边的珠子 
			node[a].left=b;					//a的左边珠子为b 
			node[b].right=a;				//b的右边珠子为a 
		}
		else if(!strcmp(q,"DEL")){		//删除操作 
			len--;				//串长度减 1 
			int a;
			scanf("%d",&a);
			if(node[a].left==-1){		//如果是第一个珠子 
				begin=node[a].right;		//更新串首珠子的编号 
				node[node[a].right].left=-1;	//更新a右边的珠子的左边编号
				node[a].left=node[a].right=-1; 
				continue;
			}
				//删除a，更新其左右信息 
			node[node[a].left].right=node[a].right;		//更新a左边珠子的右边信息 
			node[node[a].right].left=node[a].left;		//更新a右边珠子的左边信息 
			node[a].left=node[a].right=-1; 
		}
	}
	printf("%d\n",len);
	printf("%d",begin);
	while(node[begin].right!=-1){
		printf(" %d",node[begin].right);
		begin=node[begin].right;	
	}
	
	return 0;
}

PS. 刘汝佳著的紫书中有一题，和这题思路差不多，与大家分享：
移动盒子 （Boxes in a Line，UVa 12657）
你有一行盒子，从左到右依次编号为1,2,3,…,n。可以执行以下4种指令：
1 x y：表示把盒子x移动到盒子y的左边（如果x已经在y的左边则忽略此指令）。
2 x y：表示把盒子x移动到盒子y的右边（如果x已经在y的右边则忽略此指令）。
3 x y：表示交换盒子x和y的位置。
4：表示反转整条链。

指令保证合法，即x不等于y。

例如当n=6时在初始状态盒子序列为为：1 2 3 4 5 6；
　　执行1 1 4后，盒子序列为：2 3 1 4 5 6；
　　接下来执行2 3 5，盒子序列变为：2 1 4 5 3 6；
　　再执行3 1 6，盒子序列变为：2 6 4 5 3 1；
　　最终执行4，盒子序列变为：1 3 5 4 6 2。

【输入格式】
输入包含不超过10组数据，每组数据第一行为盒子数n和指令m，以下m行每行包含一条指令。
【输出格式】
每组数据输出一行，即所有奇数位置的盒子编号之和。位置从左到右编号为1~n。
【输入样例】
6 4
1 1 4
2 3 5
3 1 6
4
6 3
1 1 4
2 3 5
3 1 6
100000 1
4
【输出样例】
12
9
2500050000
【数据范围】
N,M<=100000

// UVa12657 Boxes in a Line
// Rujia Liu
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 100000 + 5;
int n, left[maxn], right[maxn];

inline void link(int L, int R) {
  right[L] = R; left[R] = L;
}

int main() {
  int m, kase = 0;
  while(scanf("%d%d", &n, &m) == 2) {
    for(int i = 1; i <= n; i++) {
      left[i] = i-1;
      right[i] = (i+1) % (n+1);
    }
    right[0] = 1; left[0] = n;
    int op, X, Y, inv = 0;

    while(m--) {
      scanf("%d", &op);
      if(op == 4) inv = !inv;
      else {
        scanf("%d%d", &X, &Y);
        if(op == 3 && right[Y] == X) swap(X, Y);
        if(op != 3 && inv) op = 3 - op;
        if(op == 1 && X == left[Y]) continue;
        if(op == 2 && X == right[Y]) continue;

        int LX = left[X], RX = right[X], LY = left[Y], RY = right[Y];
        if(op == 1) {
          link(LX, RX); link(LY, X); link(X, Y);
        }
        else if(op == 2) {
          link(LX, RX); link(Y, X); link(X, RY);
        }
        else if(op == 3) {
          if(right[X] == Y) { link(LX, Y); link(Y, X); link(X, RY); }
          else { link(LX, Y); link(Y, RX); link(LY, X); link(X, RY); }
        }
      }
    }

    int b = 0;
    long long ans = 0;
    for(int i = 1; i <= n; i++) {
      b = right[b];
      if(i % 2 == 1) ans += b;
    }
    if(inv && n % 2 == 0) ans = (long long)n*(n+1)/2 - ans;
    printf("Case %d: %lld\n", ++kase, ans);
  }
  return 0;
}