旋转游戏 “井”

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<memory.h>
#include<string>
#define INF 0x3f3f3f3f
using namespace std;

const int indexs[8][7]=
{
    {0,2,6,11,15,20,22},
    {1,3,8,12,17,21,23},
    {10,9,8,7,6,5,4},
    {19,18,17,16,15,14,13},
    {23,21,17,12,8,3,1},
    {22,20,15,11,6,2,0},
    {13,14,15,16,17,18,19},
    {4,5,6,7,8,9,10},
};
const int ni[]={5,4,7,6,1,0,3,2,-1};
const int center[]={6,7,8,11,12,15,16,17};
 int min(int a,int b) {return a>b ? b : a;}
 int max(int a,int b) {return a<b ? b : a;}
char map[24];
char route[101];
bool hasSolution;

void pull(int op)
{
    int temp=map[indexs[op][0]];
    for (int i=0;i<7-1;i++)
    {
        map[indexs[op][i]]=map[indexs[op][i+1]];
    }
    map[indexs[op][6]]=temp;
}

int h()
{
    int cnt[3]={0,0,0};
    int maxCnt= -1;
    for(int i=0;i<8;i++)
    {
        cnt[map[center[i]]-1]++;
        maxCnt=max(maxCnt,cnt[map[center[i]]-1]);//作用和if.m>cnt.m=cnt[]一样；
    }
    return 8-maxCnt;
}

