UVa 129 Krypton Factor

注意输出格式，比较坑爹。

每次要进行处理去掉容易的串，统计困难串的个数。

  1. #include<iostream>
  2. #include<vector>
  3. #include<cmath>
  4. #include<map>
  5. #include<algorithm>
  6. #include<cstring>
  7. #include<cstdio>
  8. #include<cstdlib>
  9. #include<string>
  10. #define INF 1000000000LL
  11. #define ll long long
  12. using namespace std;
  13. ];
  14. int cnt,K,L;
  15. bool check(int len)
  16. {
  17.     int l=strlen(str);
  18.     ||l==) return false;
  19.     ; i<=len/; ++i)
  20.     {
  21.         bool ok=true;
  22.         ; j<i&&ok; ++j)
  23.         {
  24.             -j]!=str[len--i-j])
  25.                 ok=false;
  26.         }
  27.         if(ok) return true;
  28.     }
  29.     return false;
  30. }
  31. void dfs(int pos)
  32. {
  33.     if(cnt>=K) return ;
  34.     else
  35.     {
  36.         ; i<L; ++i)
  37.         {
  38.             str[pos]='A'+i;
  39.             str[pos+]=;
  40.             )) cnt++;
  41.             else continue ;
  42.             dfs(pos+);
  43.             if(cnt>=K) return ;
  44.         }
  45.     }
  46. }
  47. int main()
  48. {
  49.     while(scanf("%d%d",&K,&L)!=EOF)
  50.     {
  51.         if(!K&&!L) break;
  52.         cnt=;
  53.         dfs();
  54.         int L=strlen(str);
  55.         ; str[i]; ++i)
  56.         {
  57.             ==&&i%) putchar(' ');
  58.             putchar(str[i]);
  59.             )%==) putchar('\n');
  60.         }
  61.         ) putchar('\n');
  62.         printf("%d\n",L);
  63.     }
  64.     ;
  65. }

SPOJ COMCB  1003

注意棋盘方格总数不会超过26。所以可以尝试dfs回溯寻找最优解。

怎么找字典序最小的，这个把棋盘画出来，然后指定一下每次跳的方向的顺序就行。如果第一个跳完全部棋盘的就是最优解。

这里要求输出最优解，每个位置是二维的，可以把它们压缩成一维，开一个数组，下标存第几步，内容存位置，这样就方便储存了。

实际上可行解并不多，可以打表。

  1.  

HDU 4848 Wow! Such Conquering!

首先用fylod求最短路，然后搜索。时间复杂度大约是30！。肯定要剪枝。

有两个剪枝，一个是如果当前时刻有星球永远无法到达，则return，另一个是如果到该星球以后的时间花费比当前最优解要小则剪枝。这样就能过了。

  1. #include <iostream>
  2. #include <string>
  3. #include <cstdio>
  4. #include <cstring>
  5. #include <algorithm>
  6. #define inf 100000000
  7. using namespace std;
  8. ][],tim[];
  9. int n;
  10. int ans;
  11. ];
  12. void dfs(int now,int rest,int all,int sum)
  13. {
  14.     if(all>=ans) return ;
  15.     )
  16.     {
  17.         ans=min(ans,all);
  18.         return ;
  19.     }
  20.     ; i<n; ++i)
  21.         if((!vis[i])&&(sum+dist[now][i]>tim[i]))
  22.             return;
  23.     ; i<n; ++i)
  24.     {
  25.         if(!vis[i])
  26.         {
  27.             int time=sum+dist[now][i];
  28.             if(time<=tim[i])
  29.             {
  30.                 if(ans<=all+rest*time) continue;
  31.                 vis[i]=true;
  32.                 dfs(i,rest-,all+time,time);
  33.                 vis[i]=false;
  34.             }
  35.         }
  36.     }
  37. }
  38. int main()
  39. {
  40.     while(scanf("%d",&n)!=EOF)
  41.     {
  42.         ; i<n; ++i)
  43.             ; j<n; ++j)
  44.             {
  45.                 scanf("%d",&dist[i][j]);
  46.             }
  47.         ; k<n; ++k)
  48.             ; i<n; ++i)
  49.                 ; j<n; ++j)
  50.                     dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
  51.         ; i<n; ++i)
  52.         {
  53.             scanf("%d",&tim[i]);
  54.         }
  55.         ans=inf;
  56.         memset(vis,,sizeof(vis));
  57.         vis[]=true;
  58.         dfs(,n-,,);
  59.         if(ans==inf) puts("-1");
  60.         else printf("%d\n",ans);
  61.     }
  62.     ;
  63. }

