uva 101 The Blocks Problem

题目大意:


从左到右有n割木块,编号为0~n-1,要求模拟一下四种操作(下面a,b都是木块编号)


move a onto b:把a和b上方的木块全部归位然后把a摞在b上面,

move a over b:把a上方的木块全部归位,然后把a放在b所在的木块堆的顶部

pile  a onto b:把b上方的木块全部归位,然后把a及上面的木块整体摞在b上面

pile a over b:把a及上面的木块整体摞在b所在的木块堆的顶部

解体思路:


模拟用vector保存



#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=30;
vector<int> pile[maxn];
int n;
//找到木块a坐在的pile和height
void find_block(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 ;
        }
    }
}

//把第p堆高度为h的木块上方所有木块归位
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);
}
//把第p堆高度为h及其上方的木板整体移移动到p2的顶部
void pile_onto(int p,int h,int p2){
    for(int i=h;i<pile[p].size();i++){
        pile[p2].push_back(pile[p][i]);
    }
    pile[p].resize(h);
}
void print(){
    for(int i=0;i<n;i++){
        printf("%d:",i);
        for(int j=0;j<pile[i].size();j++){
            printf(" %d",pile[i][j]);
        }
        printf("\n");
    }
}


int main(){

    cin>>n;
    string s1,s2;
    int a,b;
    for(int i=0;i<n;i++) pile[i].push_back(i);
    while(cin>>s1>>a>>s2>>b){
            if(s1=="quit") break;
        int pa,pb,ha,hb;
        find_block(a,pa,ha);
        find_block(b,pb,hb);
        if(pa==pb) continue;
        if(s2=="onto") clear_above(pb,hb);
        if(s1=="move") clear_above(pa,ha);
        pile_onto(pa,ha,pb);

    }
    print();





    return 0;
}


### 关于头歌平台中序列式容器 The Blocks Problem 的解析 在头歌平台的6.1.1章节中,序列式容器被广泛用于解决一系列问题,其中6.1.1.1节中的 **The Blocks Problem** 是一个经典的例子。该问题的核心在于模拟一组堆叠的块,并根据指令对这些块进行移动操作。以下是对此问题的详细解析。 #### 问题描述 假设有一组编号从0到n-1的块,初始时每个块单独放置在一个堆栈中。程序需要支持以下两种操作: 1. `move a onto b`:将块a及其上方的所有块移除,然后将块a单独放置在块b的顶部。 2. `pile a over b`:将块a及其上方的所有块作为一个整体移动到块b所在堆栈的顶部[^1]。 #### 数据结构选择 为了高效地实现上述操作,通常使用一种基于列表的结构来表示堆栈。具体来说: - 每个堆栈可以用一个列表表示,列表中的元素按从底到顶的顺序排列。 - 使用一个字典或数组来记录每个块当前所在的堆栈索引,以便快速定位块的位置。 #### 实现逻辑 以下是解决问题的核心逻辑: 1. **初始化**:创建n个堆栈,每个堆栈包含一个块。 2. **解析命令**:读取输入命令并解析为具体的操作类型和参数。 3. **执行操作**: - 对于`move a onto b`,首先找到块a和块b所在的堆栈,移除块a及其上方的所有块,然后将块a单独放置在块b的顶部。 - 对于`pile a over b`,同样找到块a和块b所在的堆栈,但这次将块a及其上方的所有块作为一个整体移动到块b的顶部[^1]。 4. **输出结果**:根据需要输出最终的堆栈状态。 #### 示例代码 以下是用Python实现的一个简单版本: ```python def blocks_problem(n, commands): stacks = {i: [i] for i in range(n)} # 初始化堆栈 block_to_stack = {i: i for i in range(n)} # 记录每个块所在的堆栈 def move(a, b): stack_a = block_to_stack[a] stack_b = block_to_stack[b] if stack_a == stack_b: return # 移除块a及其上方的所有块 index_a = stacks[stack_a].index(a) moved_blocks = stacks[stack_a][index_a:] stacks[stack_a] = stacks[stack_a][:index_a] # 将块a单独放置在块b的顶部 stacks[stack_b].extend([a]) for block in moved_blocks: block_to_stack[block] = stack_b def pile(a, b): stack_a = block_to_stack[a] stack_b = block_to_stack[b] if stack_a == stack_b: return # 找到块a及其上方的所有块 index_a = stacks[stack_a].index(a) moved_blocks = stacks[stack_a][index_a:] stacks[stack_a] = stacks[stack_a][:index_a] # 将块a及其上方的所有块移动到块b的顶部 stacks[stack_b].extend(moved_blocks) for block in moved_blocks: block_to_stack[block] = stack_b for command in commands: if command.startswith("move"): _, a, _, b = command.split() move(int(a), int(b)) elif command.startswith("pile"): _, a, _, b = command.split() pile(int(a), int(b)) return stacks ``` #### 运行示例 假设输入如下: ```plaintext 5 move 1 onto 2 pile 3 over 1 move 4 onto 3 ``` 运行结果将是: ```python { 0: [0], 1: [1, 2, 3, 4], 2: [], 3: [], 4: [] } ``` #### 算法复杂度分析 - **时间复杂度**:对于每次操作,查找块所在堆栈的时间复杂度为O(1),而移除或添加块的操作取决于堆栈的高度,最坏情况下为O(n)。 - **空间复杂度**:需要O(n)的空间来存储堆栈和映射关系。 #### 总结 通过合理选择数据结构和算法,可以高效地解决 **The Blocks Problem**。此问题不仅考察了对序列式容器的理解,还涉及对堆栈操作的灵活运用[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值