7.4回溯法

1.八皇后问题：

构建算法的思考：

①分别选择64个格子中含8个元素的子集，再分别判断是否合适，利用排列组合可解，但是情况太多了，需要4.42*10^9种

②发现规律：恰好每行放一个皇后共8!=40320种方案（算是枚举时尽量减少判断次数）

//回溯解决n皇后问题
#include <iostream>
#include <stdio.h>
#include <string.h>
#include<queue>
#include<vector>
using namespace std;
int A[99],zhi = 0;
void solve(int n,int *A,int cur)
{
    if(cur == n)  //当cur指向n时，跳出程序，这是说明到达底层，n行已经考虑完毕
    {
        for(int i = 0;i < n;i++) printf("%d ",A[i]);
        printf("---------%d\n",zhi++);
    }
    else  //很重要,这里定义程序出口
    for(int i = 0;i < n;i++)  //在这一行上一共有n个位置，n种情况，挨个遍历
    {
        A[cur] = i;
        int flag = 1;
        for(int j = 0;j < cur;j++) //判断是否有冲突,j的边界为什么不包含cur？想不明白
            if(A[cur] == A[j] || cur - A[cur] == j - A[j] || cur + A[cur] == j + A[j])  //既然是横行放置，则皇后不会横向攻击，只需要判断是否纵向攻击和斜向攻击即可，cur代表着行数，A[cur]代表着列数，行-列相等，则代表在对左上角，cur+A[cur]相等代表在右上角，妙判啊！！！！
            {flag = 0;break;}
        if(flag) solve(n,A,cur + 1);
    }
}
int main()
{
    int A[99],n;
    cin>> n;
    solve(n,A,0);
    return 0;
}

//另一种回溯解决n皇后问题
#include <iostream>
#include <stdio.h>
#include <string.h>
#include<queue>
#include<vector>
using namespace std;
int A[99],zhi = 0,vis[3][100];
void solve(int n,int *A,int cur)
{
    if(cur == n)  //当cur指向n时，跳出程序，这是说明到达底层，n行已经考虑完毕
    {
        for(int i = 0;i < n;i++) printf("%d ",A[i]);
        printf("---------%d\n",zhi++);
    }
    else  //很重要,这里定义程序出口
    for(int i = 0;i < n;i++)  //在这一行上一共有n个位置，n种情况，挨个遍历
        if(!vis[0][i] && !vis[1][cur + i] && !vis[2][cur - i + n])  //cur代表当前行,i代表当前列,主对角线标示cur-i可能为负，要加上n
        {
            A[cur] = i;
            vis[0][i] = vis[1][cur + i] = vis[2][cur - i + n] = 1;  //vis表示已经放置的皇后占据了哪些列、主对角线、副对角线
            solve(n,A,cur + 1);
            vis[0][i] = vis[1][cur + i] = vis[2][cur - i + n] = 0;  //回溯法中修改了辅助的全局变量，则一定要及时恢复原状,避免回溯别的可能性时出现问题
        }
}
int main()
{
    int A[99],n;
    cin>> n;
    memset(vis,0,sizeof(vis));
    solve(n,A,0);
    return 0;
}

2.回溯的定义：当把问题分成若干个步骤并且递归求解时，如果当前步骤没有合法选择，则函数返回上一级递归调用而不是继续递归，这种现象叫做回溯。

递归枚举算法常被称作回溯法。

3.乱入——递归的小例子：

         main()
         {
             int num=1,sn;
             sn=add(num);
             printf("%d/n",sn);
             getch();
         }

         int add(int num)
         {
             static int sn;  //static能保证本次初始化的值是上次执行后的值，这样也就保证了前面想加的结果不会丢失。（因为sn不是全局变量，改成全局变量也行）
             sn+=num;
             if(num==100) return sn;
             add(++num);
         }

4.例题7-4素数环：

自己大概先编了一下，以下是我自己的代码，思路是枚举所有的排序方法，边枚举边判断，及时break，和刘汝佳思路一样：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include<queue>
#include<vector>
using namespace std;
int A[16],is_prime[32]={0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0};  //判断素数打表
void solve(int n,int *A,int cur)
{
    if(cur == n)
    {
        int flag = 1;
        if(!is_prime[A[0] + A[n - 1] + 1]) flag = 0;
        if(flag)
        {
            for(int i = 0;i < n;i++)
                printf("%d ",A[i]+1);
            printf("\n");
        }
    }
    else
    {
        if(cur == 0) {A[cur] = 0;solve(n,A,cur + 1);}
        else
        for(int i = 0;i < n;i++)
        {
            A[cur] = i;
            int flag = 1;
            if(!is_prime[A[cur] + A[cur - 1] +1] && cur) {flag = 0;continue;}  //不符合条件及时退出
            for(int j = 0;j < cur;j++)
                if(A[cur] == A[j]) {flag = 0;break;}
            if(flag) solve(n,A,cur + 1);
        }
    }
}
int main()
{
    int n,kase = 0;
    while(cin>>n)
    {
        printf("Case %d:\n",++kase);
        solve(n,A,0);
        printf("\n");
    }
    return 0;
}

下面是刘汝佳的代码，思路和我的一样，但是细节实现有差别：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include<queue>
#include<vector>
using namespace std;
int A[16],vis[16],is_prime[33]={0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0};
void dfs(int n,int *A,int cur)
{
    if(n == cur && is_prime[A[0] + A[n - 1]])
    {
        for(int i = 0;i < n;i++)
            printf("%d ",A[i]);
        printf("\n");
    }
    else
    for(int i = 2;i <= n;i++)  //对本题来说，应该把1先拿出来，因为第一个数总是1而且要判断前后和是否是素数
    {
        if(!vis[i] && is_prime[i + A[cur - 1]])
        {
            A[cur] = i;  //用了一个“使用标志”
            vis[i] = 1;
            dfs(n,A,cur + 1);
            vis[i] = 0;  //记住一定要归零啊，不归零就跪了
        }
    }

}
int main()
{
    int n,kase = 0;
    while(cin>>n)
    {
        memset(vis,0,sizeof(vis));
        printf("Case %d:\n",++kase);
        A[0] = 1;
        dfs(n,A,1);
        printf("\n");
    }
    return 0;
}