SGU 125  Shtirlits

给一个矩阵B，每个元素B[i][j]表示A[i][j]上下左右四周有多少个数大于自身。输出一个可能的矩阵A。

由于n<=3，完全可以暴力搜索解决。但是9^9肯定会超时的，考虑剪枝。对于每个A[i][j]枚举可能的元素，当枚举到第二行以上的时候，该元素上面的一个元素四周的元素都已经确定了，可以判断是否满足题意，不满足则剪枝。当枚举到最后一行的时候，还可以判断左边的元素是否满足题意。当所有元素都枚举完毕，要进行一次全体的判断，如果符合就是答案。

之前想到一个剪枝，以为每次枚举A[i][j]，可以从0枚举到9-B[i][j]。其实这是不对的，因为比A[i][j]大的元素可能是相同的。

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<algorithm>
  4. #include<cstring>
  5. using namespace std;
  6. ][];
  7. ][];
  8. int n;
  9. bool judge(int x,int y)
  10. {
  11.     <=x&&x<n&&<=y&&y<n;
  12. }
  13. ][]= {{-,},{,-},{,},{,}};
  14. bool check(int x,int y)
  15. {
  16.     ;
  17.     ; i<; ++i)
  18.     {
  19.         ],ny=y+Move[i][];
  20.         if(judge(nx,ny))
  21.         {
  22.             if(A[x][y]<A[nx][ny])
  23.                 cnt++;
  24.         }
  25.     }
  26.     return cnt==B[x][y];
  27. }
  28. bool dfs(int cur)
  29. {
  30.     if(cur==n*n)
  31.     {
  32.          ;i<n;++i)
  33.             ;j<n;++j)
  34.             if(!check(i,j)) return false;
  35.          return true;
  36.     }
  37.     const int x=cur/n,y=cur%n;
  38.     ; i<=; ++i)
  39.     {
  40.         A[x][y]=i;
  41.         &&!check(x-,y))||(x==n-&&y>=&&!check(x,y-)))
  42.             continue;
  43.         ))
  44.             return true;
  45.     }
  46.     return false;
  47. }
  48. int main()
  49. {
  50.     while(scanf("%d",&n)!=EOF)
  51.     {
  52.         ; i<n; ++i)
  53.             ; j<n; ++j)
  54.                 scanf("%d",&B[i][j]);
  55.         ))
  56.             puts("NO SOLUTION");
  57.         else
  58.         {
  59.             ; i<n; ++i)
  60.             {
  61.                 ; j<n; ++j)
  62.                     if(!j) printf("%d",A[i][j]);
  63.                     else printf(" %d",A[i][j]);
  64.                 printf("\n");
  65.             }
  66.         }
  67.     }
  68.     ;
  69. }

POJ 2676 Sudoku

简单数独。用一个剪枝，每次填该行该列该块未出现的数字，可以AC。

