简单搜索专题

2016-08-10

题源：http://acm.hust.edu.cn/vjudge/contest/65959#overview

A - 棋盘问题

思路：要放k个棋子，dfs贪心深搜。

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN=10;
int mmap[MAXN][MAXN];  //棋盘
bool vis[MAXN];    //标记数组 vis[1]=true表示1行已放棋子
int n,k;

int ans;
int sum;  //记录已经放了多少个旗子

void dfs(int i)
{
    if(sum==k)
    {
        ans++;
        return;
    }
    if(i>=n) return;
    for(int j=0;j<n;j++)
    {
        if(!vis[j]&&mmap[i][j])
        {
            sum++;
            vis[j]=true;
            dfs(i+1);
            sum--;
            vis[j]=false;
        }
    }
    dfs(i+1);  //第i行不放
}

int main()
{
    while(cin>>n>>k&&n!=-1&&k!=-1)
    {
        char temp;
        ans=0;
        sum=0;
        memset(mmap,0,sizeof(mmap));
        memset(vis,false,sizeof(vis));
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                cin>>temp;
                if(temp=='#')
                    mmap[i][j]=1;
            }
        }
        dfs(0);
        cout<<ans<<endl;

    }

    return 0;
}

B - Dungeon Master

题意：给你一个三维的矩阵，L层，R行，L列。起点为S，终点为E，'#'表示墙，'.'表示路。可以上下左右前后六个方向走，每走一格耗时1min，问怎样最快到达终点。

思路：用广搜的特性：最短路，bfs即可。

代码：

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

using namespace std;

const int MAXN=50;

char mmap[MAXN][MAXN][MAXN];   //地图
int L,R,C;              //L表示层数，R表示行数，C表示列数


bool vis[MAXN][MAXN][MAXN];   //标记数组
int path[MAXN][MAXN][MAXN];   //记录路径值
struct cubes     //三位坐标点结构体
{
    int l,r, c;
} s,e;     //s表示起点，e表示终点
queue<cubes> q;


bool bfs(cubes x)   //出入起点s给x
{
    memset(path,0,sizeof(path));
    memset(vis,false,sizeof(vis));
    vis[x.l][x.r][x.c]=true;
    bool escape=false;     //标记是否成功逃离迷宫
    while(!q.empty()) q.pop();
    int dl[6]= {0,0,0,0,1,-1};    //前后上下左右6个方向
    int dr[6]= {1,-1,0,0,0,0};
    int dc[6]= {0,0,-1,1,0,0};
    cubes now,tmp;
    tmp=x;
    q.push(tmp);
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(mmap[now.l][now.r][now.c]=='E')
        {
            escape=true;
            break;
        }

        for(int i=0; i<6; i++)
        {
            tmp.l=now.l+dl[i];           //6个方向都找一遍
            tmp.r=now.r+dr[i];
            tmp.c=now.c+dc[i];

            if(tmp.l>0&&tmp.l<=L&&tmp.r>0&&tmp.r<=R&&tmp.c>0&&tmp.c<=C)   //判断越界
                if(!vis[tmp.l][tmp.r][tmp.c]&&(mmap[tmp.l][tmp.r][tmp.c]=='.'||mmap[tmp.l][tmp.r][tmp.c]=='E'))
                {
                    vis[tmp.l][tmp.r][tmp.c]=true;
                    path[tmp.l][tmp.r][tmp.c]=path[now.l][now.r][now.c]+1;
                    q.push(tmp);
                }
        }


    }
    return escape;
}

int main()
{

    while(cin>>L>>R>>C&&L&&R&&C)
    {
        for(int l=1; l<=L; l++)
        {
            for(int r=1; r<=R; r++)
            {
                for(int c=1; c<=C; c++)
                {
                    cin>>mmap[l][r][c];
                    if(mmap[l][r][c]=='S')
                    {
                        s.l=l;
                        s.c=c;
                        s.r=r;
                    }
                    if(mmap[l][r][c]=='E')
                    {
                        e.l=l;
                        e.r=r;
                        e.c=c;
                    }
                }
            }
        }

        if(bfs(s))
            cout<<"Escaped in "<<path[e.l][e.r][e.c]<<" minute(s)."<<endl;
        else
            cout<<"Trapped!"<<endl;
        /*for(int i=1; i<=L; i++)
        {
            for(int j=1; j<=R; j++)
            {
                for(int k=1; k<=C; k++)
                    cout<<path[i][j][k]<<" ";
                cout<<endl;
            }
            cout<<endl;

        }*/


    }

    return 0;
}

