搜索专题解题报告

最新推荐文章于 2023-04-09 12:22:51 发布
最新推荐文章于 2023-04-09 12:22:51 发布
阅读量376 收藏 1
点赞数
分类专栏： 搜索 文章标签： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leohujx/article/details/47304441
版权

1001：简单模拟题

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 500010
int main()
{
    while(sf(n)!=EOF){
        ll ans=1;
        n--;
        while(n--){
            ans = (ans+1)*2;
        }
        pfI(ans);
    }
return 0;
}

1002：按照题目要求，简单判断即可。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 500010
char ch[55];
int main(){
    int t;
    sf(t);
    while(t--){
        sfs(ch);
        int len = strlen(ch);
        if(len<8 || len>16){
            printf("NO\n");
            continue;
        }
        int flag1=0,flag2=0,flag3=0,flag4=0;
        for(int i=0;i<len;i++){
            if(ch[i]>='A' && ch[i]<='Z')
                    flag1=1;
            else if(ch[i]>='a' && ch[i]<='z')
                flag2=1;
            else if(ch[i]>='0' && ch[i]<='9')
                flag3=1;
            else
                flag4=1;
        }
        if(flag1+flag2+flag3+flag4>=3){
            printf("YES\n");
        }else
            printf("NO\n");
    }
return 0;
}

1003：原题链接
hdu1241
题目就是求‘@’的联通子块的数目，联通的条件是上下左右相邻或者在用一条对角线上相邻。直接DFS即可，从’@’符号开始，边搜索边记录搜索过的块。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 500010
char mp[110][110];
int vis[110][110];
bool check(int x,int y){
    if(x<0 || x>=n || y<0 || y>=m || mp[x][y] == '*' || vis[x][y])
         return false;
    return true;
}
void dfs(int x,int y){
    if(vis[x][y]) return;
    vis[x][y]=1;
    if(check(x-1,y)) dfs(x-1,y);
    if(check(x+1,y)) dfs(x+1,y);
    if(check(x,y-1)) dfs(x,y-1);
    if(check(x,y+1)) dfs(x,y+1);
    if(check(x-1,y-1)) dfs(x-1,y-1);
    if(check(x-1,y+1)) dfs(x-1,y+1);
    if(check(x+1,y-1)) dfs(x+1,y-1);
    if(check(x+1,y+1)) dfs(x+1,y+1);
    return;
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(sfd(n,m)!=EOF && n){
        for(int i=0;i<n;i++){
            sfs(mp[i]);
        }
        memset(vis,0,sizeof vis);
        int ans=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(mp[i][j] == '@' && !vis[i][j]){
                    ans++;
                    dfs(i,j);
                }
            }
        }
        printf("%d\n",ans);
    }
return 0;
}

1004：原题链接
hdu1242

题目给出一个地图，‘#’代表不可走的位置，’.’代表可走的位置，’a’代表angel所在的位置,’r’代表angel朋友所在的位置，’x’代表该位置有个守卫。求angel朋友能否就出angel，如果能，输出需要的最短时间。我们注意，一个angel有好几个朋友，所以我们把angel当做起点，用bfs搜索，一旦搜到某个位置是angel朋友所在的位置，那么此时一定是最短的时间，输出该时间即可。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 500010
char mp[210][210];
int vis[210][210];
struct Node{
    int x,y;
    int step;
};
bool check(int x,int y){ //判断边界的函数
    if(x<0 || x>=n || y<0 || y>=m || mp[x][y] == '#' || vis[x][y])
         return false;
    return true;
}
int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
void bfs(int x,int y){
    queue<Node> q;
    memset(vis,0,sizeof vis);
    Node cur,next;
    cur.x = x;
    cur.y = y;
    cur.step = 0;
    vis[x][y] = 1;
    q.push(cur);
    int ans=-1;
    while(!q.empty()){
        cur = q.front();
        q.pop();
        for(int i=0;i<4;i++){
            next.x = cur.x+dir[i][0];
            next.y = cur.y+dir[i][1];
            if(!check(next.x,next.y)) continue;
            vis[next.x][next.y] = 1;
            if(mp[next.x][next.y] == '.'){ //'.'可走，需1个单位的时间
                next.step = cur.step+1;
                q.push(next);
            }else if(mp[next.x][next.y] == 'r'){ //'r'为终点
                next.step = cur.step+1;
                ans = next.step;
                break;
            }else if(mp[next.x][next.y] == 'x'){//'x'可走，走需要1个单位时间，杀死该位置守卫需要1个单位，共2个单位时间
                next.step = cur.step+2;
                q.push(next);
            }
        }
    }
    if(ans == -1) //如果ans==-1,说明Angel并不能到达她朋友所在的位置
        printf("Poor ANGEL has to stay in the prison all his life.\n");
    else
        printf("%d\n",ans);
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(sfd(n,m)!=EOF){
        for(int i=0;i<n;i++){
            sfs(mp[i]);
        }
        int stx,sty;
        int flag=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(mp[i][j] == 'a'){
                    stx = i;
                    sty = j;
                    flag=1;
                    break;
                }
            }
            if(flag) break;
        }
        bfs(stx,sty);
    }
