搜索 水题&&错误集锦

引子：

本以为搜索的题目老师也不会检查，结果今天早上loli慢悠悠的说：“请同学们提交一下搜索的题目~”，顿时心旌摇曳，却也只能装作镇定自若的样子，点了点头。。

然后就开始了今天的疯狂做题，虽说题目都不是太难，但题多势众啊...

 

刷了那么多题，小有收获，总结+复习一下，也是为了以后避免类似错误（十分直观而又影响巨大的）

所做题目链接：openjudge  2.5  题面不一一附上

 

1.letters

看到这道题，就想到了前几天刚刚学会的STLmap映射，然后没怎么想就敲了一遍代码，结果跑的巨慢无比，然后下去跑操想明白了不用这么麻烦的做法，直接用一个vis数组就是了，看来长时间不做搜索大脑都僵化了。。

其他的就没什么技术含量了，和dfs模板差不多，

细节：1.运算种的i循环0-3就是4次

           2.起始点的vis为true

           3.A-Z ascill码为65-90

代码：

#include<iostream>
#include<cstring>

using namespace std;

int fx[4]={0,1,0,-1};
int fy[4]={-1,0,1,0};
int ans=0,d[200][200],n,m;
char a[25][25];bool vis[100];

int dfs(int x,int y,int z)
{
    ans=max(ans,z);
    for(int i=0;i<4;i++)//细节 
    {
        int xx=x+fx[i];
        int yy=y+fy[i];
        if(xx<=n&&xx>0&&yy<=m&&yy>0&&!vis[a[xx][yy]])
        {
            vis[a[xx][yy]]=true;
            dfs(xx,yy,z+1);
            vis[a[xx][yy]]=false;
        }
    }
}
int main()
{
    memset(vis,false,sizeof(vis));
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            cin>>a[i][j];
    vis[a[1][1]]=true;//细节 
    dfs(1,1,1);
    cout<<ans<<endl;
    return 0;
}

2&&3.八皇后&&问题

例题八皇后问题引申出的各种问题，比较简单，+注意细节

细节：

      1.横纵循环的次序，外层循环行号，内层循环列号

代码：

#include<iostream>
using namespace std;
int s=0,n,ans[20],h[100]={0},l[100]={0},a[100]={0},b[100]={0},anss[93][20];
void out()
{
    s++;
    for(int i=1;i<=8;i++)
      anss[s][i]=ans[i];  
}
int dfs(int k)
{
      //cout<<"12 ";
      for(int j=1;j<=8;j++)
        {
            if((h[j]==0)&&(a[k+j]==0)&&(b[k-j+8]==0))
            {
            ans[k]=j;
            h[j]=1;
            a[k+j]=1;
            b[k-j+8]=1;
            
            if(k==8)out();
              else dfs(k+1);
            h[j]=0;
            a[k+j]=0;
            b[k-j+8]=0;
            }
        }
}
int main()
{
    dfs(1);
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        for(int k=1;k<=8;k++)
          cout<<anss[x][k];
        cout<<endl;
    } 
}

#include<iostream>
using namespace std;
int s=0,n,ans[20],h[100]={0},l[100]={0},a[100]={0},b[100]={0},anss[93][20];
void out()
{
    s++;
//    if(s>4)return ;
    cout<<"No. "<<s<<endl;
    for(int i=1;i<=8;i++)
    {
      for(int j=1;j<=8;j++)
      {
          if(ans[j]==i)cout<<1<<" ";
          else
            cout<<0<<" ";
      }
      cout<<endl;
    }
}
int dfs(int k)
{
      //cout<<"12 ";
      for(int j=1;j<=8;j++)
        {
            if((h[j]==0)&&(a[k+j]==0)&&(b[k-j+8]==0))
            {
            ans[k]=j;
            h[j]=1;
            a[k+j]=1;
            b[k-j+8]=1;
            
            if(k==8)out();
              else dfs(k+1);
            h[j]=0;
            a[k+j]=0;
            b[k-j+8]=0;
            }
        }
}
int main()
{
//    cin>>n;//cout<<"123";
    dfs(1);
    cin>>n;
//    cout<<s;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        for(int k=1;k<=8;k++)
          cout<<anss[x][k];
        cout<<endl;
    } 
}

 4.迷宫

