九、Codeup墓地深搜【2019.12.14】

http://codeup.cn/problem.php?cid=100000608
A: 【递归入门】全排列
难度：D（签到题）
类型：基础递归

#include<bits/stdc++.h>
using namespace std;
int n;
int used[11],ans[11];
void dfs(int k)
{
    if(k==n+1)
    {
        for(int i=1;i<n;i++)
            printf("%d ",ans[i]);
        printf("%d\n",ans[n]);
        return ;
    }
    for(int i=1;i<=n;i++)
    {
        if(used[i]==0)
        {
            ans[k]=i;
            used[i]=1;
            dfs(k+1);
            used[i]=0;
        }
    }
}
int main()
{
    scanf("%d",&n);
    dfs(1);
    return 0;
}

B: 【递归入门】组合的输出
难度：D（签到题）
类型：基础递归

#include<bits/stdc++.h>
using namespace std;
int n,r;
int used[22];
int ans[22];
void dfs(int k)
{
    if(k==r+1)
    {
        for(int i=1;i<r;i++)
            printf("%d ",ans[i]);
        printf("%d\n",ans[r]);
        return ;
    }
    for(int i=ans[u-1]+1;i<=n;i++)
    {
        if(used[i]==0)
        {
            ans[k]=i;
            used[i]=1;
            dfs(k+1);
            used[i]=0;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&r);
    dfs(1);
    return 0;
}

C: 【递归入门】组合+判断素数
难度：C（水题）
类型：基础递归+判断素数
之前的做法：把所有素数筛出来，所有答案求出来再逐个判断

#include<iostream>
#include<cmath>
#include<stdlib.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#define maxn 1500000
using namespace std;
int n,r;
bool used[21];//存使用记录
int w[21];//存数据
int f[21];//存下标
int x[10000000];//存答案
int cnt=0;//答案数量
int prime[maxn];//存素数
int isprime[maxn];
int p=0;
int sieve(int m)
{
    for(int i=2;i<maxn;i++)
        isprime[i]=1;
    for(int i=2;i<=m;i++)
    {
        if(isprime[i])
        {
            prime[p++]=i;
            for(int j=2*i;j<=m;j+=i)
                isprime[j]=0;
        }
    }
    return p;
}
void dfs(int u)
{
    if(u==r+1)
    {
        for(int i=1;i<=n;i++)
            if(used[i])
                x[cnt]+=w[i];
        cnt++;
        return ;
    }
    for(int i=1;i<=n;i++)
    {
        if(!used[i]&&i>f[u-1])
        {
            f[u]=i;
            used[i]=1;
            dfs(u+1);
            used[i]=0;
        }
    }
    return ;
}
int main()
{
    scanf("%d%d",&n,&r);
    for(int i=1;i<=n;i++)
        scanf("%d",&w[i]);
    dfs(1);
    sieve(1000000);
    int k=0;
    for(int i=0;i<cnt;i++)
    {
        int flag=0;
        for(int j=0;j<p&&prime[j]<x[i];j++)
        {
            if(x[i]%prime[j]==0)
            {
                flag=1;
                break;
            }
        }
        if(flag==0)
            k++;
    }
    printf("%d\n",k);
    return 0;
}
/**************************************************************
    Problem: 5974
    User: ATLTA
    Language: C++
    Result: 正确
    Time:88 ms
    Memory:52800 kb
****************************************************************/

新做法：每求出一个答案立即判断（数据较大时会超时）

#include<bits/stdc++.h>
using namespace std;
int n,m;
int a[25]={0};
int used[25]={0};
int f[25];
int sum=0;
int num=0;
int judge(int n)
{
    if(n<=1)
        return 0;
    for(int i=2;i<=sqrt(n);i++)//"="!!!!
        if(n%i==0)
            return 0;
    return 1;
}
void dfs(int k)
{
    if(k==m+1)
    {
        sum=0;
        for(int i=1;i<=n;i++)
            if(used[i])
                sum+=a[i];
        if(judge(sum)==1)
            num++;
        return ;
    }
    for(int i=1;i<=n;i++)
    {
        if(used[i]==0&&i>f[k-1])
        {
            f[k]=i;
            used[i]=1;
            dfs(k+1);
            used[i]=0;
        }
    }
    return ;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    dfs(1);
    printf("%d\n",num);
    return 0;
}

D: 【递归入门】n皇后问题（原始的8皇后问题）
难度：C（水题）
类型：基础递归

#include<iostream>
#include<cmath>
#include<stdlib.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
int n;
int sum=0;
bool used[21];
int ans[21];
void dfs(int u)//行数
{
    if(u==n+1)
    {
        for(int i=1;i<=n-1;i++)
            printf("%d ",ans[i]);
        printf("%d\n",ans[n]);
        sum++;
        return ;
    }
    for(int i=1;i<=n;i++)//列数
    {
        int flag=0;
        for(int j=1;j<u;j++)
        {
            if(ans[j]==i||abs(ans[j]-i)==abs(j-u))
            {
                flag=1;
                break;
            }
        }
        if(!used[i]&&flag==0)
        {
            ans[u]=i;
            used[i]=1;
            dfs(u+1);
            used[i]=0;
        }
    }
    return ;
}
int main()
{
    scanf("%d",&n);
    dfs(1);
    if(sum==0)
        printf("no solute!\n");
    return 0;
}
/**************************************************************
    Problem: 5976
    User: ATLTA
    Language: C++
    Result: 正确
    Time:0 ms
    Memory:2020 kb
****************************************************************/

E: 【递归入门】出栈序列统计
难度：C（水题）
类型：模拟（栈）/卡特兰数
模拟写法：

#include<iostream>
#include<cmath>
#include<stdlib.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
int n;
int sum=0;
bool used[21];
int ans[21];
void dfs(int x,int y)//行数
{
    if(x==n&&y==n)
    {
        sum++;
        return ;
    }
    if(x<n)
        dfs(x+1,y);
    if(y<x&&y<n)
        dfs(x,y+1);
}
int main()
{
    scanf("%d",&n);
    dfs(0,0);
    printf("%d\n",sum);
    return 0;
}
/**************************************************************
    Problem: 5977
    User: ATLTA
    Language: C++
    Result: 正确
    Time:0 ms
    Memory:2020 kb
****************************************************************/

卡特兰数写法：

#include<iostream>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<set>
#include<list>
#include<queue>
#include<stack>
#include<vector>
#include<algorithm>
#define ll long long
using namespace std;
ll n;
const ll M=1000000007;//1e9+7
ll inv[100010];
ll last,now=1;
void init()
{
    inv[1]=1;
    for(int i=2;i<=n+1;i++)
        inv[i]=(M-M/i)*inv[M%i]%M;
}
int main()
{
    scanf("%lld",&n);
    n++;
    init();
    for(int i=2;i<=n;i++)
    {
        last=now;
        now=last*(4*i-2)%M*inv[i+1]%M;
    }
    printf("%lld\n",last);
    return 0;
}
/**************************************************************
    Problem: 5977
    User: ATLTA
    Language: C++
    Result: 正确
    Time:0 ms
    Memory:2800 kb
****************************************************************/

F: 【递归入门】走迷宫
难度：C（水题）
类型：基础递归（迷宫）

#include<iostream>
#include<cmath>
#include<stdlib.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
int n,m;
int sx,sy,ex,ey;
int dir[4][2]={0,-1,-1,0,0,1,1,0};
int ma[20][20];//是否可走
bool used[20][20];//是否走过
int ans[50][2];//记录路径
int cnt=0;
int sum=0;
void dfs(int x,int y)
{
    if(x==ex&&y==ey)
    {
        for(int i=0;i<cnt-1;i++)
            printf("(%d,%d)->",ans[i][0],ans[i][1]);
        printf("(%d,%d)\n",ans[cnt-1][0],ans[cnt-1][1]);
        sum++;
        return ;
    }
    for(int i=0;i<4;i++)
    {
        if(ma[x+dir[i][0]][y+dir[i][1]]==1&&used[x+dir[i][0]][y+dir[i][1]]==0)
        {
            used[x+dir[i][0]][y+dir[i][1]]=1;
            ans[cnt][0]=x+dir[i][0];
            ans[cnt++][1]=y+dir[i][1];
            dfs(x+dir[i][0],y+dir[i][1]);
            used[x+dir[i][0]][y+dir[i][1]]=0;
            cnt--;
        }
    }
    return ;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&ma[i][j]);
    scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
    used[sx][sy]=1;
    ans[cnt][0]=sx;
    ans[cnt++][1]=sy;
    dfs(sx,sy);
    if(sum==0)
        printf("-1\n");
    return 0;
}
/**************************************************************
    Problem: 5978
    User: ATLTA
    Language: C++
    Result: 正确
    Time:128 ms
    Memory:2020 kb
****************************************************************/