AlgarithmLearning_Day3.1 (《算法笔记》第四章入门篇（2）算法初步）

本文链接：https://blog.csdn.net/qq_42645708/article/details/116134508

昨天整理到了全排列，之后书籍马上就对全排列进行了“实例化”，给了一个“n皇后问题”。即一个n*n的棋盘中放着n个皇后棋子，要求皇后与皇后彼此之间行列不可相等，也不能在同一条对角线上。
表面看可能和全排列有点关系，仔细一思考，这就是全排列啊，一点差没有，除了可以根据实际问题剪枝优化外就没什么差别了，不过代码真的是值得借鉴的，思维的转化也非常重要。
如果把N列皇后所在的行号依次写出，那就是1~n的一个排列。而每一列都有不同的行号。我们以每一列为基准进行循环，这样排列数目就不再是全枚举量，只需要 ( n！) 次，而剪枝之后需要的次数更少。先上未剪枝代码：

void generatePrince(int index){
    //整体写法就是参照了全排列，不过这个递归方法可以进行剪枝
    //这也是为什么我叫这个方法是二叉树，其实多问题不过就是N叉树
    //剪枝就是若在一次循环中前面的子问题出现了皇后的同对角线情况，后面的皇后不论如何排列，只要拥有前置排列，就不可能成立
    //剪枝就是在有子排列不符合要求的基础上进行提前的break或者return
    //很直接，也不需要添加多少代码，参照generatePrincePlus

    if (index == n + 1){                    //递归边界，生成一个排列,这里对所有到达n+1边界的排列进行了判断，有很多无用计算
        bool flag = true;                   //flag为true表示当前排列为一个合法方案（局部变量）
        for (int i = 1; i <= n; ++i) {      //遍历任意两个皇后，判断他们的位置是否符合关系
            for (int j = 1+i; j <= n; ++j) {
                if (abs(i - j) == abs(P[i] - P[j])){ //如果在同一条对角线上
                    flag = false; //不合法，不合法就跳出了
                }
            }
        }
        if (flag){
            count++;  //循环之后若依然合法，则表示当前皇后组合都合法
                      //全局变量司马
        }
        return;
    }
    for (int x = 1; x <= n; ++x) {
        if (hashTable[x] == false){
            P[index] = x;
            hashTable[x] = true;
            generatePrince(index+1);
            hashTable[x]=false;
        }
    }
}

一开始就很明显的两个循环，这就是(n!)的编程形式，因为占用了第一列一个格子的话，第二列那一行就不能取到了。即全排列的12345之后是12354，每次装满之后都进行一次判断，装满也可以近似看作为深度同样的二叉树的路径，判断完一个路径后判断下一个路径。具体上，是因为底下的for循环：

    for (int x = 1; x <= n; ++x) {
        if (hashTable[x] == false){
            P[index] = x;
            hashTable[x] = true;
            generatePrince(index+1);
            hashTable[x]=false;
        }
    }

哈希表中装的是是否在x行存储数据，而每个index都代表列数，需要存储在不同列不同行，随着index推进，只需要寻找哈希表中对应x位置是false的位置就可以寻找到不同行的了。而由于递归所有的可能，这个思想就很奇妙，从12345->12354这一步就蕴含着很有趣的思想，首先是递归到x=4，到 index+1=5 ，循环五次发现 x=5 时候哈希表才是false。传入index+1=6发现前面都是false，回到x=5，哈希表变为false，回到x=4，哈希表变为false，可是x=4的时候for循环还能向后走，即在index=4的时候x=5又是一次可能性，同理，向前也是这么推进，将所有的可能性遍历。
我们在遍历的时候可以思考一件事情，在遍历所有可能性的时候可坑会遇到一些问题，因为遍历是线性的，这种方法是需要将这个数组装满才能进行判断。然而，同对角线的情况可能在前几列就已经出现了，这样后面的遍历都是无用的计算，会加大我们的时间复杂度，占用多余的内存。下面会进行剪枝：


void generatePrincePlus(int index){
    //优化了上面的算法，书中称之为回溯法
    if (index == n+1){//到达边界的一定合法，不合法的在下面代码过滤
        count++;
        return;
    }
    for (int x = 1; x <= n; ++x) {      //第x行
        if (hashTable[x] == false){     //第x行没有皇后
            bool flag = true;           //flag为true表示当前皇后不会和之前的皇后冲突，这里是初始化
            for (int i = 1; i < index; ++i) {//遍历之前的皇后
                //第index列皇后的行号为x，第i列皇后的行号为P[i]
                if (abs(index - i) == abs(x-P[i])){
                    flag = false;
                    break;
                }//这就是剪枝
            }//for
            if (flag){//如果可以把皇后放在第x行
                P[index]     =    x;
                hashTable[x] = true;
                generatePrincePlus((index+1));
                hashTable[x] = false;
            }//这个是遍历树所用的，中序遍历递归
        }
    }
}

这里可以看到，在判断到达边界之后直接就count++了，而不像上面的代码一样先进行判断再自增。这是因为在循环中不符合条件的，即处于同一对角线的排列都排除了，因为在遍历过程中每次装入一个数据都总体进行遍历判断元素之间是否同对角线。表面上这样增加了判断次数，增加了程序的复杂度。但实际上子集的遍历增量是按照指数增量增长，要是在前面就判断好了，后面能节省的遍历时间是非常值得的。判断后就是看需不需要进行下一位的遍历，遍历方式还是不变，不过这次if中的判断因子是 flag ，是true的情况下是没有冲突的，此时需要没有冲突才能进行递归，不能像上面的方法一样只要要求列中没有安排数字就进行，因为这个算法的优势就是对无用循环的及时掐断。

大体就是这样，晚上回到宿舍复习，明天再敲一遍代码。递归+hash，有点吃不消。这个题俩for就搞定的，呜呜呜不过确实优化的程度没有递归hash程度高。加油啊高桑！！