C - Catch That Cow

题意：一条直线上，你在点N处，要到达目标点K点。

走的时候只能有两种选择（假如现在在X点）：

1.到达x-1点或者到达x+1点；2.到达x*2点处。

每种选择耗时相同，问怎样最快到达目标点。

思路：bfs....直接贴代码

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;

const int MAXN=100005;
int N,K;
int path[MAXN*2+1];  //记录步数
bool vis[MAXN*2+1];  //标记数组
queue<int> q;
void bfs(int N)
{
    memset(path,0,sizeof(path));
    memset(vis,false,sizeof(vis));

    while(!q.empty()) q.pop();
    int now;
    q.push(N);
    vis[N]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now==K)
        {
            break;
            //return;
        }

        if(!vis[now+1]&&(now+1)<=100000&&(now+1)>=0)
        {

            vis[now+1]=true;
            path[now+1]=path[now]+1;
            q.push(now+1);
        }
        if(!vis[now-1]&&(now-1)<=100000&&(now-1)>=0)
        {
            vis[now-1]=true;
            path[now-1]=path[now]+1;
            q.push(now-1);
        }
        if(!vis[now*2]&&(now*2)<=100000&&(now*2)>=0)
        {
            vis[now*2]=true;
            path[now*2]=path[now]+1;
            q.push(now*2);
        }


    }
}

int main()
{
    while(cin>>N>>K)
    {
        if(N>K) cout<<N-K<<endl;  //要注意这个地方，起点>终点
        else
        {
            bfs(N);
            cout<<path[K]<<endl;
        }
    }
    return 0;
}

D - Fliptile

题意：给你一个矩阵，每个点有一个带数字的牌子（一面为0，一面为1），你可以翻动任意牌子，使所有牌子为0的面朝上，翻动规则如下：

翻动某一牌子，该牌子的上下左右方向的牌子会跟着它一起翻动。

问最少多少次可以完成任务。

思路：bfs+二进制压缩。这里有一个很"显然"（看了别人的报告才"显然"的）的规律：从第二行开始，每行翻牌的时候要看上一行的状态，如果上一行为1，那么就翻，使上一行为0，否则就不翻。直到翻到最后一行，判断最后一行是否全为0，如果是，则记录翻的次数。如果不是，则直接返回。

那么问题就好解决了，只需把第一行的状态枚举一遍即可，求出最小的次数。

因为只有0,1。所以可以用二进制记录。

看代码：

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

using namespace std;

const int MAXN=16;

int mmap[MAXN][MAXN];
int f[MAXN][MAXN];  //mmap记录现在状态，为0还是1。f记录翻转状态,0为不翻，1为翻
int t[MAXN][MAXN];  //临时数组

int m,n;    //m行n列
int ans,cnt;   //cnt代表步数
int p;        //记录最优解时 第一行怎样翻

int di[5]={0,-1,1,0,0};   //记录原地和四个方向
int dj[5]={0,0,0,-1,1};

void flip(int x,int y)
{

    cnt++,f[x][y]=1;
    for(int i=0;i<5;i++)
    {
        int ti=x+di[i];
        int tj=y+dj[i];
        if(ti>-1&&tj>-1)  //判断是否越界
            t[ti][tj]^=1;   //0变1,1变0
    }

}

bool ok(int k)   //k记录第0行的现状态
{
    cnt=0;          //初始化步数
    memcpy(t,mmap,sizeof(t)); //将原始数组拷贝到临时数组
    for(int j=0;j<n;j++)       //先判断第0行哪一列为1，然后翻转
    {
        if(k&(1<<(n-1-j)))
            flip(0,j);
    }

    for(int i=1;i<m;i++)     //第0行翻完了，从1行开始翻一直到m-1行
    {
        for(int j=0;j<n;j++)
        {
            if(t[i-1][j])    //如果该列上一行为1，就翻转
                flip(i,j);
        }
    }

    for(int j=0;j<n;j++)     //判断最后一行有没有1，如果有返回false
        if(t[m-1][j]) return false;
    return true;
}

