C++_学习随笔_牛郎织女迷宫

先上题目，

 

 

 

 

这个题...我用C++写了200+行的代码，不包括数据纠错（比如输入点超过了迷宫的限制，或者输入数据时输入的不是整数）

所以记录一下。

C++ vector自带的方法比较少，而且感觉不是很好用，几乎所有用到的方法都是重新写的。

 

我的思路是，已知牛郎的坐标（x1,y1） 然后织女的坐标(x2,y2)

那么无论牛郎怎么走，一定要走m=|x1-x2|个横坐标，n=|y1-y2|个纵坐标（先不考虑封闭房间）

并且路线一定是C(m+n,n)条（排列组合）。

我使用0 表示牛郎在x轴上走了一步，用1 表示牛郎在y轴上走了一步。

这样就能表示一条路径，比如牛郎在上图中的a点，织女在b点，那么 000111 就表示牛郎先向右走了3步，然后向下走了3步

当我们知道了两人的坐标后，也就知道了0的个数和1的个数，以上图为例，我们要求的路径就是 000111 这六个数字的无重复全排列。

这样我们就知道了所有牛郎走向织女的可能路径。接下来就要排除被封闭房间所挡住的路径。

以同样的方法，我们求出所有 牛郎通向封闭房间（在牛郎和织女之间的封闭房间）的路径，然后再删除 牛郎通向织女路径中 前部分与之重合的路径。

以上图为例，我们找到了一条通向封闭房间的路径，0011，接下来删除所有以 0011 开头的 牛郎通向织女的路径，然后重复这一过程，直至所有经过该封闭房间的路径都被删除，

再以同样的方法检索剩余的封闭房间。

最终剩下的，就是所有不经过封闭房间的 牛郎通向织女的路径。

 

另，在求全排列这个地方卡住了好久，最终找到一种巧妙的算法并改了改。

大概就是，先排出最小的路径，比如000111，然后从该数串的最后开始 ，选取两个数字进行比较，直到找到前一个数字比后一个数字小，在目前这个只有0 和1模型中就是找到“01”，

然后将左边这个0与最靠后的1进行交换，比如001110，然后把原来0位置后面的所有元素翻转，最终变成001011。这就是仅大于000111的排列，按照上述方法不断重复，最终就能按照从小到大的顺序找全所有的 排列。

我可能说的不太明白。我参考的是https://blog.csdn.net/morewindows/article/details/7370155中的非递归全排列方法。

贴上代码：

#include<iostream>
#include<vector>
#include<string>
using namespace std;

int min(int a, int b) {
    if (a < b)
        return a;
    else
        return b;
}

int max(int a, int b) {
    if (a > b)
        return a;
    else
        return b;
}

