POJ 2251 、3278 、 3279

三题均为简单搜索

POJ 2251：不能用DFS，必须用BFS，因为DFS必须维护最值，且要扫完，铁定TLE。

POJ 3278：注意 10000 0和0 10000这两组数据，两组数据不处理好，铁定RE，注意 k == n 这样的数据，如果不等于 0 铁定WA。。。别的没什么了，BFS即可。

POJ 3279：注意题目说的字典序根本不用考虑，只要是翻转次数最小即可，枚举第一排的所有情况，最多有2^15次方种，然后利用2~n行更新前排的即可，最后判断最后一行是否全文为0，如果是，看是否需要更新最值。

 

代码：

POJ 2251:

#include <iostream>
#include <cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
char mp[50][50][50];
int s[50][50][50];
int sum;
int ss;
int dp[6][3] = {1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1};
int vis[50][50][50];
struct st{
        int x,y,z,t;
};
int  bfs(int sx,int sy,int sz,int L,int R,int C)
{
        queue<st>que;
        st f;
        f.x = sx;
        f.y = sy;
        f.z = sz;
        f.t = 0;
        que.push(f);
        vis[sx][sy][sz] = 1;
        while(!que.empty())
        {
                f= que.front();
                que.pop();
                st g;
                for(int i = 0;i < 6; i++ )
                {
                        g.x = f.x + dp[i][0];
                        g.y = f.y + dp[i][1];
                        g.z = f.z + dp[i][2];
                        g.t = f.t + 1;
                        if(!vis[g.x][g.y][g.z]&&(s[g.x][g.y][g.z]==1||s[g.x][g.y][g.z]==2))
                        {
                                que.push(g);
                                vis[g.x][g.y][g.z] = 1;
                                if(s[g.x][g.y][g.z]==2)
                                        return g.t;
                        }
                }
        }
        return -1;
}

int main()
{
    ios::sync_with_stdio(false);
    int L,R,C;
    int sx,sy,sz;
    while(~scanf("%d%d%d",&L,&R,&C))
    {
            memset(vis,0,sizeof(vis));
            memset(mp,0,sizeof(mp));
            memset(s,0,sizeof(s));
            getchar();
            if(!L&&!R&&!C)
                break;
            ss=0;
            for(int i = 0;i < L;i++)
            {
                    for(int j = 0;j < R; j++ )
                    {
                            for(int k = 0; k < C ; k++)
                            {
                                    scanf("%c",&mp[i][j][k]);
                                    if(mp[i][j][k]=='.')
                                        s[i][j][k] = 1;
                                    if(mp[i][j][k]=='#')
                                        s[i][j][k] = 0;
                                    if(mp[i][j][k]=='S')
                                    {
                                            sx=i;sy=j;sz=k;
                                    }
                                    if(mp[i][j][k]=='E')
                                        s[i][j][k] = 2;

                            }
                            getchar();
                    }
                    getchar();

            }
            int temp = bfs(sx,sy,sz,L,R,C);
            if(temp!=-1)
                cout<<"Escaped in "<<temp<<" minute(s)."<<endl;
            else
                cout<<"Trapped!"<<endl;
    }
    return 0;
}

POJ 3278:

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

struct st{
        int x;
        int t;
}f;
int vis[200000+50];
int bfs(int s,int e)
{
        queue<st>que;
        f.x = s;
        f.t = 0;
        que.push(f);
        vis[s] = 1;
        while(!que.empty())
        {
                f = que.front();
                que.pop();
                for(int i = 0;i<3;i++)
                {
                        st g;
                        if(i==0&&f.x<=e){
                        g.x = f.x+1;
                        g.t = f.t + 1;}
                        if(i==1&&f.x-1>=0)
                        {
                                g.x = f.x-1;
                                g.t = f.t + 1;
                        }
                        if(i==2&&f.x<=e)
                        {
                                g.x = f.x+f.x;
                                g.t = f.t +1;
                        }
                        if(!vis[g.x])
                        {
                                vis[g.x] = 1;
                                que.push(g);
                                if(g.x==e)
                                        return g.t;
                        }
                }
        }
}

int main()
{
        int n,k;
        scanf("%d%d",&n,&k);
        if(n==k)
              cout<<"0"<<endl;
        else if(n>k)
                cout<<n-k<<endl;
        else
        printf("%d\n",bfs(n,k));
}

POJ 3279:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <climits>
#include <cassert>
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1

using namespace std;
const int maxn = 1000 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);

int mp[20][20];
int vis[20][20];
int mm[20][20];
int mmmm[20][20];
int ans[20][20];
int sum ,mx,id;
void solve(int n,int m)
{
        for(int i = 1;i <= (1<<m);i++)//二进制枚举
        {
                        memset(mmmm,0,sizeof(mmmm));
                        for(int kk = 1;kk <= n;kk++)
                                for(int tt = 1; tt <= m;tt++)
                                        mm[kk][tt] = mp[kk][tt];
                        for(int j=1; j <= m; j++)
                        {
                                mmmm[1][m - j + 1 ] = (((i -1)>> (j-1))) & 1; //可以给第一行赋值左右情况
                                if(mmmm[1][m-j+1])
                                {
                                mm[1][m-j+1]^=1;
                                mm[2][m-j+1]^=1;
                                if(m-j+2<=m) mm[1][m-j+2]^=1;
                                if(m-j+1>=2) mm[1][m-j] ^=1;
                                sum++;
                                }
                        }

                        for(int t = 2;t<=n;t++)
                        {
                                for(int v = 1;v <= m;v++)
                                if(mm[t-1][v]==1)
                                {
                                        mmmm[t][v] = 1;
                                        sum++;
                                        mm[t][v] ^= 1;
                                        mm[t-1][v] ^= 1;
                                        if(v>=2) mm[t][v-1] ^=1;
                                        if(v<=m-1) mm[t][v+1]^=1;
                                        if(t+1<=n) mm[t+1][v] ^= 1;
                                } 
                        }
                        int  flag = 1;
                        for(int v = 1;v<=m;v++)
                                if(mm[n][v])
                                        flag = 0;

                        if(flag){
                                if(sum<mx)
                                {
                                        for(int p = 1;p<=n;p++)
                                                for(int q = 1;q<=m;q++)
                                                        ans[p][q] = mmmm[p][q];
                                        mx = sum;
                                        sum = 0;
                                        id = i;
                                }
                        }
                        else
                                sum = 0;
        }
}
 int main()
 {
        int n,m;
        sum = 0;
        mx = 9999999;
        scanf("%d %d",&n,&m);
        for(int i = 1;i <= n;i++)
                for(int j = 1; j <= m;j++)
                        scanf("%d",&mp[i][j]);
        solve(n,m);
        if(mx==9999999)
        printf("IMPOSSIBLE\n");
        else 
        for(int i = 1;i<=n;i++)
        {
                for(int j = 1;j<=m;j++)
                {
                        if(j!=1) printf(" ");
                        printf("%d",ans[i][j]);
                }
                printf("\n");
        }

 }