return 0;
}

1005：原题链接
hdu1728
题意不难懂。我们注意题目中所求的是最少的拐弯数，这和到达某一个点所经过的最短步数是不一样的。在求最短步数时，如果某个点被访问过了，那第二次就不访问了。但是在求最少的拐弯数时，我们并不能这样做。原因如图：
图片源
图中从起点到终点标有两条路，它们的步数是一样的，但是蓝色的拐弯数少，如果代码中我们先通过红色那条路访问到了终点，那么蓝色就不能再次访问终点了，但是就本题来说，显然蓝色的路更优。
所以，点是可以被重复访问的。
那么我们应该怎么做，使得点可以被重复访问，但是又不至于使得一些无用的点入队列那？我们还是使用vis[i][j]，但是此时，vis[i][j]代表到达(i,j)这个点时，所需要的最小拐弯数，如果有其他点到达该点时所经过的拐弯数大于vis[i][j],那么显然，该状态肯定不是最优的，将其舍弃即可。当然，还有种做法就是从一个点一直走，走到走不了为止，那样下一次就得拐弯了。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
struct Loc {
    int x;
    int y;
    int step;               //记录行走到某个点时转过的弯
    int pre;                 //记录走到某个点的方式（直走，反向，左转或者右转）
};
int dir[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
int sa, sb, ea, eb;
queue<Loc> q;
int m, n;
char map[110][110];            //记录一副地图
int vis[110][110];                //记录走到某个点时最小的转弯数目
int k;                                //最大允许转弯的次数
int flag;
void bfs() {
    for (int i = 0; i < 110; i++)
        for (int j = 0; j < 110; j++)
            vis[i][j] = INF;             //初始化转弯的次数（必定要大于题目允许的最大值）
    while (!q.empty())
        q.pop();
    Loc cur, next;
    cur.x = sa;
    cur.y = sb;
    cur.step = -1;
    cur.pre = -1;                                //初始化
    //cur.step=0;
    vis[cur.x][cur.y] = 0;
    q.push(cur);
    while (!q.empty()) {
        cur = q.front();
        q.pop();
        if (cur.x == ea && cur.y == eb && cur.step <= k) {
            flag = 1;
            return;
        }
        for (int i = 0; i < 4; i++) {
            next = cur;                            //先把之前的方向记录到下一个点
            next.x = cur.x + dir[i][0];
            next.y = cur.y + dir[i][1];
            if (next.x < 0 || next.x >= m || next.y < 0 || next.y >= n
                    || map[next.x][next.y] == '*')
                continue;
            if (next.pre == -1)            //如果还未拐过弯
            {
                next.pre = i;               //记录当前的方向
                next.step = 0;                //初始化转弯次数
                if (vis[next.x][next.y] >= next.step){ //如果在这一点的最小转弯次数大于当前走到这一点转弯的次数，那么更新转弯次数，并将符合条件的点入队
                    vis[next.x][next.y] = next.step;
                    q.push(next);
                }
            } else {
                if (cur.pre == i) { //如果该点行进的方向与之前的方向相同，那么只需更新转弯次数就好了，方向在之前已经初始化过了
                    if (vis[next.x][next.y] >= next.step) {
                        vis[next.x][next.y] = next.step;
                        q.push(next);
                    }
                }
                else {          //如果方向不同
                    next.step += 1;
                    next.pre = i;        //如果不同（注意！这里掉头也算转弯！），那么更新转弯次数以及方向
                    if (vis[next.x][next.y] >= next.step) //这里判断一下next.setp是否小于k,这样可以进行优化
                    {
                        vis[next.x][next.y] = next.step;
                        q.push(next);
                    }
                }
            }
        }
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    while (t--) {
        flag = 0;
        scanf("%d%d", &m, &n);
        for (int i = 0; i < m; i++)
            scanf("%s", map[i]);
        scanf("%d%d%d%d%d", &k, &sb, &sa, &eb, &ea);    //注意：该题输入时是先输入列在输入行
        sa--;   //我们的输入是从0开始的，而题目中的输入是从1开始的
        sb--;
        ea--;
        eb--;
        bfs();
        if (flag)
            printf("yes\n");
        else
            printf("no\n");
    }
    return 0;
}

1006：原题链接
hdu1175
题意也不难懂。这题和1005还是挺相似的。
我们同样用vis[i][j]来标记到达(i,j)这个点时经过的最小拐弯数。看懂了1005的话1006也不难。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
struct Loc {
    int x;
    int y;
    int step;                      //记录行走到某个点时转过的弯
    int dir;                          //记录走到某个点的方式（直走，反向，左转或者右转）
};
int n,m,k;
int mp[1010][1010];
int vis[1010][1010];        //vis[i][j]记录到达某个点最小的拐弯数,
int stx,sty,edx,edy;
int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
bool check(int x,int y){
    if(x<0 || x>=n || y<0 || y>=m)
        return false;
    return true;
}
bool bfs(){
    queue<Loc> q;
    for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++)
            vis[i][j] = INF;        //初始化
    Loc cur,next;
    cur.x = stx;
    cur.y = sty;
    cur.dir = -1;
    cur.step = 0;
    q.push(cur);
    while(!q.empty()){
        cur = q.front();
        q.pop();
        if(cur.x == edx && cur.y == edy && cur.step<=2){ //到达了终点且拐弯数小于等于2
            return true;
        }
        for(int i=0;i<4;i++){
            next.x = cur.x+dir[i][0];
            next.y = cur.y+dir[i][1];
            if(!check(next.x,next.y)) continue; //出界了
            next.step = cur.step;
            next.dir = i;
            if(next.dir != cur.dir && cur.dir != -1)//方向不同且刚开始的方向不为-1(即刚开始未定方向时)
                next.step++;
            if(next.step>2) continue;//如果拐弯数大于2,那么该状态就没用了，舍弃
            if(mp[next.x][next.y] && !(next.x==edx&&next.y==edy)) continue;//next位置上为非零数字且该位置不是终点，舍弃
            if(vis[next.x][next.y]>=next.step){ //符合条件，入队
                vis[next.x][next.y] = next.step;
                q.push(next);
            }
        }
    }
    return false;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(sfd(n,m)!=EOF){
        if(n ==0 && m==0) break;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                sf(mp[i][j]);
            }
        }
        sf(k);
        for(int i=0;i<k;i++){
            scanf("%d%d%d%d",&stx,&sty,&edx,&edy);
            stx--;sty--;edx--;edy--;
            if(stx == edx && sty == edy){ //如果起点和终点一样，那么指向的是同一块，无法消去
                printf("NO\n");
                continue;
            }
            if(mp[stx][sty] == 0 || mp[edx][edy] == 0){ //某个块是空位置
                printf("NO\n");
                continue;
            }
            if(mp[stx][sty] != mp[edx][edy]){ //要消的两个块不是同个种类的
                printf("NO\n");
                continue;
            }
            if(bfs()) printf("YES\n");
            else
                printf("NO\n");
        }
    }
    return 0;
}

