dfs需要剪枝

问题 G: 优美的排列

题目描述
假设有从 1 到 N 的 N 个整数，如果从这 N 个数字中成功构造出一个数组，使得数组的第 i 位 (1 <= i <= N) 满足如下两个条件中的一个，我们就称这个数组为一个优美的排列。条件：

I. 第 i 位的数字能被 i 整除
II. i 能被第 i 位上的数字整除

现在输入一个整数 N，请问可以构造多少个优美的排列？

输入
输入样例由多组测试数据组成。每组测试数据第一行输入一个正整数 N （ 1 <= N <= 15 )
输出
输出可以构造的优美的排列的数量
样例输入
2
样例输出
2
提示
参照输入样例：

第 1 个优美的排列是 [1, 2]:
第 1 个位置（i=1）上的数字是1，1能被 i（i=1）整除
第 2 个位置（i=2）上的数字是2，2能被 i（i=2）整除

第 2 个优美的排列是 [2, 1]:
第 1 个位置（i=1）上的数字是2，2能被 i（i=1）整除
第 2 个位置（i=2）上的数字是1，i（i=2）能被 1 整除

AC代码：

#include<bits/stdc++.h>
using namespace std;
int n,ans,k;
int a[25];
bool vis[25];
void dfs(int m){
    for(int i=1;i<=n;i++){
        if(vis[i]==false&&(m%i==0||i%m==0)){
            a[m]=i;
            vis[i]=true;
            if(m==n){
                ans++;
            }
            dfs(m+1);
            vis[i]=false;
        }
    }
}
int main(){
    while(cin>>n){
        memset(vis,false,sizeof(vis));
        k=0;
        ans=0;
        dfs(1); 
        /*for(int i=0;i<k;i++){
            for(int j=1;j<=n;j++){
                cout<<s[i][j];
            }
            cout<<endl;
        }
         
        for(int i=0;i<k;i++){
            bool flag=true;
            for(int j=1;j<=n;j++){
                if(s[i][j]%j!=0&&j%s[i][j]!=0){
                    flag=false;
                    break;
                }
            }
            if(flag) ans++;
        }*/
        cout<<ans<<endl;
    }
    return 0;
}
//0,1,2,3,8,10,36,41,132,250,700,750,4010,4237,10680,24679

之前的傻逼 代码：

#include<bits/stdc++.h>
using namespace std;
int s[16]={0,1,2,3,8,10,36,41,132,250,700,750,4010,4237,10680,24679};
int main(){
    int n;
    while(cin>>n){
        cout<<s[n]<<endl;
    }
    return 0;
} 
//时间很长，慢慢跑，下次进行优化 
/*#include<bits/stdc++.h>
using namespace std;
int n,ans,k;
int a[25];
bool vis[25];
void dfs(int m){
    for(int i=1;i<=n;i++){
        if(vis[i]==false){
            a[m]=i;
            vis[i]=true;
            if(m==n){
                bool flag=1;
                for(int i=1;i<=n;i++){
                    if(a[i]%i!=0&&i%a[i]!=0){
                        flag=0;
                        break;
                    }
                }
                if(flag) ans++;
            }
            dfs(m+1);
            vis[i]=false;
        }
    }
}
int main(){
    while(cin>>n){
        memset(vis,false,sizeof(vis));
        k=0;
        ans=0;
        dfs(1); 
        for(int i=0;i<k;i++){
            for(int j=1;j<=n;j++){
                cout<<s[i][j];
            }
            cout<<endl;
        }
         
        for(int i=0;i<k;i++){
            bool flag=true;
            for(int j=1;j<=n;j++){
                if(s[i][j]%j!=0&&j%s[i][j]!=0){
                    flag=false;
                    break;
                }
            }
            if(flag) ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}*/

思考过程：

1. 先是dfs全排列确定全部排列，存入数组；
2. 把数组一个个判断过来是否符合；
   特别特别的荣幸，超时了；
   然后我就让他慢慢跑；
   我敲，跑的太慢了；

然后就开始剪枝；

直接在存入数组的时候判断是否符合，
好处：

1. 取消了数组存数；
2. 如果不符合直接返回，少了很多不必要的操作；

总结：dfs又爱又恨