zoukankan      html  css  js  c++  java
  • bzoj 3041: 水叮当的舞步 迭代加深搜索 && NOIP RP++

    3041: 水叮当的舞步

    Time Limit: 10 Sec  Memory Limit: 128 MB
    Submit: 72  Solved: 44
    [Submit][Status]

    Description

    水叮当得到了一块五颜六色的格子形地毯作为生日礼物,更加特别的是,地毯上格子的颜色还能随着踩踏而改变。
    为了讨好她的偶像虹猫,水叮当决定在地毯上跳一支轻盈的舞来卖萌~~~
    地毯上的格子有N行N列,每个格子用一个0~5之间的数字代表它的颜色。
    水叮当可以随意选择一个0~5之间的颜色,然后轻轻地跳动一步,左上角的格子所在的联通块里的所有格子就会变成她选择的那种颜色。这里连通定义为:两个格子有公共边,并且颜色相同。
    由于水叮当是施展轻功来跳舞的,为了不消耗过多的真气,她想知道最少要多少步才能把所有格子的颜色变成一样的。

    Input


    每个测试点包含多组数据。
    每组数据的第一行是一个整数N,表示地摊上的格子有N行N列。
    接下来一个N*N的矩阵,矩阵中的每个数都在0~5之间,描述了每个格子的颜色。
    N=0代表输入的结束。

    Output


    对于每组数据,输出一个整数,表示最少步数。

    Sample Input

    2
    0 0
    0 0
    3
    0 1 2
    1 1 2
    2 2 1
    0

    Sample Output


    0
    3

    对于100%的数据,N<=8,每个测试点不多于20组数据。
     
      这道题与以往不同的是,这道题难点不在于剪枝,而在于常数优化,通过一个特殊的数组记录左上角联通快内部,边界,外部的位置,来消除每次求联通快的时间。
     
      明天NOIP了,时间真的过的太快了,总之while(true)rp++;
     
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    #define MAXN 9
    #define INF 0x3f3f3f3f
    int mov[4][2]={{1,0},{0,1},{0,-1},{-1,0}};
    int n;
    int a[MAXN][MAXN];
    int g[MAXN][MAXN];
    int vis[MAXN][MAXN],bfstime=0;
    int vis2[6];
    int q[MAXN*MAXN][2];
    /*
    bool dfs(int chs,int lev)
    {
            if (!lev)return false;
            int i,j;
            int old[8];
            for (i=0;i<n;i++)
            {
                    old[i]=0;
                    for (j=0;j<n;j++)
                            old[i]=old[i]*6+a[i][j];
            }
            int x,y;
            x=0;y=0;
            bool ret=false;
            int head=-1,tail=0;
            int ii;
            int c,d;
            int nc=0;
            for (ii=0;!ret && ii<6;ii++)
            {
                    if (!((1<<ii)&chs))continue;
                    nc=0;
                    x=y=0;
                    c=a[x][y];
                    a[x][y]=ii;
                    vis[x][y]=++bfstime;
                    head=-1;tail=0;
                    while (head<tail)
                    {
                            x=q[++head][0];
                            y=q[head][1];
                            for (i=0;i<4;i++)
                            {
                                    x+=mov[i][0];
                                    y+=mov[i][1];
                                    if (x>=0 && y>=0 && x<n && y<n && vis[x][y]!=bfstime && a[x][y]==c)
                                    {
                                            vis[x][y]=bfstime;
                                            q[++tail][0]=x;
                                            q[tail][1]=y;
                                            a[x][y]=ii;
                                    }
                                    x-=mov[i][0];
                                    y-=mov[i][1];
                            }
                    }
                    head=-1;
                    while (head<tail)
                    {
                            x=q[++head][0];
                            y=q[head][1];
                            for (i=0;i<4;i++)
                            {
                                    x+=mov[i][0];
                                    y+=mov[i][1];
                                    if (x>=0 && y>=0 && x<n && y<n && vis[x][y]!=bfstime)
                                    {
                                            if (a[x][y]==ii)
                                            {
                                                    vis[x][y]=bfstime;
                                                    q[++tail][0]=x;
                                                    q[tail][1]=y;
                                            }else
                                            {
                                                    nc|=(1<<a[x][y]);
                                            }
                                    }
                                    x-=mov[i][0];
                                    y-=mov[i][1];
                            }
                    }
                    if (tail==n*n-1)
                    {
                            ret=true;
                    }
                    head=-1;
            //        memset(dis,INF,sizeof(dis));
                    for (i=0;i<=tail;i++)
                            dis[q[i][0]][q[i][1]]=0;
                    c=0;
                    while (head<tail)
                    {
                            x=q[++head][0];
                            y=q[head][1];
                            d=dis[x][y];
                            for (i=0;i<4;i++)
                            {
                                    x+=mov[i][0];
                                    y+=mov[i][1];
                                    if (x>=0 && y>=0 && x<n && y<n && vis[x][y]!=bfstime)
                                    {
                                            vis[x][y]=bfstime;
                                            dis[x][y]=d+1;
                                            x=max(c,d+1);
                                    }
                                    x-=mov[i][0];
                                    y-=mov[i][1];
                            }
                    }
                    d=0;
                    for (i=0;i<n;i++)
                            for (j=0;j<n;j++)
                                    if (vis2[a[i][j]]!=bfstime)
                                    {
                                            vis2[a[i][j]]=bfstime;
                                            d++;
                                    }
                    d--;
                    c=max(c,d);
                    if (lev-1>=c && !ret && dfs(nc,lev-1))
                    {
                            ret=true;
                    }
                    for (i=0;i<n;i++)
                    {
                            x=old[i];
                            for (j=n-1;j>=0;j--)
                            {
                                    a[i][j]=x%6;
                                    x/=6;
                            }
                    }
            }
            return ret;
    }
    */
    bool dfs(int lev)
    {
            if (!lev)return false;
            int i,j;
            int x,y;
            bool ret=false;
            int head=-1,tail=0;
            int ii;
            int c;
            int grec[MAXN][MAXN];
            memcpy(grec,g,sizeof(grec));
            for (ii=0;!ret && ii<6;ii++)
            {
                    head=-1,tail=-1;
                    ++bfstime;
                    for (i=0;i<n;i++)
                    {
                            for (j=0;j<n;j++)
                            {
                                    if (g[i][j]==2 && a[i][j]==ii)
                                    {
                                            q[++tail][0]=i;
                                            q[tail][1]=j;
                                            vis[i][j]=bfstime;
                                            g[i][j]=1;
                                    }
                            }
                    }
                    if (head==tail)continue;
                    while (head<tail)
                    {
                            x=q[++head][0];
                            y=q[head][1];
                            for (i=0;i<4;i++)
                            {
                                    x+=mov[i][0];
                                    y+=mov[i][1];
                                    if (x>=0 && y>=0 && x<n && y<n && !g[x][y] )
                                    {
                                            if (a[x][y]==ii)
                                            {
                                                    q[++tail][0]=x;
                                                    q[tail][1]=y;
                                                    g[x][y]=1;
                                            }else
                                            {
                                                    g[x][y]=2;
                                            }
                                    }
                                    x-=mov[i][0];
                                    y-=mov[i][1];
                            }
                    }
                    c=0;
                    for (i=0;i<n;i++)
                            for (j=0;j<n;j++)
                            {
                                    if (g[i][j]!=1 && vis2[a[i][j]]!=bfstime)
                                    {
                                            vis2[a[i][j]]=bfstime;
                                            c++;
                                    }
                            }
                    if (!c)
                            return true;
                    if (lev-1>=c && dfs(lev-1))
                    {
                            ret=true;
                    }
                    memcpy(g,grec,sizeof(grec));
            }
            return ret;
    }
    
    int main()
    {
            //reopen("input.txt","r",stdin);
            //    freopen("output.txt","w",stdout);
            while (scanf("%d",&n),n)
            {
                    int i,j;
                    for (i=0;i<n;i++)
                            for (j=0;j<n;j++)
                                    scanf("%d",&a[i][j]);
                    int l,r;
                    l=0,r=19;
                    int mid;
                    g[0][0]=2;
                    while (l+1<r)
                    {
                            mid=(l+r)>>1;
                            memset(g,0,sizeof(g));
                            g[0][0]=2;
                            if (dfs(mid))
                                    r=mid;
                            else
                                    l=mid;
                    }
                    printf("%d
    ",r-1);
            }
    }
    by mhy12345(http://www.cnblogs.com/mhy12345/) 未经允许请勿转载

    本博客已停用,新博客地址:http://mhy12345.xyz

  • 相关阅读:
    AbstractRoutingDataSource动态数据源切换,AOP实现动态数据源切换
    SPEC CPU——简介和使用
    Python——sklearn 中 Logistics Regression 的 coef_ 和 intercept_ 的具体意义
    伯努利分布的最大似然估计(最小化交叉熵、分类问题)
    Python关于%matplotlib inline
    MySQL——告别慢SQL,如何去写一手好SQL
    HiveSQL——row_number() over() 使用
    Python——Python缓存技术
    solr——Lucene打分公式的数学推导
    solr——影响Lucene对文档打分的四种方式
  • 原文地址:https://www.cnblogs.com/mhy12345/p/4082499.html
Copyright © 2011-2022 走看看