OJ Board

Code: Select all

#include <iostream>
#include <stack>

class BlockWorld
{
private:
	int numSpaces;
	std::stack<int> *spaces;
	int *blockPosition;

	void AllocateArrays();
	bool IllegalOperation(int src, int dest) const;
	void UnpileOver(int block);
	void MoveBlock(int src, int dest);
	void MovePile(int src, int dest);
public:
	BlockWorld(int newNumSpaces);	// default constructor
	BlockWorld(const BlockWorld &other);	// copy constructor
	~BlockWorld();					// destructor

	void MoveOnto(int src, int dest);
	void MoveOver(int src, int dest);
	void PileOnto(int src, int dest);
	void PileOver(int src, int dest);

	void PrintOut(std::ostream &target = std::cout) const;
};



void BlockWorld::AllocateArrays()
{
	spaces = new std::stack<int>[numSpaces];
	blockPosition = new int[numSpaces];
}



BlockWorld::BlockWorld(int newNumSpaces):numSpaces(newNumSpaces)
{
	AllocateArrays();
	for(int ii = 0; ii < numSpaces; ii++)
	{
		blockPosition[ii] = ii;
		spaces[ii].push(ii);
	}
}



BlockWorld::BlockWorld(const BlockWorld &other):numSpaces(other.numSpaces)
{
	AllocateArrays();
	for(int ii = 0; ii < numSpaces; ii++)
	{
		spaces[ii] = other.spaces[ii];
		blockPosition[ii] = other.blockPosition[ii];
	}
}



BlockWorld::~BlockWorld()
{
	delete[] spaces;
	delete[] blockPosition;
}



bool BlockWorld::IllegalOperation(int src, int dest) const
{
	if(src == dest || blockPosition[src] == blockPosition[dest])
		return true;

	return false;
}



void BlockWorld::UnpileOver(int block)
{
	while(spaces[blockPosition[block]].top() != block)
	{
		int newBlock = spaces[blockPosition[block]].top();
		spaces[blockPosition[block]].pop();
		spaces[newBlock].push(newBlock);
		blockPosition[newBlock] = newBlock;
	}
}



void BlockWorld::MoveBlock(int src, int dest)
{
	spaces[blockPosition[src]].pop();
	blockPosition[src] = blockPosition[dest];
	spaces[blockPosition[dest]].push(src);
}



void BlockWorld::MovePile(int src, int dest)
{
	std::stack<int> temp;

	while(spaces[blockPosition[src]].top() != src)
	{
		temp.push(spaces[blockPosition[src]].top());
		spaces[blockPosition[src]].pop();
	}

	temp.push(spaces[blockPosition[src]].top());
	spaces[blockPosition[src]].pop();

	while(!temp.empty())
	{
		int block = temp.top();
		temp.pop();
		blockPosition[block] = blockPosition[dest];
		spaces[blockPosition[dest]].push(block);
	}
}



void BlockWorld::MoveOnto(int src, int dest)
{
	if(IllegalOperation(src, dest))
		return;
	
	UnpileOver(src);
	UnpileOver(dest);

	MoveBlock(src, dest);	
}



void BlockWorld::MoveOver(int src, int dest)
{
	if(IllegalOperation(src, dest))
		return;

	UnpileOver(src);

	MoveBlock(src, dest);
}



void BlockWorld::PileOnto(int src, int dest)
{
	if(IllegalOperation(src, dest))
		return;

	UnpileOver(dest);

	MovePile(src, dest);
}



void BlockWorld::PileOver(int src, int dest)
{
	if(IllegalOperation(src, dest))
		return;
	
	MovePile(src, dest);
}



void BlockWorld::PrintOut(std::ostream &target) const
{
	std::stack<int> temp;
	for(int ii = 0; ii < numSpaces; ii++)
	{
		target << ii << ": ";
		while(!spaces[ii].empty())
		{
			temp.push(spaces[ii].top());
			spaces[ii].pop();
		}

		while(!temp.empty())
		{
			int block = temp.top();
			temp.pop();
			target << block << (temp.empty() ? "" : " ");
			spaces[ii].push(block);
		}

		target << std::endl;
	}
}



