STL初步（二）vector

vector不定长数组

vector头文件中的vector就是一个不定长数组。一些常用操作也封装在vector类型内部。例如，a是一个vector，可以用a.size()读取它的大小，a.resize()改变大小，a.push_back()向尾部添加元素，a.pop_back()删除最后一个元素，可以用a.clear()清空，也可以用a.empty()测试是否为空。此例题中它更像一个二维数组，只是第一维的大小固定(不超过maxn),第二维的大小不固定。

vector是一个模板类，所以需要用vector< int > a 或者vector< double > b 这样的方式来声明一个vector。vector < int >是一个类似于int a[]的整数数组，而vector < string >就是一个类似string a[]的字符串数组。vector看上去像“一等公民”，因为它们可以直接赋值，还可以作为函数的参数或者返回值，而无需像传递数组那样另外用一个变量指定元素个数。

【例题5-2 UVA - 101】The Blocks Problem
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:

Initial Blocks World
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:

题目大意：
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和上的积木放在b的最上方。

注意：遇到quit时终止一组数据。a和b同一个积木堆时，任何操做都时无效的。

我的代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 30;

string s1, s2;
int n, a, b;
vector <int> v[N];
///找木块所在的堆和高度，以引用的形式返回调用者
void get_sta(int a, int &p, int &h)
{
    for (int i = 0; i < n; i++)
    {
        int len = v[i].size();
        for (int j = 0;j < len;j++)
            if (v[i][j] == a)///找到a
            {
                p = i, h = j;
                return;
            }
    }
}
///把第p堆高度为h的木块上方的所有木块移回原位
void clear(int p, int h)
{
    int len = v[p].size();
    for (int i = h + 1; i < len; i++)
        v[v[p][i]].push_back(v[p][i]);///v[v[p][i]]尾部添加元素。把木块放回原位
    v[p].resize(h + 1);///resize改变大小，v只保留下标0~h的元素
}
///把第p1堆高度为h1及其上方木块整体移动到p2堆的顶部
void add(int p1, int h1, int p2)
{
    int len = v[p1].size();
    for (int i = h1; i < len; i++)
        v[p2].push_back(v[p1][i]);///v[p2]尾部添加元素。把第p1堆高度为h1及其上方木块整体移动到p2堆的顶部
    v[p1].resize(h1);///resize改变大小，v只保留下标0~h1-1的元素
}

int main()
{
    cin>>n;
    for (int i = 0; i < n; i++) v[i].push_back(i);///把底部木块依次放入
    while (cin >> s1)
    {
        if (s1 == "quit") break;
        cin >> a >> s2 >> b;
        int p1, h1, p2, h2;
        get_sta(a, p1, h1);///找木块
        get_sta(b, p2, h2);
        if (p1 == p2) continue;///非法指令
        if (s1 == "move") clear(p1, h1);
        if (s2 == "onto") clear(p2, h2);
        add(p1,h1,p2);
    }
    for (int i = 0; i < n; i++)
    {
        cout<<i<<":";
        int len = v[i].size();
        for (int j = 0; j < len; j++) cout<<" "<<v[i][j];
        cout<<endl;//puts("");
    }
    return 0;
}

参考：紫薯（《算法竞赛入门经典第2版》刘汝佳◎著）