1007:原题链接
题目大意就是给你一个n，让你将1,2,3….n围成一个环，相邻两个数的和要为素数，按字典序输出所有符合排列。
直接用dfs即可，用过的数用vis[i]=1标记，如果这个数在此位置用的不对，那么用vis[i]=0改回来。
此题如果统计一下就知道，在范围里面，除了1以外的奇数，都不可能围成一个素数环。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 110
#define N 11010
int f[M];
//vector<int> v[N];
int tmp[25];
int vis[25];
int cnt;
void Init(){              //素数筛选，如果f[i]==0,说明i为素数
    memset(f,0,sizeof f);
    for(int i=2;i<M;i++){
        if(f[i]) continue;
        for(int j=i;i*j<M;j++)
            f[i*j] = 1;
    }
}
void dfs(int cur){
    if(cur == n){
        for(int i=0;i<n;i++)
            printf("%d%c",tmp[i],i+1==n?'\n':' ');
        cnt++;
        return;
    }
    for(int i=2;i<=n;i++){
        if(vis[i]) continue; //每个数字只能使用一次
        if(f[tmp[cur-1]+i]) continue; //如果相邻的数之和不为素数，舍弃
        if(cur == n-1){
            if(f[tmp[cur-1]+i] || f[i+tmp[0]]) continue; //如果是该素数环的最后一个部分，那么得判断它和它之前以及它和该素数环的第一个数之和是否都为素数
        }
        tmp[cur] = i;
        vis[i] = 1; //标记
        dfs(cur+1);
        vis[i] = 0; //恢复标记
    }
    return;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    Init();
    int kas=1;
    while(sf(n)!=EOF){
        cnt=0;
        memset(vis,0,sizeof vis);
        tmp[0]=1;         //环的第一个为1
        vis[1]=1;
        printf("Case %d:\n",kas++);
        if(n==1 || n%2==0) //不是偶数或者1的话就不用搜了，肯定不能组成素数环
         dfs(1);
//      printf("%d\n",cnt);
        printf("\n");
    }
    return 0;
}