int main()
{
    while(cin>>m>>n)
    {

        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
                cin>>mmap[i][j];
        }

        ans=m*n+1;   //更新记录最小步数
        p=-1;
        for(int k=0;k<(1<<n);k++)
        {

            if(ok(k)&&ans>cnt)
            {
                p=k;
                ans=cnt;
            }
        }

        memset(f,0,sizeof(f));
        if(p>=0)   //说明该题有解
        {
            ok(p);   //再模拟一下第0行,然后输出f
            for(int i=0;i<m;i++)
                for(int j=0;j<n;j++)
                    printf("%d%c",f[i][j],j<n-1?' ':'
');
        }
        else
            puts("IMPOSSIBLE");


    }
    return 0;
}

 E - Find The Multiple

题意：给你一个正整数n,编程找到一个能整除n的最小数m,m只能由0,1组成。

思路：bfs，搜的时候从1开始，每次由两种选择，1*10,1*10+1，知道搜到第一个满足题意的数即可。（嫌慢的话，还有一个方法，打表。。毕竟数据不大）

代码：

#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstring>
#include <queue>

#define ll long long


using namespace std;



ll n;
 queue<ll> q;
void bfs(ll s)
{


    while(!q.empty()) q.pop();
    q.push(s);
    while(!q.empty())
    {
        ll tmp=q.front();
        q.pop();
        if(tmp%n==0)
        {
            cout<<tmp<<endl;
            break;
        }
        q.push(tmp*10);
        q.push(tmp*10+1);
    }

}

int main()
{
    while(cin>>n&&n)
    {

       if(n==1)
        cout<<1<<endl;
       else
            bfs(1);
    }

    return 0;
}

/*
int main()
{
    ll arr[]={1,10,111,100,10,1110,1001,1000,111111111,10,
              11,11100,1001,10010,1110,10000,11101,1111111110,11001,
              100,10101,110,110101,111000,100,10010,1101111111,100100,
              1101101,1110,111011,100000,111111,111010,10010,11111111100,
              111,110010,10101,1000,11111,101010,1101101,1100,1111111110,
              1101010,10011,1110000,1100001,100,100011,100100,100011,11011111110,110,
              1001000,11001,11011010,11011111,11100,100101,1110110,1111011111,1000000,10010,
              1111110,1101011,1110100,10000101,10010,10011,111111111000,10001,1110,11100,1100100,
              1001,101010,10010011,10000,1111111101,111110,101011,1010100,111010,11011010,11010111,
              11000,11010101,1111111110,1001,11010100,10000011,100110,110010,11100000,11100001,11000010,
              111111111111111111,100,101,1000110,11100001,1001000,101010,1000110,100010011,110111111100,1001010111,
              110,111,10010000,1011011,110010,1101010,110110100,10101111111,110111110,100111011,111000,11011,1001010,
              10001100111,11101100,1000,11110111110,11010011,10000000,100100001,10010,101001,11111100,11101111,11010110,
              11011111110,11101000,10001,100001010,110110101,100100,10011,100110,1001,1111111110000,11011010,100010,1100001,
              11100,110111,11100,1110001,11001000,10111110111,10010,1110110,1010100,10101101011,100100110,100011,100000,11101111,
              11111111010,1010111,1111100,1111110,1010110,11111011,10101000,10111101,111010,1111011111,110110100,1011001101,
              110101110,100100,110000,100101111,110101010,11010111,11111111100,1001111,10010,100101,110101000,1110,100000110,
              1001011,1001100,1010111010111,110010,11101111,111000000,11001,111000010,101010,110000100,1101000101,
              1111111111111111110,111000011,1000};
    int n;
    while(cin>>n&&n)
        cout<<arr[n-1]<<endl;
    return 0;

}
*/

F - Prime Path

题意：输入m,n。求出并打印m,n之间的素数路径有多少个元素。下一个素数由上一个素数变换一位数字而来。

思路：按照题意模拟一下，直接搜即可。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MAXN=10001;

int m,n;
int step;
int mmin=-1;
int path[MAXN];  //存路径长度
int vis[MAXN];  //标记数组

bool is_prime(int a)   //素数判断
{
    if(a<2) return false;
    for(int i=2;i*i<=a;i++)
    {
        if(a%i==0)
            return false;
    }
    return true;
}

void change(int &tmp,int i,int num)  //把tmp的第i位变成num，（从右往左数第i位）
{
   int di=1;
   for(int ii=0;ii<i;ii++)
        di*=10;
    di/=10;
    int tmp1=tmp/di;
    int tmp2=tmp1%10;
    tmp2*=di;
    tmp-=tmp2;
    tmp+=num*di;

}

