新汉诺塔

题目

汉诺塔问题
题目描述
有三个柱子A,B,C上面随机套了N个大小不一盘子(N <= 31)，小号盘子依次罗在大号盘子上面, 现需要将所有的盘子都移到C柱上面，在移动的过程当中:
每次只能将一个柱子最上面的盘子放到其它柱子的最上面
且任何时刻不能将大号的盘子压在小号的盘子上面。

输入说明
以命令行参数的形式输入盘子的初始状态，以及移动步数S(S <= 2^31 - 1)。
在程序中可以从main 函数的参数中获得，示例代码如下:

int main(int argc, char* argv[])
{
unsigned int print_count;
char* init_status;
init_status = argv[1];
print_count = strtoul(argv[2], NULL, 10);
…
return 0;
}
输出说明
最少需要移动多少步可以完成目标，以及在移动S步后，盘子的当前状态是什么，以逗号隔开。

示例1
输入:
AAA
1
AAA: 表示初始状态有3个盘子 全部放在A柱上面, 1: 表示移动 步数 S = 1

输出:
7,CAA
表示最少需要7步，能将所有盘子移到C柱上，CAA: 表示移动S=1步后，1号盘子在C柱上，2和3在A柱上

示例2
输入:
BACA
2
BACA表示1号盘 在B柱，2和4号盘在A柱，3号盘在C柱, S = 2

输出:
13,AABA
表示最少需要13步，能将所有盘子移到C柱上，移动S=2步后，1,2,4号盘子在A柱上，3在B柱上

示例3
输入:
BACA
18
表示1号盘 在B柱，2和4号盘在A柱，3号盘在C柱, S = 18

输出:
13,CCCC
表示最少需要13步，能将所有盘子移到C柱上，13步就已经完成目标，之后会一直维持CCCC状态

思路

1. 本来原题目是递归的，但初始状态改变之后，感觉还是BFS简单一点~
2. 先定义节点StepPoint，内有当前的盘子分布s，步骤数steps，以及之前的步骤path，用于输出；当然，还有记录走过的步骤的vis集合。
3. 每次遍历当前步骤下面的所有变化，若不是想要的结果就将其放入队尾，然后再从队首取新的步骤。
4. 那么怎么得到接下来的所有变化呢？注意一个限制：每次只能将一个柱子最上面的盘子放到其它柱子的最上面，且任何时刻不能将大号的盘子压在小号的盘子上面。然后基于题目的盘子的表达方式，我们可以得到下面规律：一个盘子可以转移到其前面没有的字符（柱子）上。比如：BACA，其编号分别为1234，那么对于1号盘子，它可以转移到A柱与C柱上；2号盘子，由于前面有B，可以转移到C柱上；3号盘子，无法转移；4号盘子，无法转移。

代码

#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <set>
#include <map>
#include <vector>
#include <functional>
#include <algorithm>

using namespace std;

class StepPoint {
public:
    string s;
    int step;
    vector<string> path;

    StepPoint(string s, int step) {
        this->s = s;
        this->step = step;
        path.push_back(s);
    }

    StepPoint(string s, StepPoint *t) {
        this->s = s;
        this->step = t->step;
        this->path = t->path;
    }
};

set<string> vis;
list<StepPoint *> steps;

void addList(string s, StepPoint *now) {
    if (vis.find(s) == vis.end()) {
        vis.insert(s);
        StepPoint* next = new StepPoint(s, now);
        next->step++;
        next->path.push_back(s);
        steps.push_back(next);
    }
}

void BFS(string s, string ans, int step) {
    StepPoint* now = new StepPoint(s, 0);
    StepPoint* next = NULL;

    while (now) {
        string ss = now->s;
        for (int i = 0; i < ss.length(); i++) {
            string tmp = ss;
            string sub = ss.substr(0, i);
            if (ss[i] == 'A' && sub.find('A') == string::npos) {
                if (sub.find('B') == string::npos) {
                    tmp[i] = 'B';
                    addList(tmp, now);
                }
                if (sub.find('C') == string::npos) {
                    tmp[i] = 'C';
                    if (tmp == ans) {
                        cout << now->step + 1 << "," << ((step <= now->step) ? now->path[step] : ans) << endl;
                        return;
                    }
                    addList(tmp, now);
                }
            }
            if (ss[i] == 'B' && sub.find('B') == string::npos) {
                if (sub.find('A') == string::npos) {
                    tmp[i] = 'A';
                    addList(tmp, now);
                }
                if (sub.find('C') == string::npos) {
                    tmp[i] = 'C';
                    if (tmp == ans) {
                        cout << now->step + 1 << "," << ((step <= now->step) ? now->path[step] : ans) << endl;
                        return;
                    }
                    addList(tmp, now);
                }
            }
            if (ss[i] == 'C' && sub.find('C') == string::npos) {
                if (sub.find('A') == string::npos) {
                    tmp[i] = 'A';
                    addList(tmp, now);
                }
                if (sub.find('B') == string::npos) {
                    tmp[i] = 'B';
                    addList(tmp, now);
                }
            }
        }

        delete(now);
        now = steps.front();
        steps.pop_front();
    }
}



int main(int args, char** argc) {
    string s = argc[1];
    int step = atoi(argc[2]);

    string ans = s;
    for (int i = 0; i < s.length(); i++) ans[i] = 'C';

    BFS(s, ans, step);

    system("pause");
    return 0;
}