void dfs(int depth,int lastop,int maxdepth )
{
    if(hasSolution) return ;
    if(h()==0)
    {
        hasSolution=true;
        route[depth]='';
        printf("%s
%d
",route, map[center[0]]);
        return;
    }
    if(depth>maxdepth||depth+h()>maxdepth) return;
    for(int nextop=0;nextop<8;nextop++)
    {
        if(nextop != ni[lastop])
        {
            pull(nextop);
            route[depth]=nextop+'A';
            dfs(depth+1,nextop,maxdepth);
            pull(ni[nextop]);
        }
    }
}

int main()
{
    int x;
    while(cin>>x&&x)
    {
        map[0]=x;
        for(int i=1;i<24;i++)
        {
            cin>>map[i];
            if(map[i]==0) return 0;
        }
        hasSolution = false;
        if(h()==0)
        {
            printf("No moves needed
%d
", map[center[0]]);
            continue;
        }
        for(int depth =1;!hasSolution;depth++)
        {
            dfs(0,8,depth);
        }
    }
    return 0;
}

第一题“井”

https://lo-li.net/1363.html

 AC的代码。。求哪里不同啊。。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <memory.h>
using namespace std;
#define INF 0x3f3f3f3f
const int indexs[8][7] = {                        // 每种操作变动的下标
    { 0,2,6,11,15,20,22 },    //AF
    { 1,3,8,12,17,21,23 },    //BE
    { 10,9,8,7,6,5,4 },       //CH
    { 19,18,17,16,15,14,13 }, //DG
    { 23,21,17,12,8,3,1 },    //EB
    { 22,20,15,11,6,2,0 },    //FA
    { 13,14,15,16,17,18,19 }, //GD
    { 4,5,6,7,8,9,10 },       //HC
};
const int reverseOp[] = { 5,4,7,6,1,0,3,2,-1 };  // A-H的逆操作
const int center[] = { 6,7,8,11,12,15,16,17 };   // 中心八点下标
int min(int a, int b) { return a>b ? b : a; }
int max(int a, int b) { return a<b ? b : a; }
char map[24];
char route[101];                                 // 操作序列
bool hasSolution;

void pull(int op) {
    int tmp = map[indexs[op][0]];
    for (int i = 0; i < 7 - 1; i++) {
        map[indexs[op][i]] = map[indexs[op][i + 1]];
    }
    map[indexs[op][6]] = tmp;
}

int h() {
    int cnt[3] = { 0,0,0 }; // 计数 1, 2, 3
    int maxCnt = -1;
    for (int i = 0; i < 8; i++) {
        cnt[map[center[i]] - 1]++;
        maxCnt = max(maxCnt, cnt[map[center[i]] - 1]);
    }
    return 8 - maxCnt;
}

void d(int depth, int lastOp, int maxDepth) {// 当前深度、到达当前深度所做的操作
    if (hasSolution)return;
    if (h() == 0) {  // 中心都相同了
        hasSolution = true;
        route[depth] = '';
        printf("%s
%d
",route, map[center[0]]);
        return;
    }
    if (depth > maxDepth || depth + h() > maxDepth) return;  // 可行性剪枝
    for (int nextOp = 0; nextOp < 8; nextOp++) {
        if (nextOp != reverseOp[lastOp]) {  //操作不互逆
            pull(nextOp);
            route[depth] = nextOp + 'A';
            d(depth + 1, nextOp, maxDepth);
            pull(reverseOp[nextOp]);                         //还原
        }
    }
}
int main() {
    while (1) {
        for (int i = 0; i < 24; i++) {
            scanf("%d", &map[i]);
            if (map[i] == 0) return 0;
        }
        hasSolution = false;
        if (h() == 0) {
            printf("No moves needed
%d
", map[center[0]]);
            continue;
        }
        for (int depth = 1; !hasSolution; depth++) {    // 迭代加深
            d(0, 8, depth);
        }
    }
    return 0;
}

 第二题

Output

对于每个测试用例，打印一行，表示可以从这些序列中生成的最短序列的长度。

Sample Input

1
4
ACGT
ATGC
CGTT
CAGT

Sample Output

8

第二题的代码

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

char str[10][10];//记录n个字符串
int n,ans,deep,size[10];
char DNA[4]={'A','C','G','T'};//一共四种可能

void dfs(int cnt,int len[])
{
    if(cnt > deep)//大于限制的深度，不用往下搜索
        return;
    int maxx = 0;//预计还要匹配的字符串的最大长度
    for(int i=0;i<n;i++)
    {
        int t = size[i]-len[i];
        if(t>maxx)
            maxx = t;
    }
    if(maxx==0)//条件全部满足即为最优解
    {
        ans = cnt;
        return;
    }
    if(cnt + maxx > deep)
        return;
    for(int i=0;i<4;i++)
    {
        int pos[10];
        int flag = 0;
        for(int j=0;j<n;j++)
        {
            if(str[j][len[j]]==DNA[i])
            {
                flag = 1;
                pos[j] = len[j]+1;
            }
            else
                pos[j]=len[j];
        }
        if(flag)
            dfs(cnt+1,pos);
        if(ans!=-1)
            break;
    }
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        int maxn = 0;
        for(int i=0;i<n;i++)
        {
            cin>>str[i];
            size[i] = strlen(str[i]);
            if(size[i]>maxn)
                maxn = size[i];
        }
        ans = -1;
        deep = maxn;
        int pos[10] = {0};//记录n个字符串目前匹配到的位置
        while(1)
        {
            dfs(0,pos);
            if(ans!=-1)
                break;
            deep++;//加深迭代
        }
        cout<<ans<<endl;
    }
    return 0;
}

 第三题

AveryBoy又又又被关在一个n*m的迷宫里，这次还有了检查人员防止他逃跑。，并在迷宫的某些地方安装了带锁的门，钥匙藏在迷宫另外的某些地方。刚开始AveryBoy被关在(sx,sy)的位置，离开迷宫的门在(ex,ey)的位置。AveryBoy每分钟只能从一个坐标走到相邻四个坐标中的其中一个。检查人员每t分钟回地牢视察一次，若发现AveryBoy不在原位置便把他拎回去。经过若干次的尝试，AveryBoy已画出整个迷宫的地图。现在请你帮他计算能否再次成功逃出迷宫。只要在检查人员下次视察之前走到出口就算离开迷宫，如果检查人员回来的时候刚好走到出口或还未到出口都算逃亡失败。

Input

每组测试数据的第一行有三个整数n,m,t(2<=n,m<=20,t>0)。接下来的n行m列为迷宫的地图，其中包括:

. 代表路
* 代表墙
@ 代表AveryBoy的起始位置
^ 代表地牢的出口
A-J 代表带锁的门,对应的钥匙分别为a-j
a-j 代表钥匙，对应的门分别为A-J

每组测试数据之间有一个空行。

Output

针对每组测试数据，如果可以成功逃出迷宫，请输出需要多少分钟才能离开，如果不能则输出-1。

Sample Input

4 5 17
@A.B.
a*.*.
*..*^
c..b*

4 5 16
@A.B.
a*.*.
*..*^
c..b*

Sample Output

16
-1

第三题代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=20+10;
char map[maxn][maxn];
int n,m,t;
bool vis[maxn][maxn][(1<<10)+10];
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
struct Point
{
    int x,y,step;
    int key;
};
queue<Point>q;
Point st;
bool check(int x,int y)
{
    if(x>=1&&x<=n&&y>=1&&y<=m&&map[x][y]!='*')
         return true;
    return false;
}
int bfs()
{
    while(!q.empty())  q.pop();
    memset(vis,false,sizeof(vis));//初始化
    vis[st.x][st.y][st.key]=true;
    st.key=st.step=0;
    q.push(st);
    Point cur,nex;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        if(map[cur.x][cur.y]=='^')//判断是否到终点
            return cur.step;
        for(int i=0;i<4;i++)
        {
            nex.x=cur.x+dx[i];
            nex.y=cur.y+dy[i];
            nex.key=cur.key;
            if(check(nex.x,nex.y))
            {
               nex.step=cur.step+1;
               if(nex.step>=t)
                   continue;
               else if(map[nex.x][nex.y]>='A'&&map[nex.x][nex.y]<='Z')//判断是否为门
               {
                  int temp=map[nex.x][nex.y]-'A';
                  int nk=cur.key&1<<temp;//查询是否有钥匙
                  if(nk&&!vis[nex.x][nex.y][nex.key])
                  {
                      vis[nex.x][nex.y][nex.key]=true;//走过
                      q.push(nex);
                  }
               }
               else if(map[nex.x][nex.y]>='a'&&map[nex.x][nex.y]<='z')//判断是否有钥匙
               {
                   int temp=map[nex.x][nex.y]-'a';
                   nex.key=cur.key|1<<temp;//查询是否有钥匙
                   if(!vis[nex.x][nex.y][nex.key])
                   {
                       vis[nex.x][nex.y][nex.key]=true;//捡起
                       q.push(nex);
                   }
               }
               else
               {
                   if(!vis[nex.x][nex.y][nex.key])
                   {
                       vis[nex.x][nex.y][nex.key]=true;
                       q.push(nex);
                   }
               }
            }
         }
    }
    return -1;
}
inline void print()//输入
{
    char str[maxn];
    for(int i=1;i<=n;i++)
    {
        scanf("%s",str+1);
        for(int j=1;j<=m;j++)
        {
            if(str[j]=='@')
            {
                st.x=i;
                st.y=j;
                map[i][j]=str[j];
            }
            else  map[i][j]=str[j];
        }
    }
}

int main()
{
    while(~scanf("%d%d%d",&n,&m,&t))
    {
        print();
        int ans=bfs();
        printf("%d
",ans);
    }
    return 0;
}

第四题是超级进阶版的迷宫 四维数组