编程之美---找出翻烙饼的最少次数

最近把《编程之美》上这个题做了下， 觉得挺简单的啊，即使是寻找最优解，就是一个广度优先搜索，用到的数据结构是 数组+队列+栈， 搜索空间还需要进一步优化.

感觉代码比 书上的要简单些，就是一些小函数 组合一下，不要像书中给出的代码那样 使用类成员变量来传递数据，这不是一种好的实践方法！！！

书上的代码使用深度优先搜索，递归实现，除了要求比较大的栈空间之外， 还需要对 得到的 多个解 进行 优劣比较，虽然比较很简单。 如果使用广度优先搜索就不会有这个问题。

后面得知这是所谓的 prefix sorting, 属于违背研究人员彻底攻克的问题， CMU 一门课第一节就讲的这个问题。有点像一些数论中的问题，理解起来简单，彻底解决很难。

#include <iostream>
#include <vector>
#include<queue>
#include<stack>

using namespace std;

struct Status
{
	vector<int> seq;

	int depth; // 从初始算起，第多少次翻转， 从1开始计数，最多 2(n-1)次翻转

	int pos; // 本次翻转位置，从0开始计数, -1 表示没进行翻转

	int parentId; // 过程中的父编号, 
	int Id;
};

// 排序好返回true,否则 false;
bool check(const std::vector<int> & seq)
{
	for (int i = 0; i < seq.size()-1; i++)
	{
		if (seq[i] > seq[i + 1])
		{
			return false;
		}
	}
	return true;
}
std::vector<int> swap(const std::vector<int> & seq, int pos)
{
	std::vector<int> res(seq);

	for (int i = 0; i < (1+pos) / 2; i++)
	{
		auto t = res[i];
		res[i] = res[pos - i];
		res[pos - i] = t;
	}

	return res;
}

void outputRes(const vector<Status> & ans, const Status status, const Status init)
{
	Status curr = status;
	stack<Status> pos;

	while(curr.parentId != -1)
	{
		pos.push(curr);

		curr = ans[curr.parentId];
	}

	std::cout << "start :";
	for (int i = 0; i < init.seq.size(); i++)
	{
		std::cout << init.seq[i] << " ";
	}
	std::cout << "\n";

	while (!pos.empty())
	{
		auto t = pos.top();
		std::cout << " swap " << t.pos << std::endl;

		for (int i = 0; i < t.seq.size(); i++)
		{
			std::cout << t.seq[i] << " ";
		}
		std::cout << "\n";

		pos.pop();
	}
}

void getAnswer(const Status status, int  n)
{
	queue<Status> queue;
	vector<Status> ans; // 保存所有状态
	ans.push_back(status);

	int counter = 0;
	if (check(status.seq))
	{
		std::cout << " have reached the final status\n";
		return;
	}

	queue.push(status);

	while (!queue.empty())
	{
		auto sts = queue.front();
		queue.pop();

		// 遍历每个能翻转的位置，如果不是最终状态，那么 插入队列

		for (int i = 1; i < n; i++)
		{
			if (i != sts.pos)
			{
				// 执行一次翻转
				auto newSeq = swap(sts.seq, i);

				if (check(newSeq))
				{
					// 输出结果
					Status sts2;
					sts2.seq = newSeq;
					sts2.parentId = sts.Id;
					sts2.pos = i;
					outputRes(ans, sts2, status);
					
					std::cout << " search space size " << ans.size() << std::endl;

					return ;
				}
				else if(sts.depth < 2*(n-1))
				{
					Status sts2;
					sts2.parentId = sts.Id;

					counter++;
					sts2.Id = counter;

					sts2.seq = newSeq;
					sts2.pos = i;
					sts2.depth = sts.depth + 1;

					ans.push_back(sts2);
					queue.push(sts2);
				}

			}
		}
	}
}

int main()
{
	vector<int> _start = { 3,2,1,6,5,4,9,8,7,0};
	int n = _start.size();

	Status start;
	start.parentId = -1;
	start.Id = 0;
	start.seq = _start;
	start.depth = 0;
	start.pos = -1;

	getAnswer(start, n);

	return 0;
}