倒着搜索用时更少。

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. #include<cstdio>
  5. #include<cstdlib>
  6. #include<string>
  7. #include<cmath>
  8. #include<vector>
  9. #define INF 1000000000
  10. #define LL long long
  11. #define MAXN 100005
  12. using namespace std;
  13. ][];
  14. ][];
  15. ][],visrow[][],visblock[][];
  16. void init()
  17. {
  18.     memset(grid,,sizeof(grid));
  19.     memset(zero,,sizeof(zero));
  20.     memset(viscol,,sizeof(viscol));
  21.     memset(visrow,,sizeof(visrow));
  22.     memset(visblock,,sizeof(visblock));
  23. }
  24. bool dfs(int cur)
  25. {
  26.     ) return true;
  27.     ,y=cur%,num=(x/*)+(y/);
  28.     );
  29.     ; i<=; ++i)
  30.         if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
  31.         {
  32.             visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
  33.             grid[x][y]=i;
  34.             )) return true;
  35.             visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
  36.         }
  37.     return false;
  38. }
  39. int main()
  40. {
  41.     int T;
  42.     scanf("%d",&T);
  43.     while(T--)
  44.     {
  45.         init();
  46.         ; i<; ++i)
  47.         {
  48.             ];
  49.             scanf("%s",str);
  50.             ; str[j]; ++j)
  51.             {
  52.                 grid[i][j]=str[j]-';
  53.                 if(!grid[i][j])
  54.                     zero[i][j]=true;
  55.             }
  56.         }
  57.         ; i<; ++i)
  58.         {
  59.             ; j<; ++j)
  60.             {
  61.                 viscol[j][grid[i][j]]=true;
  62.                 visrow[i][grid[i][j]]=true;
  63.                 visblock[(i/*)+(j/)][grid[i][j]]=true;
  64.             }
  65.         }
  66.         dfs();
  67.         ; i<; ++i)
  68.         {
  69.             ; j<; ++j)
  70.                 printf("%d",grid[i][j]);
  71.             printf("\n");
  72.         }
  73.     }
  74.     ;
  75. }

POJ 2918 Tudoku

同POJ2676

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. #include<cstdio>
  5. #include<cstdlib>
  6. #include<string>
  7. #include<cmath>
  8. #include<vector>
  9. #define INF 1000000000
  10. #define LL long long
  11. #define MAXN 100005
  12. using namespace std;
  13. ][];
  14. ][];
  15. ][],visrow[][],visblock[][];
  16. void init()
  17. {
  18.     memset(grid,,sizeof(grid));
  19.     memset(zero,,sizeof(zero));
  20.     memset(viscol,,sizeof(viscol));
  21.     memset(visrow,,sizeof(visrow));
  22.     memset(visblock,,sizeof(visblock));
  23. }
  24. bool dfs(int cur)
  25. {
  26.     ) return true;
  27.     ,y=cur%,num=(x/*)+(y/);
  28.     );
  29.     ; i<=; ++i)
  30.         if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
  31.         {
  32.             visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
  33.             grid[x][y]=i;
  34.             )) return true;
  35.             visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
  36.         }
  37.     return false;
  38. }
  39. int main()
  40. {
  41.     ;
  42.     scanf("%d",&T);
  43.     while(T--)
  44.     {
  45.         init();
  46.         ; i<; ++i)
  47.         {
  48.             ];
  49.             scanf("%s",str);
  50.             ; str[j]; ++j)
  51.             {
  52.                 grid[i][j]=str[j]-';
  53.                 if(!grid[i][j])
  54.                     zero[i][j]=true;
  55.             }
  56.         }
  57.         ; i<; ++i)
  58.         {
  59.             ; j<; ++j)
  60.             {
  61.                 viscol[j][grid[i][j]]=true;
  62.                 visrow[i][grid[i][j]]=true;
  63.                 visblock[(i/*)+(j/)][grid[i][j]]=true;
  64.             }
  65.         }
  66.         dfs();
  67.         printf("Scenario #%d:\n",++kase);
  68.         ; i<; ++i)
  69.         {
  70.             ; j<; ++j)
  71.                 printf("%d",grid[i][j]);
  72.             printf("\n");
  73.         }
  74.         if(T) printf("\n");
  75.     }
  76.     ;
  77. }

UVa 989  Su Doku

注意判断无解的情况。

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. #include<cstdio>
  5. #include<cstdlib>
  6. #include<string>
  7. #include<cmath>
  8. #include<vector>
  9. #define INF 1000000000
  10. #define LL long long
  11. #define MAXN 100005
  12. using namespace std;
  13. ][];
  14. ][];
  15. ][],visrow[][],visblock[][];
  16. void init()
  17. {
  18.     memset(grid,,sizeof(grid));
  19.     memset(zero,,sizeof(zero));
  20.     memset(viscol,,sizeof(viscol));
  21.     memset(visrow,,sizeof(visrow));
  22.     memset(visblock,,sizeof(visblock));
  23. }
  24. int n,N;
  25. bool dfs(int cur)
  26. {
  27.     if(cur==N*N) return true;
  28.     int x=cur/N,y=cur%N,num=(x/n*n)+(y/n);
  29.     );
  30.     ; i<=N; ++i)
  31.         if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
  32.         {
  33.             visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
  34.             grid[x][y]=i;
  35.             )) return true;
  36.             visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
  37.         }
  38.     return false;
  39. }
  40. int main()
  41. {
  42.     ;
  43.     while(scanf("%d",&n)!=EOF)
  44.     {
  45.         init();
  46.         N=n*n;
  47.         if(kase)printf("\n");
  48.         ; i<N; ++i)
  49.         {
  50.             ; j<N; ++j)
  51.             {
  52.                 scanf("%d",&grid[i][j]);
  53.                 if(!grid[i][j])
  54.                     zero[i][j]=true;
  55.             }
  56.         }
  57.         ; i<N; ++i)
  58.         {
  59.             ; j<N; ++j)
  60.             {
  61.                 viscol[j][grid[i][j]]++;
  62.                 visrow[i][grid[i][j]]++;
  63.                 visblock[(i/n*n)+(j/n)][grid[i][j]]++;
  64.             }
  65.         }
  66.         bool ok=true;
  67.         ; i<&&ok; ++i)
  68.             ; j<=&&ok; ++j)
  69.                 ||visrow[i][j]>=||visblock[i][j]>=)
  70.                     ok=false;
  71.         ))
  72.         {
  73.             puts("NO SOLUTION");
  74.         }
  75.         else
  76.         {
  77.             ; i<N; ++i)
  78.             {
  79.                 ; j<N; ++j)
  80.                     if(!j) printf("%d",grid[i][j]);
  81.                     else printf(" %d",grid[i][j]);
  82.                 printf("\n");
  83.             }
  84.         }
  85.         kase=;
  86.     }
  87.     ;
  88. }

ACM 暴力搜索题 题目整理的更多相关文章

  1. bnuoj 33656 J. C.S.I.: P15（图形搜索题）

    http://www.bnuoj.com/bnuoj/problem_show.php?pid=33656 [题解]:暴力搜索题 [code]: #include <iostream> # ...

  2. hdu 4740 The Donkey of Gui Zhou(暴力搜索)

    题目地址:http://acm.hdu.edu.cn/showproblem.php?pid=4740 [题意]: 森林里有一只驴和一只老虎,驴和老虎互相从来都没有见过,各自自己走过的地方不能走第二次 ...

  3. Noip往年题目整理

    Noip往年题目整理 张炳琪 一．历年题目 按时间倒序排序 年份 T1知识点 T2知识点 T3知识点 得分 总体 2016day1 模拟 Lca,树上差分 期望dp 144 挺难的一套题目,偏思维难度 ...

  4. NOIP2010提高组真题部分整理（没有关押罪犯）

    目录 \(NOIP2010\)提高组真题部分整理 \(T1\)机器翻译: 题目背景: 题目描述: 输入输出格式: 输入输出样例: 说明: 题解: 代码: \(T2\)乌龟棋 题目背景: 题目描述: 输 ...

  5. 2013 ACM网络搜索与数据挖掘国际会议

    ACM网络搜索与数据挖掘国际会议" title="2013 ACM网络搜索与数据挖掘国际会议"> 编者按:ACM网络搜索与数据挖掘国际会议(6th ACM Conf ...

  6. 「浙江理工大学ACM入队200题系列」问题 J: 零基础学C/C++83——宁宁的奥数路

    本题是浙江理工大学ACM入队200题第八套中的J题 我们先来看一下这题的题面. 题面 题目描述 宁宁参加奥数班,他遇到的第一个问题是这样的:口口口+口口口=口口口,宁宁需要将1~9 九个数分别填进对应 ...

  7. 「浙江理工大学ACM入队200题系列」问题 A: 零基础学C/C++34—— 3个数比较大小(冒泡排序与选择排序算法)

    本题是浙江理工大学ACM入队200题第四套中的A题,同时给出了冒泡排序和选择排序算法 我们先来看一下这题的题面. 由于是比较靠前的题目,这里插一句.各位新ACMer朋友们,请一定要养成仔细耐心看题的习 ...

  8. [HDU 2102] A计划(搜索题,典型dfs or bfs)

    A计划 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submiss ...

  9. 历年NOIP中的搜索题

    什么题目都不会做于是开始做搜索题. 然而我搜索题也不会做了. 铁定没戏的蒟蒻. 1.NOIP2004 虫食算 “对于给定的N进制加法算式,求出N个不同的字母分别代表的数字,使得该加法算式成立.输入数据 ...

随机推荐

  1. BWT压缩算法（Burrows-Wheeler Transform）

    参考: BWT (Burrows–Wheeler_transform)数据转换算法 压缩技术主要的工作方式就是找到重复的模式,进行紧密的编码. BWT(Burrows–Wheeler_transfor ...

  2. BWA MEM算法

    现在BWA大家基本上只用其mem算法了,无论是二代还是三代比对到参考基因组上,BWA应用得最多的就是在重测序方面. Aligning sequence reads, clone sequences a ...

  3. USR-BLE101配置

    新买来的模块,默认为slave模式,波特率57600,8位数据位,无检验位,1位停止位. 发送+++a,进入命令模式. 1.设置模块名称 AT+NAME=BT_Shining 2.设置发射功率(最大功 ...

  4. selenium提供了三种模式的断言：assert,verify,waitfor

    Assert:失败时,该测试将终止 Verify:失败时,该测试继续执行,并将错误日志记录在日显示屏 Waitfor:等待某些条件变为真,一般使用在AJAX应用程序的测试 断言常用的有,具体见如下:a ...

  5. session和cookie

    第一次听到cookie这个词的时候着实兴奋了一段时间,以为是小饼干呢~快喝一杯82年的java压压惊!哈哈~ 与cookie的第一次邂逅——清缓存和清cookie 刚毕业的时候上班,做二次开发,明明后 ...

  6. Redis入门学习笔记一

    Redis 简要描述: 1.  Redis 是啥 ? Redis 英文名称全称为: Remote Dictionary Server ,中译为远程字典服务器. 是一款区分于磁盘数据库如(Mysql)的 ...

  7. VC++使用Pro*CC++

    几种数据库访问技术的比较 由上所述, Visual C++ 通过以上方法都可以访问Oracle 数据 库, 但是上述方法各有优缺点.ODBC 出现得比较早, 几乎支持所 有的关系型数据库, 而且有MF ...

  8. 区分IE版本的三个方法

    我们通常使用IE条件判断语言来处理IE的CSS问题,但其实还是有其他的一些方法来处理IE的CSS bug的. 一.IE条件判断语句 IE条件判断语句也许是用的最多的区分IE版本(IE6, IE7, I ...

  9. 张艾迪（创始人）： 整合全新的UIW.AD概念模式

    The World No.1 Girl :Eidyzhang The World No.1 Internet Girl :Eidyzhang AOOOiA.global Founder :Eidyzh ...

  10. 深入剖析tomcat 笔记——第8章 载入器

    深入剖析tomcat 笔记 目录: