【Poj1363】-判断合法栈序列

题目大意：

给定一个数字序列判断该序列是否可以按照栈的规则得到
链接: poj1363.

---

解决思路一（超时）：

经发现，如果是三个数的情况下，不合法的顺序只有312，也就是一个数最大第二个数最小的情况下，出栈序列是不合法的，原先我是只比较相连的三个序列，经老师提醒应该是全局的三个数进行比较。

解决思路一的代码：

#include <iostream>
#include <cstdio>
#include <stack>
using namespace std;
const int maxn = 1000 + 5;
int a[maxn];
int n;
bool judge()
{
	for (int i = 0;i < n - 2;i++)
	{
		for (int j = i + 1;j < n - 1;j++)
			for (int k = j + 1;k < n;k++)
			{
				if (a[i] > a[j] && a[i] > a[k] && a[k] > a[j])
					return false;
			}
	}
	return true;
}
int main()
{
	int cnt=0;
	
	while (cin>>n&&n)
	{
		int flag = 0;
		if (cnt++)
			cout << endl;
		while (1)
		{
			for (int i = 0;i < n;i++)
			{
				cin >> a[i];
				if (a[0] == 0)
				{
					flag = 1;
					break;
				}
			}
			if (flag)
				break;
			else
			{
				if (judge())
					cout << "YES" << endl;
				else
					cout << "NO" << endl;
			}
		}
	}
	return 0;
}

---

解决思路一评价：

这种方法虽然可以解决问题，但是由于有三重遍历，实际上的时间复杂度为O（n^3）还是比较高的，可行但不可取

---

解决思路二：

使用栈模拟的方式进行，当新建的栈按照需判断的数字序列模拟能使得栈为空，说明该数字序列就是合法的

方案二实现代码（一）：

#include <iostream>
#include <cstdio>
#include <stack>
#include <fstream>

//#define cout fout
using namespace std;

//ofstream fout("result.txt");
const int maxn = 1000 + 10;
int a[maxn],n;
void tpop(stack<int> &q1,stack<int> &q2)
{

	while (!q1.empty() &&!q2.empty() &&q1.top() == q2.top())
	{
		q1.pop();
		q2.pop();
	}
}
int main()
{
	int cnt = 0;
	while (cin >> n && n)
	{
		int flag = 0;
		//if (cnt++)
			//cout << endl;
		while (1)
		{
			stack<int> q1, q2;
			for (int i = 0;i < n;i++)
			{
				cin >> a[i];
				if (a[0] == 0)
				{
					flag = 1;
					break;
				}
			}
			if (flag)
				break;
			else
			{
				for (int i = n - 1;i >= 0;i--)
					q2.push(a[i]);
				for (int i = 0;i < n;i++)
				{
					q1.push(i + 1);
					tpop(q1, q2);
				}
				if (q1.empty())
					cout << "Yes" << endl;
				else
					cout << "No" << endl;
			}
		}
		cout << endl;
	}

	return 0;
}

方案二实现代码（二）：

#include<cstdio>
#include<stack>
using namespace std;
const int MAXN = 1000 + 10;
int n, target[MAXN];
int main()
{
	while(scanf("%d", &n) == 1)
	{
		stack<int> s;
		int A = 1, B = 1;//A标识的是模拟栈，B标识的是现在需要判断是否合法的栈
		for(int i = 1; i <= n; i++)
		scanf("%d", &target[i]);
		int ok = 1;
		while(B <= n)
		{
			if(A == target[B])//正好对应的数据相同时，两个栈往下走，就不用多堆积元素了
			{
				 A++;
				 B++;
			 }
			else if(!s.empty() && s.top() == target[B])//之前堆积的数据和现在相同时弹出并往下走
			{
				 s.pop();
				 B++; 
			}
			     else if(A <= n) //要不然把数据压到栈中
				  s.push(A++);
			           else          //知道A走完栈空
			        { 
			              ok = 0;
			              break;
			        }
		}
		printf("%s\n", ok ? "Yes" : "No");
	}
	return 0;
}

解决思路二评价：

这种方式下判断，时间复杂度应该是O（n）级别的。
代码实现一，是我自己实现的代码，但有需要改进的地方，就是直接可以用队列存储需要判断的数字序列，栈存储模拟栈，进行判断即可，而我的那种方式，是将数据放进数组中，再反向存储到栈中，不免有些麻烦；
代码实现二，是《算法竞赛入门经典》中提供的代码，好处在于节省了空间，只用A，B两个人变量来标识，且也没用到栈的数据结构，缺点就是刚开始看有点点难理解。

---