1008：原题链接
hdu1045
题目大意就是给一个n*m地图，里面有两种符号，’.’和’X’，我们所做的就是在’.’处放置blackhouse，条件是同行或者同列不能同时放置超过一个的blackhouse，除非两两之间有’X’符号挡着。问最多可以放置多少blackhouse。
这道题目。。其实我没用搜索，当然，搜索也是可以的。。首先看数据，一共就4*4格子，我暴力枚举，最多也就2^16次的复杂度。所以我用了二进制的枚举，枚举一个二进制串，如果某个位置为1，那么我就在该位置放置blackhouse，如果为0，就不放。放完以后判断下是否符合条件，符合条件的话就更新放置的数目。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 110
#define N 11010
int f[M];
char mp[10][10];
char nmap[10][10];
int vis[10][10];
int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int getTheMap(int x){
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            nmap[i][j] = mp[i][j];

    int id=0;     //记录当前是第几个格子
    int xx,yy;
    int res=0;  //记录放置的格子数
    while(x){
        if(x&1){ //x状态下某个格子需要放置blackhosue
            xx = id/n;  //当前格子数/n得到该格子所在的行坐标
            yy = id%n;  //当前格子数%n得到该格子所在的列坐标
            if(nmap[xx][yy] == 'X') return -1; //如果我们当前要放置blackhouse的地方有‘X’，那就放不了，说明该状态无效
            nmap[xx][yy] = 'S'; //我们用‘S’来代表此处有个blackhouse
            res++; //记录放置的格子数
        }
        id++;
        x>>=1;
    }
    return res;
}
bool check(int x,int y){ //判断是否出界或者是否有'X'挡着
    if(x<0 || x>=n || y<0 || y>=n || nmap[x][y] == 'X')
        return false;
    return true;
}
bool ok(int x,int y){

    for(int i=0;i<4;i++){   //从(x,y)处遍历其所在的行和列
        int xx = x+dir[i][0];
        int yy = y+dir[i][1];
        while(check(xx,yy)){
            if(nmap[xx][yy] == 'S') return false; //如果在同一行或者同一列还有blackhouse，那么不符合题目条件，返回false
            xx += dir[i][0];
            yy += dir[i][1];
        }
    }
    return true;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(sf(n)!=EOF && n){
        for(int i=0;i<n;i++)
            sfs(mp[i]);
        int tot = 1<<(n*n); //一共的状态数目
        int ans=0;
        for(int i=1;i<tot;i++){
            int tmp = getTheMap(i); //在i状态下得到新的地图
            if(tmp == -1) continue; //该状态无效
            int flag=1;
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    if(nmap[j][k] == 'S'){ //我们从放置blackhouse处遍历它的行和列
                        if(!ok(j,k)){
                            flag=0;
                            break;
                        }
                    }
                }
                if(!flag) break;
            }
            if(flag){ //如果符合条件，那么更新ans(tmp是getTheMap()的返回值，代表放置blackhouse的格子数)
                ans = Max(ans,tmp);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

1009：原题链接
题目大意不难懂。其实我发现这道题目当时虽然过了。但是交到poj上挂了。。然后我就改了改。
其实输出解不难，主要问题是我们怎么避免重复。
比如 3 1 1要等于4，我们先输出3+1，但是后面还有一个1，我们怎么避免再输出一次？这里我们用一个pre记录上一次从这里搜索时的值，如果这次搜索的值还为pre，那么我们就不继续搜索。这样子就能有效地避免重复。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 110
#define N 11010
int a[15];
int tmp[15];
int t;
int flag;
void dfs(int cur,int sum,int id){ //cur代表此时存结果数组的下标，sum代表此时的和，id代表我们在某一层搜索到了原数组中的第几个，下次从它开始搜索即可
    if(sum == t){
        for(int i=0;i<cur;i++){
            printf("%d%c",tmp[i],i+1==cur?'\n':'+');
            flag=1;
        }
        return;
    }
    if(sum>t) return; //如果sum>t，那么不符合条件，返回
    int pre=-1;             //pre要在这里定义！
    for(int i=id;i<=n;i++){
        if(a[i] == pre) continue; //如果上一次在这里搜索过的值和这次要搜索的值相同，那么就舍弃
        if(sum+a[i]>t) continue; //如果当前的和+a[i]超过了t，那么舍弃
        pre = a[i];  //pre在此赋值
        tmp[cur] = a[i];
        dfs(cur+1,sum+a[i],i+1); //继续搜索下一层，下标+1，和+a[i],id+1
    }
    return;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(sfd(t,n)!=EOF && n){
        for(int i=1;i<=n;i++)
            sf(a[i]);
        flag=0;
        printf("Sums of %d:\n",t);
        dfs(0,0,1);
        if(!flag)
            printf("NONE\n");
    }
    return 0;
}

1010：原题链接
题目大意就是从‘S’出发到达’D’，问你是否在时间t那一时刻能够到达’D’。注意每个可走的地方都只能走一次，包括’S’和’D’。
首先，我们知道，如果可走的位置总数如果还小于t,那么肯定是无解的，这算是一个特判。
搜索的代码很简单，关键在于剪枝。
有这么两个剪枝条件：
1.假设我们当前所在的位置为(x,y)，已经经过了tm时间，那么能到达终点(edx,edy)最短时间为 tm+abs(x-edx)+abs(y-edy)，如果这个时间还大于t，那么说明这个状态不可能达到时间t，也就没有必要再搜下去了，舍弃。
2.这个是关键，叫做奇偶剪枝，百度百科的定义在此，简单来说，如果此时坐标为(x,y)，那么到达终点(edx,edy)最短步数为abs(x-edx)+abs(y-edy)，那么无论你怎么走，最终到达终点所经过的步数的奇偶性，综合最短步数的奇偶性是一样的。不信你可以自己画图看看。所以啊，假设tmp1=abs(x-edx)+abs(y-edy)，此时已经过tm时间，那么还剩余tmp2 =t-tm,如果tmp1和tmp2的奇偶性不同，那么无需再搜，该状态无效，怎么都不可能从(x,y)到达(edx,edy)而刚好花费t-tm时间。
做到以上两个剪枝，此题就可以解决。

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define ll __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,k;
#define M 110
#define N 11010
char mp[10][10];
int vis[10][10];
int t;
int flag;
int edx,edy;
int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
bool check(int x,int y){
    if(x<0 || x>=n || y<0 || y>=m || mp[x][y] == 'X')
        return false;
    return true;
}
bool getDis(int x,int y,int tm){
    int ddis = abs(x-edx)+abs(y-edy);
    if(ddis+tm>t) return false; //第一个剪枝
    if(ddis%2 != (t-tm)%2) return false;  //第二个剪枝，奇偶剪枝
    return true;
}
void dfs(int x,int y,int cur){ //x,y代表当前的位置，cur代表经过的时间
    if(x == edx && y == edy && cur == t){
        flag=1;
        return;
    }
    if(!getDis(x,y,cur)) return; //剪枝
    if(flag) return;
//  if(cur>t) return;
    for(int i=0;i<4;i++){         //选择符合条件的点进行搜索
        int xx = x+dir[i][0];
        int yy = y+dir[i][1];
        if(!check(xx,yy)) continue;
        mp[xx][yy] = 'X';
        dfs(xx,yy,cur+1);
        mp[xx][yy] = '.';
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
#endif
    while(scanf("%d%d%d",&n,&m,&t)!=EOF){
        if(n==0&&m==0&&t==0) break;
        for(int i=0;i<n;i++)
            sfs(mp[i]);
        memset(vis,0,sizeof vis);
        int xx,yy;
        int num=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(mp[i][j] == 'S'){
                    xx = i;
                    yy = j;
                }else if(mp[i][j] == 'D'){
                    edx = i;
                    edy = j;
                }else if(mp[i][j] == '.'){
                    num++;
                }
            }
        }
        if(num+1<t){    //num为'.'数目，+1是因为到达‘D’还可以走一步
            printf("NO\n");
            continue;
        }
        flag=0;
        mp[xx][yy] = 'X'; //走过'S'以后，'S'就不能走了，我们可以直接将其变为'X'
        dfs(xx,yy,0);
        if(flag)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

以上为此次搜索专题的解题报告，如果有更好的解法可以多交流，谢谢~

leohujx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构专题 - 解题报告 - B
fatdog_jo的博客
05-12 114
这是我这个专题做出来的第一道题，跟榜看到的B，读完题，惊了惊了！似李！货车运输！当时也不说忙着抢一血，反正就是把自己写过的代码直接粘来改改交了过了。 但这样做的意义仅仅是多一个过题数而已，还是得好好整理一下。 分析完题意后，我们知道我们需要一个最大生成树保证带宽尽可能大，因为我们不会去选择更低带宽的路，然后在一条路上找到带宽最小值。就可以搜图并记录边权最小值即可。但是这么暴力去搜基本上是必T的。我...
图论专题 - 解题报告 - C
fatdog_jo的博客
06-10 194
首先这是明确的是一个打印有向图欧拉通路路径的题目，现在我们知道欧拉通路的成立需要些什么条件： 图连通 每个点的入度等于出度或有两个点入度不等于出度，且一个点出度比入度大一（起点），另一个点入度比出度小一（终点）如下图只能从中间一点开始到中间另一点结束，并且起点出度比入度大一 推论： 当有向图D，除了出度，入度之差为1，-1的两个节点之外，其余顶点的出度与入度相等时，D的有向欧拉通路必以出度...
【test】2015.7.28搜索解题报告（一）
MEET YOU FIRST TIME
08-08 453
这是夏令营的第三天，今天讲的主要是搜索，但解题报告今天才写，是因搜索一些细节处理很需要注意，下面就来看看这次的题目。   Tour Guides [Russ Cox, 2006] 给出一个N*N的矩阵(1 ，现在从左上角出发，走到右下角。而且，每个格子只能走一次，在矩阵中有‘.’和‘#’，‘.’表示可走，‘#’表示不可以走，问，共有多少种行走方案，保证左上角和左下角的格子一定可走。 PRO
2014 UESTC暑前集训搜索专题解题报告
weixin_30889885的博客
05-14 67
A.解救小Q BFS。每次到达一个状态时看是否是在传送阵的一点上，是则传送到另一点即可。 代码： #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include ...
算法之搜索专题
`or 1 or 不正经の泡泡
04-09 457
深度优先搜索（DFS）和广度优先搜索（BFS）都是常见的图搜索算法。它们的目的是访问和遍历图中的所有节点，并找到满足特定条件的节点。虽然这两种算法的实现方式不同，但它们都有以下的特点。首先，DFS 和 BFS 都是无向图或者有向图的通用算法。其次，它们都需要使用一个队列来存放待处理的节点。在 DFS 中，该队列被称为堆栈，而在 BFS 中，该队列被称为队列。无论是哪一种方法，都会访问每个节点，并跟踪已经访问过的节点。
数据结构专题 - 解题报告 - I
fatdog_jo的博客
05-12 185
平衡树做法，因为最近正好自己看了点平衡树相关的知识，便觉得这个题就是专门为了平衡树准备的。（完全没想到set，其实也是不会用） 因为查排名，如果我们有一棵二叉搜索树那就很好办，上面每个点都有相应的判断位置的值，从根节点入手，如果当前节点比过题数较多就往左儿子查，过题少就往右儿子查，相等就是判断罚分然后向左或者向右儿子搜索。一旦发现与当前节点过题数和罚分都相等的节点就返回左方所有节点囊括的点数，在那...
图论专题 - 解题报告 - I
fatdog_jo的博客
06-10 135
第K短路 首先可以想到在BFS中，从起点开始走，把每个点放入队列中时，以当前走过的距离加上当前点到终点的最短距离的和（即我们假设可以预知走哪个点到终点的距离最短）作为比较条件从小到大排序，当第一个到达终点时，走过的路径长度即为最短路，那么第k次到达终点的长度显然就是k短路。 那么接下来就是问题的核心了，如何判断哪个点到终点的距离最短呢？我们需要一个排序条件，可以保证每次都优先走最有希望到达终点的点...
动态规划专题 - 解题报告 - M
fatdog_jo的博客
05-25 304
别的我不说了，良心题解先吹一波好吧。 最重要的使这一段 假如第一位4，第二位7，三四位就可以随便取了。设这种状态为(2,2)，意思为前两位已经匹配上了4750的第二位。则用dp[2][2]表示(dp[100010][5],一共5*1e5种状态)。 那么(2,2)就有10种选择（0~9）： ·会转移1次到(3，3)(选5); ·1次(3,1)(选4); ·8次(3,0)(选其他) 在一番推导后，...
动态规划专题 - 解题报告 - L
fatdog_jo的博客
05-25 106
转移方程：dp[i]=min(dp[i],dp[j]+(x−L)2),0&lt;=j&lt;=i−1dp[i]=min(dp[i],dp[j]+(x-L)^2) , 0&lt;=j&lt;=i-1dp[i]=min(dp[i],dp[j]+(x−L)2),0<=j<=i−1 但是如果只是单纯的n2 爆破大概率超时，（但就是有爆破神仙过了），这里的优化想法...
搜索讲座-清华大学，NOI2016金
02-12
【描述】"搜索专题讲座-吕同学，清华大学，NOI2016金，APIO讲师"进一步明确了讲座的主题聚焦在搜索算法上，吕同学是这场讲座的主角，他不仅来自清华大学，还因为在NOI2016中获得金牌而备受认可。同时，他作为APIO的...
leetcode递归专题-leetcode:不定期发布leetcode解题思路和代码
06-30
leetcode递归专题 leetcode 我的LeetCode主页： 不定期发布leetcode解题思路和代码 一些好的题目 动态规划 一般dp 区间dp 位数dp 状压dp 树形DP 树 二叉树 前缀树 -- 其他树上问题 ---- ---- ---- ---- ---- ---- --...
动态规划专题-清华大学IOI金牌讲座
02-10
5. **记忆化搜索**：为了优化空间效率，可以使用数组或数据结构（如字典）存储已经计算过的子问题结果，避免重复计算。 在【动态规划专题-吴同学，清华大学，IOI2016金牌.mp4】的视频中，吴同学可能会深入讲解以下...
NOIP 2019 提高班专题集训课件.zip
09-04
这套课程涵盖了DP（动态规划）、贪心算法、图论、数据结构以及数学等多个核心算法与理论知识领域，旨在提升参赛者的编程能力和解题技巧。 首先，我们要理解DP（动态规划）的基本思想。动态规划是一种解决最优化问题...
高三英语专题复习 阅读理解解题技巧关注高中学习资料库PPT课件.pptx
10-10
【高三英语专题复习 阅读理解解题技巧】 阅读理解是英语考试中至关重要的一部分，对于高三学生来说，掌握有效的解题技巧能显著提高得分。本篇内容将深入讲解一些关键的阅读理解策略，帮助学生克服阅读理解过程中的...
员工关怀实施提案.pptx
08-07
员工关怀实施提案.pptx
基于面向对象的python学生管理系统源码.zip
最新发布
08-07
python 基于面向对象的python学生管理系统源码.zip
项目管理培训实操课件08项目管理模式的优缺点和适用条件.pptx
08-07
项目管理培训实操课件08项目管理模式的优缺点和适用条件.pptx
Authl-0.3.4-py3-none-any.whl.zip
08-07
Authl-0.3.4-py3-none-any.whl.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值