void bfs(int x)
{
    queue<int> q;
    memset(path,0,sizeof(path));
    memset(vis,false,sizeof(vis));

    while(!q.empty()) q.pop();
    q.push(x);
    vis[x]=true;
    while(!q.empty())
    {
        int tmp=q.front();
        //cout<<tmp<<" ап:";
        q.pop();
        if(tmp==n)   //出口
        {
            mmin=tmp;
            break;
        }

        int mtmp=tmp;
        for(int i=1;i<=4;++i)
        {
            for(int num=0;num<10;++num)
            {

                  change(mtmp,i,num);
                  if(is_prime(mtmp)&&!vis[mtmp]&&mtmp>=1000)
                  {
                      path[mtmp]=path[tmp]+1;

                      vis[mtmp]=true;
                      q.push(mtmp);
                      //cout<<mtmp<<"---";

                  }
                  mtmp=tmp;

            }
        }
        //cout<<endl;
    }
}

int main()
{

    int T;
    cin>>T;
    while(T--)
    {

        cin>>m>>n;
        if(m>n) swap(m,n);
        bfs(m);
        cout<<path[mmin]<<endl;
    }

    return 0;
}

 G - Shuffle'm Up

题意：两摞牌s1,s2，洗牌的时候按下图洗。

洗完之后变成s12,然后把s12上面部分的牌变成s1,剩下的变成s2，继续重复图中步骤洗牌。

牌用大写字母代替，输入s1,s2，和sans（都是字符串），问能否用最小的步数洗牌变成sans。能就输出多少步，否则输出-1。

思路：模拟即可，用map记录一下每种结果是否已经出现过。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
using namespace std;

const int MAXN=101;
char s1[MAXN],s2[MAXN];
char s12[MAXN<<1|1];
char sans[MAXN<<1|1];   //目标字符串（洗完牌之后的结果）

map<string,bool> mmap;

void shuffle(char s1[],char s2[],char s12[])  //洗牌过程
{
    memset(s12,'',sizeof(s12));
    int len1=strlen(s1);
    int len2=strlen(s2);
    int len12=len1+len2;
    int i=0,j=0,k=0;

    int signal=1;
    while(k<len12)
    {
        if(signal)
            s12[k++]=s2[j++];
        else
            s12[k++]=s1[i++];
        signal^=1;
    }
}

void split(char s12[],char s1[],char s2[])  //把s12拆分成s1,s2
{
    memset(s1,'',sizeof(s1));
    memset(s2,'',sizeof(s2));
    int len12=strlen(s12);
    int len1,len2;
    len1=len2=len12/2;
    int k=0;
    for(int i=0;i<len1;i++)
        s1[i]=s12[k++];
    for(int j=0;j<len2;j++)
        s2[j]=s12[k++];
}

int main()
{

   int T;
   cin>>T;
   for(int t=1;t<=T;t++)
   {
       memset(s1,'',sizeof(s1));
       memset(s2,'',sizeof(s2));
       memset(s12,'',sizeof(s12));
       memset(sans,'',sizeof(sans));
       mmap.clear();

       int c;
       cin>>c;
       for(int i=0;i<c;i++)
            cin>>s1[i];
       for(int i=0;i<c;i++)
            cin>>s2[i];
       for(int i=0;i<2*c;i++)
            cin>>sans[i];

        cout<<t<<" ";
        int time=1;
        int step=0;
        int ok=0;

        while(time++)
        {
            shuffle(s1,s2,s12);
            if(mmap[(string)s12]==true)
                break;
            else
                mmap[(string)s12]=true;
            step++;

            if(!strcmp(s12,sans))
            {
                ok=1;
                break;
            }
            else
                split(s12,s1,s2);
        }
        if(!ok)
            cout<<-1<<endl;
        else
            cout<<step<<endl;


   }




   /*   //下面这些只是一个mmap插入的测试
   char str1[]="abcde";
   //string str=(string)str1;
   int value=1;
   for(int i=0;i<5;i++)
   {
       mmap.insert(pair<string,bool>(str1,true));
       str1[0]='A'+value;
       value++;
   }

   for(map<string,bool>::iterator it=mmap.begin();it!=mmap.end();it++)
   {
       cout<<it->first<<"--"<<it->second<<endl;
   }
   */
    return 0;
}

H - Pots

题意：有两个空水壶，pot1,pot2。操作有6种：

FILL(1):用水把pot1填满，

FILL(2):用水把pot2填满，

DROP(1):把pot1里的水全部倒掉，

DROP(2):把pot2的水全部倒掉，

POUR(1,2):把pot1里的水倒在pot2里，如果pot2能盛下，就全部倒过去，如果盛不下，把pot2倒满，pot1剩点。