int main()
{
	int numBlocks;
	std::cin >> numBlocks;

	BlockWorld bw(numBlocks);
	void (BlockWorld::*moveFunction[2][2])(int, int) = 
	{
		{ &BlockWorld::MoveOnto, &BlockWorld::MoveOver },
		{ &BlockWorld::PileOnto, &BlockWorld::PileOver }
	};

	while(true)
	{		
		std::string s1, s2;
		int ii, jj, fx, fy;
		std::cin >> s1;
		if(s1 == "quit" || !std::cin)
			break;
		std::cin >> ii >> s2 >> jj;
		if(!std::cin)
			break;
		
		s1 == "move" ? fx = 0 : fx = 1;
		s2 == "onto" ? fy = 0 : fy = 1;

		(bw.*moveFunction[fx][fy])(ii, jj);		
	}

	bw.PrintOut();

	return 0;
}

Code: Select all

code removed.

Code: Select all

#include<stdio.h>
#include<stdlib.h>

typedef struct block_t {
	short name;
	struct block_t *next;
}BLOCK;

void clearBlock(BLOCK *[]);

int main(void) {
	char str[5] ,mode ,flag;
	short n ,a ,b ,i ,j ,tA ,tB ,fA ,fB;
	BLOCK **ptA ,**ptB ,**tmp ,*block[25]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

	for(i=0;i<25;++i) {
		block[i] = (BLOCK *)malloc(sizeof(BLOCK));
		block[i]->name = i;
		block[i]->next = NULL;
	}
	
	while(scanf(" %hd" ,&n)!=EOF) {
		
		while(scanf(" %s" ,str)!=EOF && str[0]!='q') {
			scanf(" %hd" ,&a);
			mode = str[0];
			scanf(" %s %hd" ,str ,&b);

			if(a!=b && 0<=a && a<n && 0<=b && b<n) {
				flag = 0;
				for(i=0 ,ptA=NULL ,ptB=NULL; !ptA || !ptB ;++i) {
					for(tmp=&block[i] ,j=0; *tmp ;tmp=&(*tmp)->next ,j++) {
						if((*tmp)->name == a) {
							ptA = tmp;
							tA = i;
							fA = j;
						}
						if((*tmp)->name == b) {
							ptB = &(*tmp)->next;
							tB = i;
							fB = j;
							flag = 1;
						}
					}
					if(ptB && str[1]=='v' && flag) {
						ptB = tmp;
						flag = 0;
					}
				}
				if(!(mode=='p' && tA==tB && fA<fB)) {
					if(mode=='m') {
						while(*ptB) {
							block[(*ptB)->name] = *ptB;
							tmp = &block[(*ptB)->name];
							*ptB = (*ptB)->next;
							(*tmp)->next = NULL;
						}
						while((*ptA)->next) {
							block[(*ptA)->next->name] = (*ptA)->next;
							tmp = &block[(*ptA)->next->name];
							(*ptA)->next = (*ptA)->next->next;
							(*tmp)->next = NULL;
						}
					} else if(*ptB) {
						block[(*ptB)->name] = *ptB;
						*ptB = NULL;
					}
					*ptB = *ptA;
					*ptA = NULL;
				}
			}
		}
		for(i=0;i<n;++i) {
			printf("%d:" ,i);
			for(tmp=&block[i]; *tmp ;tmp=&(*tmp)->next) {
				printf(" %d" ,(*tmp)->name);
			}
			printf("\n");
		}
		for(i=0;i<25;++i) {
			if(block[i]) {
				for(;block[i]->next;) {
					block[block[i]->next->name] = block[i]->next;
					tmp = &block[block[i]->next->name];
					block[i]->next = block[i]->next->next;
					(*tmp)->next = NULL;
				}
			}
		}
	}
	clearBlock(block);
	return 0;
}

void clearBlock(BLOCK *block[]) {
	short i;
	BLOCK *tmp;
	for(i=0;i<25;++i) {
		while(block[i]) {
			tmp = block[i];
			block[i] = block[i]->next;
			free(tmp);
		}
	}
}