• hdu 1430 (BFS 康托展开 或 map )


    第一眼看到这题就直接BFS爆搜,第一发爆了内存,傻逼了忘标记了,然后就改,咋标记呢。

    然后想到用map函数,就8!个不同的排列,换成字符串用map标记。然后又交一发果断超时,伤心,最恨超时,还不如来个wa算了。

    然后卡着了,后来上网上搜,要用康托展开,康托展开是什么鬼?然后学习了一下,就是个映射,感觉和map差不多。

    http://blog.csdn.net/zhongkeli/article/details/6966805这个学习一下康托展开。

    其实本题的关键不是康托展开,而是置换。

    以12345678为起始状态开始搜它经过3种变换能到达的所有状态的最小步数,每搜到一个记录下来,可以用康托展开,也可以用C++ STL库里的map

    所以只要搜一次就够了,然后记录。那么咋转置呢。举个列子 初态为65871234 目标态为87125463,那么初态和12345678比较,6和1对应,5和2对应

    8和3对应......,所以目标态的8为初态的第三位,而初态的第三位对应12345678中的三,所以目标态第一位转为3,同理第2位转为4......

    最后的到状态为34562817,所以只要知道12345678转为34562817的最小步数就为所求。

    下面给两段代码一个是用map写的一个是用康托展开写的。map写的运行时间比较慢200多Ms,不过时间足够,题目好像是给了5s吧,

    康托展开是46ms.

    题目链接http://acm.hdu.edu.cn/showproblem.php?pid=1430;

      1 #include<stdio.h>
      2 #include<algorithm>
      3 #include<iostream>
      4 #include<string.h>
      5 #include<stdlib.h>
      6 #include<math.h>
      7 #include<queue>
      8 #include<stack>
      9 #include<cstdio>
     10 #include<map>
     11 void bfs();
     12 using namespace std;
     13 void AA(char *p,char *q);
     14 void BB(char *p,char *q);
     15 void CC(char *p,char *q);
     16 int N=50005;
     17 map<string,int>my;
     18 char t[10]="12345678";
     19 char a[41000][100];//总共有8!的状态每个状态对应一个数然后用数组存变换的步奏
     20 typedef struct pp
     21 {
     22 
     23 char ab[10];
     24     int n;
     25 
     26 } ss;//开结构体存步数。
     27 int main(void)
     28 {
     29 
     30     int n,i,j,k,p,q;
     31     char aa[10];
     32     char bb[10];
     33     char cc[10];
     34     bfs();
     35     while(scanf("%s %s",aa,bb)!=EOF)
     36     {
     37         int yu=0;
     38         for(i=0; i<8; i++)
     39         {
     40             for(j=0; j<8; j++)
     41             {
     42                 if(bb[i]==aa[j])
     43                 {
     44                     cc[yu++]=j+1+'0';
     45                 }
     46             }
     47         }
     48         cc[8]='';
     49         int sh=my[cc];
     50         puts(a[sh]);
     51     }
     52     return 0;
     53 
     54 }
     55 void bfs()
     56 {
     57     int i,j,k,p,q,l;
     58     ss ll,mm;
     59     ll.n=1;
     60     int v=1;
     61     my[t]=v;//map标记并映射为一个数
     62     v++;
     63     strcpy(ll.ab,t);
     64     queue<ss>que;
     65     que.push(ll);
     66     while(!que.empty())
     67     {
     68         mm=que.front();
     69         que.pop();
     70         ss pp;
     71         AA(pp.ab,mm.ab);
     72 
     73         if(my[pp.ab]==0)
     74         {
     75             my[pp.ab]=v;
     76             strcpy(a[v],a[mm.n]);//接上一个所有的变化步数
     77             l=strlen(a[v]);//最后加上本次的变换
     78             a[v][l]='A';
     79             pp.n=v;
     80             v++;
     81             que.push(pp);
     82         }
     83         BB(pp.ab,mm.ab);
     84 
     85         if(my[pp.ab]==0)
     86         {
     87             my[pp.ab]=v;
     88             strcpy(a[v],a[mm.n]);
     89             l=strlen(a[v]);
     90             a[v][l]='B';
     91 
     92             pp.n=v;
     93             v++;
     94             que.push(pp);
     95         }
     96         CC(pp.ab,mm.ab);
     97 
     98         if(my[pp.ab]==0)
     99         {
    100             my[pp.ab]=v;
    101             strcpy(a[v],a[mm.n]);
    102             l=strlen(a[v]);
    103             a[v][l]='C';
    104             pp.n=v;
    105             v++;
    106             que.push(pp);
    107         }
    108 
    109 
    110 
    111 
    112     }
    113 
    114 
    115 
    116 
    117 
    118 
    119 }//三种不同的转换;
    120 void AA(char *p,char *q)
    121 {
    122     int i,j,k;
    123     p[0]=q[7];
    124     p[1]=q[6];
    125     p[2]=q[5];
    126     p[3]=q[4];
    127     p[4]=q[3];
    128     p[5]=q[2];
    129     p[6]=q[1];
    130     p[7]=q[0];
    131     p[8]='';
    132 }
    133 
    134 void BB(char *p,char *q)
    135 {
    136     int i,j,k;
    137     p[0]=q[3];
    138     p[1]=q[0];
    139     p[2]=q[1];
    140     p[3]=q[2];
    141     p[4]=q[5];
    142     p[5]=q[6];
    143     p[6]=q[7];
    144     p[7]=q[4];
    145     p[8]='';
    146 }
    147 
    148 void CC(char *p,char *q)
    149 {
    150     p[0]=q[0];
    151     p[1]=q[6];
    152     p[2]=q[1];
    153     p[3]=q[3];
    154     p[4]=q[4];
    155     p[5]=q[2];
    156     p[6]=q[5];
    157     p[7]=q[7];
    158     p[8]='';
    159 }
      1 #include<stdio.h>
      2 #include<algorithm>
      3 #include<iostream>
      4 #include<string.h>
      5 #include<stdlib.h>
      6 #include<math.h>
      7 #include<queue>
      8 #include<stack>
      9 #include<cstdio>
     10 int kt(char *p);
     11 void bfs();
     12 using namespace std;
     13 void AA(char *p,char *q);
     14 void BB(char *p,char *q);
     15 void CC(char *p,char *q);
     16 int as[10];
     17 int N=50005;
     18 bool vis[50005];
     19 char t[10]="12345678";
     20 char a[41000][100];
     21 typedef struct pp
     22 {
     23     char ab[10];
     24     int n;
     25 
     26 } ss;
     27 int main(void)
     28 {
     29     as[0]=1;
     30     as[1]=1;
     31     as[2]=2;
     32     as[3]=6;
     33     as[4]=24;
     34     as[5]=120;
     35     as[6]=720;
     36     as[7]=5040;//康托展开预处理
     37     int n,i,j,k,p,q;
     38     char aa[10];
     39     char bb[10];
     40     char  cc[10];
     41     memset(vis,0,sizeof(vis));
     42     bfs();
     43     while(scanf("%s %s",aa,bb)!=EOF)
     44     {
     45         int yu=0;
     46         for(i=0; i<8; i++)
     47         {
     48             for(j=0; j<8; j++)
     49             {
     50                 if(bb[i]==aa[j])
     51                 {
     52                     cc[yu++]=j+1+'0';
     53                 }
     54             }
     55         }
     56 
     57         int sh=kt(cc);
     58 
     59         puts(a[sh]);
     60     }
     61 
     62     return 0;
     63 
     64 }
     65 
     66 int kt(char *p)//康托展开
     67 {
     68     int i,j;
     69     int kk=0;
     70     for(i=0; i<8; i++)
     71     {
     72         int yy=0;
     73         for(j=i+1; j<8; j++)
     74         {
     75             if((p[i]-'0')>(p[j]-'0'))
     76             {
     77                 yy++;
     78             }
     79         }
     80         kk+=yy*as[7-i];
     81 
     82 
     83     }
     84     return kk;
     85 }
     86 
     87 void bfs()
     88 {
     89     int i,j,k,p,q,l;
     90     ss ll,mm;
     91     ll.n=0;
     92     vis[0]=true;
     93     strcpy(ll.ab,t);
     94     queue<ss>que;
     95     que.push(ll);
     96     while(!que.empty())
     97     {
     98         mm=que.front();
     99         que.pop();
    100         ss pp;
    101         AA(pp.ab,mm.ab);
    102         int yy=kt(pp.ab);
    103         if(!vis[yy])
    104         {
    105             vis[yy]=true;
    106             strcpy(a[yy],a[mm.n]);
    107             l=strlen(a[yy]);
    108             a[yy][l]='A';
    109             pp.n=yy;
    110             que.push(pp);
    111         }
    112         BB(pp.ab,mm.ab);
    113         yy=kt(pp.ab);
    114         if(!vis[yy])
    115         {
    116             vis[yy]=true;
    117             strcpy(a[yy],a[mm.n]);
    118             l=strlen(a[yy]);
    119             a[yy][l]='B';
    120             pp.n=yy;
    121             que.push(pp);
    122         }
    123         CC(pp.ab,mm.ab);
    124         yy=kt(pp.ab);
    125         if(!vis[yy])
    126         {
    127             vis[yy]=true;
    128             strcpy(a[yy],a[mm.n]);
    129             l=strlen(a[yy]);
    130             a[yy][l]='C';
    131             pp.n=yy;
    132             que.push(pp);
    133         }
    134 
    135 
    136 
    137 
    138     }
    139 
    140 
    141 
    142 
    143 
    144 }
    145 void AA(char *p,char *q)
    146 {
    147     int i,j,k;
    148     p[0]=q[7];
    149     p[1]=q[6];
    150     p[2]=q[5];
    151     p[3]=q[4];
    152     p[4]=q[3];
    153     p[5]=q[2];
    154     p[6]=q[1];
    155     p[7]=q[0];
    156 }
    157 
    158 void BB(char *p,char *q)
    159 {
    160     int i,j,k;
    161     p[0]=q[3];
    162     p[1]=q[0];
    163     p[2]=q[1];
    164     p[3]=q[2];
    165     p[4]=q[5];
    166     p[5]=q[6];
    167     p[6]=q[7];
    168     p[7]=q[4];
    169 }
    170 
    171 void CC(char *p,char *q)
    172 {
    173     p[0]=q[0];
    174     p[1]=q[6];
    175     p[2]=q[1];
    176     p[3]=q[3];
    177     p[4]=q[4];
    178     p[5]=q[2];
    179     p[6]=q[5];
    180     p[7]=q[7];
    181 }
    油!油!you@
  • 相关阅读:
    从源码剖析Lua数据类型
    【Mysql】主从同步配置
    【Logstash】Logstash收集Nginx访问日志(二十六)
    【Logstash】Logstash快速入门(二十五)
    【Kibana】集群监控(二十四)
    【Beats】Metricbeat 收集Nginx指标数据(二十三)
    【Beats】Metricbeat快速入门(二十二)
    【Beats】Filebeat 与 Kibana仪表板(二十一)
    【Kibana】坐标地图(二十)
    【Beats】Filebeat收集Nginx日志(十九)
  • 原文地址:https://www.cnblogs.com/zzuli2sjy/p/4924089.html
Copyright © 2020-2023  润新知