这道题是我做openjudge交的最多的一道题，足足交了30次，自己的dfs不知道出现了什么问题，就是不对，总是5分。。。

看了看提问区，五分的解决方法就是判断起点和终点，可是我明明判断了，无奈。。。

唯一的细节就是题目给出的特判，所以收获也就只有好好看题。

5.红与黑

又是一道模板题，注意的地方就是输入的行列是反着来的，

代码：

 

#include <iostream>
#include <cstring>
using namespace std;

int a[25][25];
int dx[5]={0,0,1,-1},dy[5]={1,-1,0,0};
int m,n,ans=0,xe,ye;

void dfs(int x,int y)
{
    ans++;
    a[x][y]=0;
    for(int i=0;i<=3;i++)
    {
        int xx=x+dx[i];
        int yy=y+dy[i];
        if(xx<=m&&xx>0&&yy<=n&&yy>0&&a[xx][yy]==1)
        {
            a[xx][yy]=0;
            dfs(xx,yy);
        }
    }
}

int main()
{
    while(cin>>n>>m)
    {
        memset(a,0,sizeof(a));
        ans=0;
        if(m==0&&n==0)break;
        for(int i=1;i<=m;i++)
          for(int j=1;j<=n;j++)
           {
            char x;
            cin>>x;
            if(x=='.')
              a[i][j]=1;
            if(x=='@')
            {
              a[i][j]=1;
              xe=i,ye=j;
            }
        }
        dfs(xe,ye);
        cout<<ans<<endl;
    }
    return 0;
}

 

6.棋盘问题

这道题第一次交的时候WA0分，主要是因为没好好看题，'#' 的地方才可以放棋子，可是受了上一道题的影响，+盲目自信没试样例2导致了如此惨剧的发生

收获：好好看题X2！！

 

7.取石子游戏

这明明就是递归，不知道为什么放到搜索上来= =

注意每次是谁先手，这里num=1为player1放棋子，player1设为先手拿旗子，

用3目运算符小装了一手，感觉良好，

这道题写了两遍，主要注意取到0获胜的到底是递归上一层的player还是这一层的player，总归最后还是理清了思路。

代码：

 

#include <iostream>
#include <cmath>
#include <cstdio>
#include <algorithm>

using namespace std;
int f(long long  a,long long  b,int num)
{
    if(a<b)swap(a,b);
    if(b==0)return num==1?2:1;
    if(a/b>=2)return num;
    a-=b;
    return f(a,b,num==1?2:1);
}
int main()
{
    long long  a,b;
    while(cin>>a>>b)
    {
        if(a==0&&b==0)break;
        if(f(a,b,1)==1)
          cout<<"win"<<endl;
        else
          cout<<"lose"<<endl;
    }
}

 

8.马走日

和dfs模板略有不同的特点可能是八个方向吧，每次走到ans++就好，一次AC

 

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int m,n,ans;
int dx[10]={1,1,2,2,-1,-1,-2,-2},dy[10]={2,-2,1,-1,2,-2,1,-1};
int vis[15][15];
void dfs(int x,int y,int s)
{
    if(s>n*m)
    {
        ans++;
        return;
    }
    for(int i=0;i<8;i++)
    {
        int xx=x+dx[i];
        int yy=y+dy[i];
        if(xx>=0&&xx<=n-1&&yy>=0&&yy<=m-1)
        if(!vis[xx][yy])
        {
            vis[xx][yy]=1;
            dfs(xx,yy,s+1);
            vis[xx][yy]=0;
        }
    }
}
int main()
{
    int u,a,b;
    cin>>u;
    while(u--)
    {
        memset(vis,0,sizeof(vis));
        cin>>n>>m>>a>>b;
        ans=0;
        vis[a][b]=1;
        dfs(a,b,2);
        cout<<ans<<endl;
    }
}

 

