101 - The Blocks Problem

本文介绍了一个基于C++实现的塔式存储模拟器程序,该程序能够通过不同的指令操作多个堆栈,模拟物品在塔式存储系统中的移动。文章详细展示了如何使用结构体定义堆栈,以及如何通过解析命令字符串来执行相应的操作。
#include <iostream>
#include <cstdio>
#include <sstream>
#include <string>
using namespace std;

const int Max=30;
struct node
{
	int stack[Max];
	int top;//+1
	node():top(0){}
}s[Max];

int n;

void init()
{
	for(int i=0;i<n;i++)
		s[i].stack[s[i].top++]=i;
}
int getCommand(string &s1,string &s2)
{
	if(s1=="move" && s2=="onto")
		return 1;
	else if(s1=="move" && s2=="over")
		return 2;
	else if(s1=="pile" && s2=="onto")
		return 3;
	else if(s1=="pile" && s2=="over")
		return 4;
	return 0;
}
int getPos(int x,int &pos,int &lev)
{
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<s[i].top;j++)
			if(s[i].stack[j]==x)
			{
				pos=i;
				lev=j;
				return 1;
			}
	}
	return 0;
}
void handle(string &s1,int a,string &s2,int b)
{
	int sort=getCommand(s1,s2);
	int a_pos,b_pos;
	int a_lev,b_lev;
	int i;
	int temp;
	getPos(a,a_pos,a_lev);
	getPos(b,b_pos,b_lev);
	if(a_pos==b_pos)
		return ;
	switch(sort)
	{
	case 1:
		for(i=a_lev+1;i<s[a_pos].top;i++)
		{
			temp=s[a_pos].stack[i];
			s[temp].stack[s[temp].top++]=temp;
		}
		s[a_pos].top=a_lev+1;
		for(i=b_lev+1;i<s[b_pos].top;i++)
		{
			temp=s[b_pos].stack[i];
			s[temp].stack[s[temp].top++]=temp;
		}
		s[b_pos].top=b_lev+1;
		s[b_pos].stack[s[b_pos].top++]=s[a_pos].stack[--s[a_pos].top];
		break;
	case 2:
		for(i=a_lev+1;i<s[a_pos].top;i++)
		{
			temp=s[a_pos].stack[i];
			s[temp].stack[s[temp].top++]=temp;
		}
		s[a_pos].top=a_lev+1;
		s[b_pos].stack[s[b_pos].top++]=s[a_pos].stack[--s[a_pos].top];
		break;
	case 3:
		for(i=b_lev+1;i<s[b_pos].top;i++)
		{
			temp=s[b_pos].stack[i];
			s[temp].stack[s[temp].top++]=temp;
		}
		s[b_pos].top=b_lev+1;
		for(i=a_lev;i<s[a_pos].top;i++)
		{
			temp=s[a_pos].stack[i];
			s[b_pos].stack[s[b_pos].top++]=temp;
		}
		s[a_pos].top=a_lev;
		break;
	case 4:
		for(i=a_lev;i<s[a_pos].top;i++)
		{
			temp=s[a_pos].stack[i];
			s[b_pos].stack[s[b_pos].top++]=temp;
		}
		s[a_pos].top=a_lev;
		break;
	default:
		break;
	}
}

int main()
{
	/*
	freopen("101.in","r",stdin);
	freopen("101.out","w",stdout);
	//*/
	scanf("%d",&n);
	getchar();
	init();
	string command;
	while(getline(cin,command) && command!="quit")
	{
		int a,b;
		string s1,s2;
		istringstream in(command);
		in>>s1;
		in>>a;
		in>>s2;
		in>>b;
		handle(s1,a,s2,b);
	}
	for(int i=0;i<n;i++)
	{
		printf("%d:",i);
		for(int u=0;u<s[i].top;u++)
			printf(" %d",s[i].stack[u]);
		//if(s[i].top>0)
			//printf("%d",s[i].stack[s[i].top-1]);
		printf("\n");
	}
	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、付费专栏及课程。

余额充值