void Swap(int* a, int* b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void deleteVector(vector<vector<int>>& v, int i) {
    //删除v中第i条路径
    vector<int>* x, * y, temp;
    x = &v[i];
    y = x + 1;
    for (int n = 0; n < v.size() - i - 1; n++) {
        temp = *x;
        *x = *y;
        *y = temp;
        x++; y++;
    }
    v.pop_back();

}

void showVector(vector<int>v) {
    //打印一条路径
    for (int i = 0; i < v.size(); i++) {
        cout << v[i] << ",";
    }
    cout << endl;
}

void showVector(vector<vector<int>> v) {
    //打印所有路径
    for (int i = 0; i < v.size(); i++) {
        cout << "第 " << i + 1 << "条路线：";
        for (int j = 0; j < v[0].size(); j++) {
            cout << v[i][j] << ",";
        }
        cout << endl;
    }
}

void TurnLanguage(vector<vector<int>> v,string x,string y) {
    //转换成自然语言的路径
    for (int i = 0; i < v.size(); i++) {
        cout << "第" << i + 1 << "条路线为： 从起始点开始-";
        for (int j = 0; j < v[0].size(); j++) {
            if(v[i][j]==0)
                cout << x << "-";
            else
                cout << y << "-";
        }
        cout << endl;
    }
}

void reverseVector(int* a, int* b) {
    //翻转 vector，vector自带的reverse老报错，没看出所以然来，所以重新写了个
    while (a < b) {
        Swap(a++, b--);
    }
}

void all_path(vector<int> first_path, vector<vector<int>>& allthepath) {
    //通过第一条路径 推算出所有路径
    bool hasnext = true;
    int* p, *q,*m,*the_end,counter=1;
    the_end = &first_path[first_path.size() - 1];
    m = &first_path[first_path.size() - 1];
    p = &first_path[first_path.size() - 1];
    q = &first_path[first_path.size() - 2];

    allthepath.push_back(first_path);

    while (hasnext) {
        if (*q >= *p) {
            //不触发
            q--; p--;
            if (p == &first_path[0]) {
                hasnext = false;
                break;
            }
        }
        else {
            //递增出现，触发,准备交换
            counter++;
            while (*m != 1) {
                m--;
            }
            Swap(m, q);
            reverseVector(p, the_end);
            //cout << "find "<<counter<<" path!:          " ;
            //showVector(first_path);
            the_end = &first_path[first_path.size() - 1];
            m = &first_path[first_path.size() - 1];
            p = &first_path[first_path.size() - 1];
            q = &first_path[first_path.size() - 2];
            int reverse_counter = first_path.size() - 1;
            allthepath.push_back(first_path);
        }

    }
}

int main() {
    int row, column;
    int x_m, y_m, x_f, y_f;
    int boxes;
    int steps_x, steps_y;
    vector<int> boxes_x,boxes_y;
    
    cout << "Please input the row and column:" << endl;
    cin >> row>>column;
    cout << "Please input niulang'x_ord and y_ord:" << endl;
    cin >> x_m >> y_m;
    cout << "Please input zhinv'x_ord and y_ord:" << endl;
    cin >> x_f >> y_f;
    cout << "How many boxes do you want?";
    cin >> boxes;
    for (int i = 0; i < boxes; i++) {
        int temp_x, temp_y;
        cout << "Please input the x_ord and y_ord of " << i +1<< " box" << endl;
        cin >> temp_x >> temp_y;
        boxes_x.push_back(temp_x);
        boxes_y.push_back(temp_y);
    }
    steps_x = abs(x_m - x_f);
    steps_y = abs(y_m - y_f);
    //创建一个最小的数 作为第一条路径
    vector<int> thefirst_path;
    vector<vector<int>> solution;
    for (int i = 0; i < steps_x; i++) {
        thefirst_path.push_back(0);
    }
    for (int j = 0; j < steps_y; j++) {
        thefirst_path.push_back(1);
    }
    all_path(thefirst_path,solution);
    showVector(solution);
    //删除路线中被盒子挡住的
    for (int i = 0; i < boxes; i++) {
         //筛除不在路径上的盒子
        if (boxes_x[i]<=max(x_f,x_m)&&boxes_x[i]>=min(x_f,x_m)&&boxes_y[i]>=min(y_m,y_f)&&boxes_y[i]<=max(y_m,y_f)) {
            //记录所有牛郎通向盒子的路径
            int x_distance, y_distance;
            vector<int> firstpath_NiuAndBox;
            vector<vector<int>> paths_NiuAndBox;
            x_distance = abs(x_m - boxes_x[i]);
            y_distance = abs(y_m - boxes_y[i]);
            for (int j = 0; j < x_distance;j++) {
                firstpath_NiuAndBox.push_back(0);
            }
            for (int j = 0; j < y_distance; j++) {
                firstpath_NiuAndBox.push_back(1);
            }
            all_path(firstpath_NiuAndBox,paths_NiuAndBox);
            cout << "-----------"<<endl;
            showVector(paths_NiuAndBox);
            //删除牛郎通向织女的 且通过该盒子的路径
            int same_counter=0;
            for (int k = 0; k < paths_NiuAndBox.size(); k++) {
                //先处理牛郎通向盒子的第k条路径
                for (int u = 0; u < solution.size();u++) {
                    //与牛郎通向织女的第u条路径比较
                    same_counter = 0;
                    for (int v = 0; v < paths_NiuAndBox[0].size();v++) {
                        //通向盒子的 第k，v个元素与通向织女的第u，v个元素进行比较，如果全中，则删除该条牛郎通向织女的路径
                        if (paths_NiuAndBox[k][v] == solution[u][v]) {
                            same_counter++;
                        }
                        if (same_counter  == paths_NiuAndBox[0].size()) {
                            //全中，删除且u--
                            
                            deleteVector(solution,u);
                            u--;
                        }
                    }
                }
            }

        }
        
    }
    cout << "---------------------" << endl;
    showVector(solution);
    cout << "---------------------" << endl;
    //转换成自然语言
    cout << "所以，可行方案如下：" << endl;
    string vector_x,vector_y;
    if (x_m > x_f)
        vector_x = "左";
    else
        vector_x = "右";
    if (y_m > y_f)
        vector_y = "下";
    else
        vector_y = "上";

    TurnLanguage(solution, vector_x, vector_y);
}

 

 

同时 输入为 （5，5） 行列　（这个行列我都没用到...）

（4，1） 牛郎坐标

（1，4） 织女坐标

  1            封闭房间个数

（2，3） 封闭房间坐标

的结果：

 

 

 

第一块表示所有不考虑封闭房间的牛郎织女路径

第二块表示牛郎到封闭房间的路径

第三块表示 第一块去掉所有第二块开头的，也就是不经过该封闭房间的路径。

最终转换为自然语言。

 

感觉应该有更巧妙的方法，希望有大佬指正，我这代码也太多了。