POUR(2,1):同POUR(1,2)，只不过从pot2倒向pot1。

输入a,b,c。a,b分别表示pot1和pot2的容量，c表示要量出的体积(即怎样操作使pot1或者pot2中水的体积为c)，

输出操作步骤。

思路：用一个结构体记录pot1和pot2的状态，搜索即可。还是比较麻烦的，看代码。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>

using namespace std;

const int MAXN=150;

string op[6]={"FILL(1)","FILL(2)","DROP(1)","DROP(2)","POUR(1,2)","POUR(2,1)"}; //6中操作

int a,b,c;

struct node   //这个结构体记录每步操作的信息。
{
    int prex;  //上一个操作的x
    int prey;  //上一个操作的y
    int step;  //当前操作的步数
    int op;    //记录第几种操作
}v[MAXN][MAXN];

struct point   //记录pot1和pot2的状态
{
    int x,y;
};

void dfs_print(int x,int y)   //递归输出 每种操作
{
    if(x==0&&y==0)
        return;
    dfs_print(v[x][y].prex,v[x][y].prey);

    cout<<op[v[x][y].op]<<endl;

}

void bfs()
{
    queue<point> Q;
    point s,q;
    s.x=s.y=0;  //初始化pot1,pot2为0
    v[0][0].step=1;
    Q.push(s);

    while(Q.size())
    {
        s=Q.front();
        Q.pop();

        if(s.x==c||s.y==c)  //如果达到目标体积输出
        {
            cout<<v[s.x][s.y].step-1<<endl;
            dfs_print(s.x,s.y);
            return;
        }
        for(int i=0;i<6;i++)  //6种操作
        {
            q=s;
            if(i==0)
                q.x=a;
            else if(i==1)
                q.y=b;

            else if(i==2)
                q.x=0;

            else if(i==3)
                q.y=0;
            else if(i==4)
            {
                if(q.x<=b-q.y)
                {

                    q.y+=q.x;q.x=0;
                }
                else
                {
                    q.x-=(b-q.y);
                    q.y=b;
                }
            }
            else
            {
                if(q.y<=a-q.x)
                {

                    q.x+=q.y;q.y=0;
                }
                else
                {

                    q.y-=(a-q.x);q.x=a;
                }
            }
            if(v[q.x][q.y].step==0)
            {
                v[q.x][q.y].step=v[s.x][s.y].step+1;
                v[q.x][q.y].op=i;
                v[q.x][q.y].prex=s.x;
                v[q.x][q.y].prey=s.y;
                Q.push(q);
            }


        }
    }

    cout<<"impossible"<<endl;

}

int main()
{
    while(cin>>a>>b>>c)
    {
        memset(v,0,sizeof(v));
        bfs();
    }

    return 0;
}

K - 迷宫问题

水题，直接贴代码。

代码：

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

const int MAXN=5;

int mapp[MAXN][MAXN];

struct point
{
    int x,y;
};

struct vis
{
    int prex,prey;
    int step;
}v[MAXN][MAXN];   //记录路径

void dfs(int x,int y)   //递归输出路径
{
    if(x==0&&y==0)
    {
        printf("(%d, %d)
",x,y);
        return;
    }

    dfs(v[x][y].prex,v[x][y].prey);
    printf("(%d, %d)
",x,y);
}

void bfs()
{
    queue<point> Q;
    point s,q;
    int dx[4]={1,-1,0,0};   //四个方向
    int dy[4]={0,0,-1,1};
    s.x=0;s.y=0;
    v[s.x][s.y].step=1;
    Q.push(s);
    while(!Q.empty())
    {
        s=Q.front();
        Q.pop();
        if(s.x==4&&s.y==4)
        {
            dfs(s.x,s.y);
        }
        for(int i=0;i<4;i++)
        {
            q.x=s.x+dx[i];
            q.y=s.y+dy[i];
            if(q.x>=0&&q.x<5&&q.y>=0&&q.y<5&&!mapp[q.x][q.y]&&v[q.x][q.y].step==0)  //判断越界和是否访问过
            {
                v[q.x][q.y].step=v[s.x][s.y].step+1;
                v[q.x][q.y].prex=s.x;
                v[q.x][q.y].prey=s.y;
                Q.push(q);
            }
        }

    }

}

int main()
{
    memset(v,0,sizeof(v));
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            cin>>mapp[i][j];
        }
    }

    bfs();
    return 0;
}

--------------------------------没了------------------------------------