The Blocks Problem (vector)

这是不定长数组vector的一道练习题
题目较长，下面有简单题目解释

The Blocks Problem （UVA01）
Many areas of Computer Science use simple, abstract domains for both analytical and empirical studies.

For example, an early AI study of planning and robotics (STRIPS) used a block world in which a robot
arm performed tasks involving the manipulation of blocks.
In this problem you will model a simple block world under certain rules and constraints. Rather
than determine how to achieve a specified state, you will “program” a robotic arm to respond to a
limited set of commands.

The problem is to parse a series of commands that instruct a robot arm in how to manipulate blocks
that lie on a flat table. Initially there are n blocks on the table (numbered from 0 to n − 1) with block
bi adjacent to block bi+1 for all 0 ≤ i < n − 1 as shown in the diagram below:

The valid commands for the robot arm that manipulates blocks are:

• move a onto b

where a and b are block numbers, puts block a onto block b after returning any blocks that are
stacked on top of blocks a and b to their initial positions.

• move a over b

where a and b are block numbers, puts block a onto the top of the stack containing block b, after
returning any blocks that are stacked on top of block a to their initial positions.

• pile a onto b

where a and b are block numbers, moves the pile of blocks consisting of block a, and any blocks
that are stacked above block a, onto block b. All blocks on top of block b are moved to their
initial positions prior to the pile taking place. The blocks stacked above block a retain their order
when moved.

• pile a over b

where a and b are block numbers, puts the pile of blocks consisting of block a, and any blocks
that are stacked above block a, onto the top of the stack containing block b. The blocks stacked
above block a retain their original order when moved.

• quit

terminates manipulations in the block world.
Any command in which a = b or in which a and b are in the same stack of blocks is an illegal
command. All illegal commands should be ignored and should have no affect on the configuration of
blocks.

Input
The input begins with an integer n on a line by itself representing the number of blocks in the block
world. You may assume that 0 < n < 25.
The number of blocks is followed by a sequence of block commands, one command per line. Your
program should process all commands until the quit command is encountered.
You may assume that all commands will be of the form specified above. There will be no syntactically
incorrect commands.

Output
The output should consist of the final state of the blocks world. Each original block position numbered
i (0 ≤ i < n where n is the number of blocks) should appear followed immediately by a colon. If there
is at least a block on it, the colon must be followed by one space, followed by a list of blocks that appear
stacked in that position with each block number separated from other block numbers by a space. Don’t
put any trailing spaces on a line.
There should be one line of output for each block position (i.e., n lines of output where n is the
integer on the first line of input).

Sample Input
10
move 9 onto 1
move 8 over 1
move 7 over 1
move 6 over 1
pile 8 over 6
pile 8 over 5
move 2 over 1
move 4 over 9
quit

Sample Output
0: 0
1: 1 9 2 4
2:
3: 3
4:
5: 5 8 7 6
6:
7:
8:
9:

题解
简单来说，你有n个箱子，input中第一个数就是n，接下来，每个箱子的编号便是0 <= i < n，接下来输入步骤
有四种移动方式：

1. move a onto b:
   把a和b上方木块全部归位，然后把a放在b上面
2. move a over b:
   把a上方木块全部归位，然后把a放在b所在木块堆的顶部
3. pile a onto b:
   把b上方木块全部归位，然后把a及a上面的木块整体放在b的上面
4. pile a over b:
   把a及a上面的木块整体放在b木块堆的顶部

遇到quit时终止一组数据的输入。

注意：a和b在同一堆的指令是非法指令，应当忽略。
如sample input中的“pile 8 over 6”这一步

#include 
#include 
#include 
#include 
using namespace std;

const int maxn = 30;

int n;

vector <int> pile[maxn];

void find_blocks(int a, int &pa, int &ha);
void clear_above(int p, int h);
void pile_onto(int pa, int ha, int pb);
void print();


int main()
{
     
	//Initialization
	int a, b; 
	cin >> n;
	string s1, s2;
	for(int i = 0; i < n; i++)
		pile[i].push_back(i); 
		
	while(cin >> s1)
	{
     
		if(s1 == "quit")	break;
		
		cin >> a >> s2 >> b;
		//pile a,b    height a,b
		int pa, pb, ha, hb;
		
		find_blocks(a, pa, ha);
		find_blocks(b, pb, hb);
		if(pa == pb)
			continue;
		//通过简单分析步骤可总结 
		if(s1 == "move")
			clear_above(pa, ha);
		if(s2 == "onto")
			clear_above(pb, hb);
		pile_onto(pa, ha, pb);
	}
	
	print();
	
	return 0;
}

//用引用来返回位置 
void find_blocks(int a, int &p, int &h)
{
     
	for(p = 0; p < n; p++)
		for(h = 0; h < pile[p].size(); h++)
			if( pile[p][h] == a)
				return;
}
//清空 
void clear_above(int p, int h)
{
     
	for(int i = h + 1; i < pile[p].size(); i++){
     
		int b = pile[p][i];
		pile[b].push_back(b);
	}
	pile[p].resize(h + 1);	//清空，留下0-h上的木块 
}
//移动 
void pile_onto(int pa, int ha, int pb)
{
     
	for(int i = ha; i < pile[pa].size(); i++)
		pile[pb].push_back(pile[pa][i]);
	pile[pa].resize(ha);
}

void print()
{
     
	for(int p = 0; p < n; p++){
     
		printf("%d:",p);
		for(int h = 0; h < pile[p].size(); h++)
			printf(" %d",pile[p][h]);	
		printf("\n");
	}
} 
 

直接输入结果

debug结果

我真搞不懂，救救孩子吧

最后也许是编译器问题，代码在别的地方可以运行。
如果有人知道为啥会有这个情况务必告诉我！！

395