9.单词接龙

记得当时刚来集训，和Juan_feng一起讨论后A掉了这道题（多亏我机智的+1,虽然不知道原理），高兴了一手，

不过听loli讲我们这样做的效率很低，直接把能不能连接，连接后长度增加多少，先预处理出一个二维数组就可以，不用每次都搜索，效率会快很多，深思熟虑后确实是这样，不过代码是之前的版本，有点小懒

代码：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int m,n,ans;
int dx[10]={1,1,2,2,-1,-1,-2,-2},dy[10]={2,-2,1,-1,2,-2,1,-1};
int vis[15][15];
void dfs(int x,int y,int s)
{
    if(s>n*m)
    {
        ans++;
        return;
    }
    for(int i=0;i<8;i++)
    {
        int xx=x+dx[i];
        int yy=y+dy[i];
        if(xx>=0&&xx<=n-1&&yy>=0&&yy<=m-1)
        if(!vis[xx][yy])
        {
            vis[xx][yy]=1;
            dfs(xx,yy,s+1);
            vis[xx][yy]=0;
        }
    }
}
int main()
{
    int u,a,b;
    cin>>u;
    while(u--)
    {
        memset(vis,0,sizeof(vis));
        cin>>n>>m>>a>>b;
        ans=0;
        vis[a][b]=1;
        dfs(a,b,2);
        cout<<ans<<endl;
    }
}

10.分成互质组

一遍ac，小开心一手，

dfs每个数是加入之前的已经建立的组别 or 新开一个组

搜完统计一下组数就是了，

然后还有个剪枝：如果当前组别已经大于目前最优解就return，因为不可能对答案有贡献了，

这道题很怪异的是，我居然自己能把自己的错误卡掉，虽然效率低了一点。。

本来就打算拿部分分的，毕竟从来没有错误再卡掉的操作，结果ac了，有点开心

代码：

 

#include <iostream>
#define re register
#include <algorithm>

using namespace std;
int n,a[15],vis[15],ans=15,tot[15],z[15][15];

int gcd(int x,int y)
{
    if(y==0)return x;
    else
      return gcd(y,x%y);
}

void dfs(int k,int s)
{
    if(s>=ans)return ;
    if(k>n)
    {
        int pd=0;
        for(int i=0;i<=s;i++)
          pd+=tot[i];
        if(pd!=n)return;//卡掉自己不知道为什么会出现的错误 
        ans=min(ans,s+1);
        return ;
    }
    for(re int i=0;i<=s;i++)
    {
        bool flag=true;
        for(int l=1;l<=tot[i];l++)
        {
            if(gcd(z[i][l],a[k])!=1)
            {
                flag=false;
                break;
            }
        }
        if(flag)
        {
            tot[i]++;
            z[i][tot[i]]=a[k];
            dfs(k+1,s);
            tot[i]--;
        }
    }
    s++;
//    cout<<s;
    z[s][1]=a[k];
    tot[s]=1;
    dfs(k+1,s);
    s--;
    tot[s]=0;
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
      cin>>a[i];
    dfs(1,0);
//    cout<<"daole";
    cout<<ans;
}

 

11.分苹果

又是一道递归题，，

在OJ的递归和递推都有这道题，思维难度还是有的

代码：

#include<iostream>
using namespace std;
int put(int x,int y)
{
    if((x==1)||(y==1)||(y==0))
      return 1;
    if(x<y)
      return put(x,x); 
    if(x==y)
      return put(x,y-1)+1;
    if(x>y)
      return put(x,y-1)+put(x-y,y);
}
main()
{
    int n,x,y;
    cin>>n;
    
    for (int i=1;i<=n;i++)
    {
        cin>>x>>y;
        cout<<put(x,y)<<endl;
    }
    return 0;
}

 

啊终于写完了，

dfsOJ搜索水题的总结如上