BFS算法与树的层次遍历很像，具有明显的层次性，一般都是使用队列来实现的！！！

常用步骤：

1、设置访问标记int visited[N]，要覆盖所有的可能访问数据个数，这里设置成int而不是bool，基于一个考虑，多次循环时不用每次都清空visited，传递进去每次一个数字即可，比如第一次标记为1,判断也采用==1，之后递加即可。

2、设置一个node，用来记录相关参数和当前的步数，比如：

  1. struct node
  2. {
  3.     int i;
  4.     int j;
  5.     int k;
  6.     int s;//步数
  7. };

3、设计数据读取过程

  1. int count=1;
  2. while(true)
  3. {
  4.         cin>>*****;
  5.  
  6.         if(l==0 && r==0 && c==0)//跳出机制
  7.             break;
  8.  
  9.         for(i=0;i<l;i++)//读数据
  10.         {
  11.             for(j=0;j<r;j++)
  12.                 cin>>road[i][j];
  13.             getline(cin,tmp);
  14.         }
  15.  
  16.         getroad(count);//传递进去次数，用来visited的标记
  17.  
  18.         count++;//每次递增等等
  19. }

4、设计队列是否为空的while循环

  1. while(!q.empty())
  2. {
  3.         first=q.front();
  4.         q.pop();
  5.  
  6. ......
  7. ......
  8. ......
  9. }

第一道题目：Catch That Cow http://poj.org/problem?id=3278

Input

Line 1: Two space-separated integers: N and K

Output

Line 1: The least amount of time, in minutes, it takes for Farmer John to catch the fugitive cow.

Sample Input

  1. 5 17

Sample Output

  1. 4

先对知识点进行初步总结：

搜索算法主要包括DFS和BFS以及这两种方式的变种，另外搜索算法还可以根据搜索条件的信息是否为启发式的信息分为盲目搜索和启发式搜索等。

与深度搜索和广度搜索关联最大的知识点是树与二叉树遍历相关，另外在搜索过程中一定注意搜索条件的剪枝！！

剪枝：就是在搜索算法的优化中，通过某种判断，避免一些不必要的遍历过程。剪枝优化的核心问题是设计剪枝判断方法，即确定哪些枝条应当舍弃，哪些枝条应当保留的方法。

在设计过程中需要通过设计出合理的判断方法，以决定某一分支的取舍，需要遵循一定的原则：
    1） 正确性
          剪枝的前提是一定要保证不丢失正确的结果。
    2）准确性
         在保证了正确性的基础上，需要根据具体问题具体分析，采用合适的判断手段，使不包含最优解的枝条尽可能多的被剪去，以达到程序“最优化”的目的。
    3）高效性
         优化的根本目的是要减少搜索的次数，使程序运行的时间减少。一定要在优化与效率之间寻找一个平衡点，使得程序的时间复杂度尽可能降低。
剪枝算法按照其判断思路可大致分成两类：可行性剪枝及最优性剪枝：

可行性剪枝：判断继续搜索能否得出答案，如果不能直接回溯。

最优性剪枝：又称为上下界剪枝，是一种重要的搜索剪枝策略。它记录当前得到的最优值，如果当前结点已经无法产生比当前最优解更优的解时，可以提前回溯。

参考自这里

所以对于剪枝的设计是保证一些搜索算法不超时的重要设计步骤！！！

回到题目，此题使用全搜索肯定会超时，所以一定要根据需求设计剪枝条件：

1、x<0时肯定需要剪枝，因为此时不可能再求得最优解；

2、x最大值的剪枝是需要确定为多少呢？有人说是要2*N，但是直接使用N也是可以AC的，所以尽量使用N吧。

参考代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include<queue>
  4.  using namespace std;
  5.  
  6.  #define N 100000
  7.  int map[N+];
  8.  
  9.  int n,k;
  10.  
  11.  struct node
  12.  {
  13.      int num;
  14.      int step;
  15.  };
  16.  
  17.  bool check(int local_num)
  18.  {
  19.      if(local_num <= N && local_num >  && map[local_num] == )
  20.          return true;
  21.      else
  22.          return false;
  23.  }
  24.  
  25.  void bfs()
  26.  {
  27.      queue<node> Q;
  28.      node first,next;
  29.      first.num = n;
  30.      first.step = ;
  31.      map[first.num] = ;
  32.  
  33.      if(n == k)
  34.      {
  35.          cout<<first.step;
  36.          return;
  37.      }
  38.      Q.push(first);
  39.  
  40.      while(!Q.empty())
  41.      {
  42.          first = Q.front();
  43.          Q.pop();
  44.  
  45.          next.step = first.step + ;
  46.  
  47.          next.num = first.num - ;
  48.          if(next.num == k)
  49.          {
  50.              cout<<next.step;
  51.              return;
  52.          }
  53.          if(check(next.num))
  54.          {
  55.              map[next.num] = ;
  56.              Q.push(next);
  57.          }
  58.  
  59.          next.num = first.num + ;
  60.          if(next.num == k)
  61.          {
  62.              cout<<next.step;
  63.              return;
  64.          }
  65.          if(check(next.num))
  66.          {
  67.              map[next.num] = ;
  68.              Q.push(next);
  69.          }
  70.  
  71.          next.num =  * first.num;
  72.          if(next.num == k)
  73.          {
  74.              cout<<next.step;
  75.              return;
  76.          }
  77.          if(check(next.num))
  78.          {
  79.              map[next.num] = ;
  80.              Q.push(next);
  81.          }
  82.      }
  83.      return;
  84.  }
  85.  
  86.  int main()
  87.  {
  88.      while(cin>>n>>k)
  89.          bfs();
  90.  
  91.      return ;
  92.  }

另外的一个考虑，当数据量比较多时，直接使用队列应该是不如数组模拟更节省内存。对比一下：

直接使用标准库的queue Memory: 1248K         Time: 16MS
使用数组来模拟循环队列 Memory: 1868K         Time: 32MS

却得到了更为耗时的结果，也就说明标准库的设计肯定是比较优化的结果了，一定要尽量使用标准库的数据结构，而不是自己创造！！！

使用数组模拟循环队列代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include <queue>
  4.  using namespace std;
  5.  
  6.  #define N 100000
  7.  
  8.  int n,k;
  9.  
  10.  struct node
  11.  {
  12.      int num;
  13.      int step;
  14.  };
  15.  
  16.  int map[N+];
  17.  node queue1[N+];
  18.  
  19.  bool check(int local_num)
  20.  {
  21.      if(local_num <= N && local_num >  && map[local_num] == )
  22.          return true;
  23.      else
  24.          return false;
  25.  }
  26.  
  27.  void bfs()
  28.  {
  29.      node first,next;
  30.      first.num = n;
  31.      first.step = ;
  32.      map[first.num] = ;
  33.  
  34.      if(n == k)
  35.      {
  36.          cout<<first.step;
  37.          return;
  38.      }
  39.  
  40.      int f=,l=;
  41.  
  42.      queue1[f++] = first;
  43.  
  44.      while(f != l)
  45.      {
  46.          first = queue1[l++];
  47.  
  48.          next.step = first.step + ;
  49.  
  50.          next.num = first.num - ;
  51.          if(next.num == k)
  52.          {
  53.              cout<<next.step;
  54.              return;
  55.          }
  56.          if(check(next.num))
  57.          {
  58.              map[next.num] = ;
  59.              queue1[f++] = next;
  60.          }
  61.  
  62.          next.num = first.num + ;
  63.          if(next.num == k)
  64.          {
  65.              cout<<next.step;
  66.              return;
  67.          }
  68.          if(check(next.num))
  69.          {
  70.              map[next.num] = ;
  71.              queue1[f++] = next;
  72.          }
  73.  
  74.          next.num =  * first.num;
  75.          if(next.num == k)
  76.          {
  77.              cout<<next.step;
  78.              return;
  79.          }
  80.          if(check(next.num))
  81.          {
  82.              map[next.num] = ;
  83.              queue1[f++] = next;
  84.          }
  85.      }
  86.      return;
  87.  }
  88.  
  89.  int main()
  90.  {
  91.      while(cin>>n>>k)
  92.          bfs();
  93.  
  94.      return ;
  95.  }

New one： Find The Multiple： http://poj.org/problem?id=1426

Input

The input file may contain multiple test cases. Each line contains a value of n (1 <= n <= 200). A line containing a zero terminates the input.

Output

For each value of n in the input print a line containing the corresponding value of m. The decimal representation of m must not contain more than 100 digits. If there are multiple solutions for a given value of n, any one of them is acceptable.

Sample Input

  1. 2
  2. 6
  3. 19
  4. 0

Sample Output

  1. 10
  2. 100100100100100100
  3. 111111111111111111

题目是一个典型的逆向广度优先组合0和1组成的数据，判断是否可以被n整除即可。

本题最大的考点除此之外还有对整数数据结构的考察，即short--int--long--long long--unsigned long long的所能表示的最大范围！

总结：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　占用内存字节　　　　　　　　　　　　　　表示数据位数

char                       -128 ~ +127                                  (1 Byte)
short                     -32767 ~ + 32768                          (2 Bytes)
unsigned short       0 ~ 65536                                      (2 Bytes)

int                         -2147483648 ~ +2147483647         (4 Bytes)　　　　　　　　　　　　　　　11位，超过11位的数据一定考虑long long  和 unsigned long long　
unsigned int           0 ~ 4294967295                             (4 Bytes)

long == int

long long               -9223372036854775808 ~ +9223372036854775807           (8 Bytes)

unsigned long long的最大值：0~1844674407370955161                                    (8 Bytes)

double                  1.7 * 10^308                                  (8 Bytes)

参考代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include <queue>
  4.  using namespace std;
  5.  
  6.  #define N 1000
  7.  
  8.  void bfs(int n)
  9.  {
  10.      if(n == )
  11.      {
  12.          cout<<""<<endl;
  13.          return;
  14.      }
  15.  
  16.      queue<unsigned long long> Q;
  17.  
  18.      unsigned long long first = ;
  19.      Q.push(first);
  20.  
  21.      while()
  22.      {
  23.          first = Q.front();
  24.          Q.pop();
  25.  
  26.          first = first*;
  27.  
  28.          if(first%n == )
  29.          {
  30.              cout<<first<<endl;
  31.              break;
  32.          }
  33.          Q.push(first);
  34.  
  35.          first += ;
  36.          if(first%n == )
  37.          {
  38.              cout<<first<<endl;
  39.              break;
  40.          }
  41.          Q.push(first);
  42.      }
  43.  
  44.      return;
  45.  }
  46.  
  47.  int main()
  48.  {
  49.     // freopen("data.in", "r", stdin);
  50.  
  51.      int n;
  52.      while(cin>>n)
  53.      {
  54.          if(n == )
  55.              break;
  56.          bfs(n);
  57.      }
  58.  
  59.      //fclose(stdin);
  60.      return ;
  61.  }

New one： Prime Path： http://poj.org/problem?id=3126

Input

One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).

Output

One line for each case, either with a number stating the minimal cost or containing the word Impossible.

Sample Input

  1. 3
  2. 1033 8179
  3. 1373 8017
  4. 1033 1033

Sample Output

  1. 6
  2. 7
  3. 0

需要明确：

1、素数定义

质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数。

质数大于等于2 不能被它本身和1以外的数整除，即对正整数n，如果用2到    根号n   之间的所有整数去除，均无法整除，则n为质数。

判断：

python:

  1.  def is_prime(n):
  2.      list_num = []
  3.      for i in range(2, n):
  4.          for num in range(2, int(sqrt(n))+1):
  5.              if i % num == 0 and i != num:
  6.                  break
  7.              elif i % num != 0 and num == int(sqrt(n)):
  8.                  list_num.append(i)
  9.       return list_num

C++:

  1.  bool isPrime(unsigned long n)
  2.  {
  3.      if (n <= )
  4.          return n > ;
  5.      else if (n %  ==  || n %  == )
  6.          return false;
  7.      else
  8.      {
  9.          for (unsigned short i = ; i * i <= n; i += )//这里的等号一定不能少！！！！！
  10.              if (n % i ==  || n % (i + ) == )
  11.                  return false;
  12.          return true;
  13.      }
  14.  }

解决了这些问题，题目就很好理解了。

参考代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include <queue>
  4.  #include <cmath>
  5.  #include <cstring>
  6.  
  7.  using namespace std;
  8.  
  9.  int num_map[];//n-1000为索引值
  10.  
  11.  struct node
  12.  {
  13.      int num;
  14.      int step;
  15.  };
  16.  
  17.  bool isPrime(int n)
  18.  {
  19.      //考虑2,3,5,...到根号下n能否被整除
  20.      if(num_map[n-])
  21.      {
  22.          num_map[n-] = ;
  23.          return false;
  24.      }
  25.  
  26.      if (n %  ==  || n %  == )
  27.          return false;
  28.      else
  29.      {
  30.          for (unsigned short i = ; i * i <= n; i += )
  31.              if (n % i ==  || n % (i + ) == )
  32.                  return false;
  33.          return true;
  34.      }
  35.  }
  36.  
  37.  void bfs(int lnum1,int lnum2)
  38.  {
  39.      if(lnum1 == lnum2)
  40.      {
  41.          cout<<""<<endl;
  42.          return;
  43.      }
  44.      queue<node> Q;
  45.      node n1,n2;
  46.      n1.num = lnum1;
  47.      n1.step = ;
  48.  
  49.      if(isPrime(n1.num))
  50.          Q.push(n1);
  51.  
  52.      while(!Q.empty())
  53.      {
  54.          n1 = Q.front();
  55.          Q.pop();
  56.  
  57.          for(int i=;i<;i++)
  58.          {
  59.              int es = ;
  60.              for(int ei=;ei<-i;ei++)//根据i值获得处理的对应位数
  61.                  es *= ;
  62.  
  63.              for(int j=;j<;j++)
  64.              {
  65.                  if(i== && j==)
  66.                      continue;
  67.                  if(i==)
  68.                      j++;
  69.  
  70.                  int tmpj1 = n1.num/es/;
  71.  
  72.                  int tmpj2= n1.num%es;
  73.  
  74.                  int tmp  = tmpj1*es* + j*es + tmpj2;
  75.  
  76.                  if(tmp == n1.num)
  77.                      continue;
  78.  
  79.                  n2.num = tmp;
  80.                  n2.step = n1.step + ;
  81.                  if(n2.num == lnum2)
  82.                  {
  83.                      cout<<n2.step<<endl;
  84.                      return;
  85.                  }
  86.  
  87.                  if(isPrime(tmp))
  88.                      Q.push(n2);
  89.              }
  90.          }
  91.      }
  92.      return;
  93.  }
  94.  
  95.  int main()
  96.  {
  97.      int n,num1,num2;
  98.      cin>>n;
  99.  
  100.      while(n> && cin>>num1>>num2)
  101.      {
  102.          bfs(num1,num2);
  103.          n--;
  104.      }
  105.  
  106.      return ;
  107.  }

此代码可以得出正确的结果，但是会超时Time Limit Exceeded，原因在于每一次的操作都有这么多次的乘法除法和取余的操作，尤其是判断一个数是不是质数的取余判断也是非常的多。

所以接下来要做的地方有两点：1、优化质数判断算法，2、用空间换时间来避免超时

1、判断1~n中所有的质数

从2~N逐一检查，如果是就显示出来，如果不是，就检查下一个。方法正确但效率不高。改进1就是只测试2与所有的奇数就足够了，同理，3是质数，但3的倍数却不是，如果能够把2与3的倍数跳过去而不测试，任意连续的6个数中，只测试2个。以6n,6n+1,6n+2,6n+3,6n+4,6n+5为例，6n,6n+2,6n+4是偶数，又6n+3是3的倍数，所以如果2与3的倍数都不理会，只要测试的数就只留下6n+1和6n+5而已了，因而工作量只是前面想法的2/6=1/3。

另外判断一个数i是不是质数，是使用2~sqrt(i)的数去除，没有能够除尽的则i为质数，否则就不是质数！ 这里应该考虑到，如果2除不尽，那么2的倍数也除不尽；同理，3除不尽，3的倍数也除不尽，所以最理想的方法就是用质数去除i来判断。如果是从2开始找所有的质数，则可以准备一个数组prime[]，用来存放找到的素数，一开始它里面有2、3、5，判断时用prime[]中小于sqrt(i)的数去除i 即可。

对应题目：判断1000~9999之间的数字是否为质数，只需要记录2-102之间的所有的质数作为判断的基数，然后找到所有的1000-9999中所有的质数标记。然后在大逻辑中直接进行判断即可。

注意点：

1、判断基数设置到102，如果代码中只取i<100，那么会得到25个质数，即p[24]=97，而97*97=9409，那么到9999之间的数据判断就会显示索引越界！使用102则会有26个质数，最后一个为101，而101*101>9999的，正常！！

2、判断质数时使用0-sqrt(n)来除，使用代码prime[j]*prime[j]<=n，这里的等号一定不能省略，否则会得出错误结果！！！！！(此bug调试耗时半天~~~切记)

3、切记广度优先和深度优先的特点：如果只要求最小的步骤数，不要求每一步的详细步骤，则肯定是广度优先，切记广度优先无法输出详细步骤，若要输出每一步的步骤，则肯定是要用深度优先了！！！！

参考代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include <queue>
  4.  #include <cmath>
  5.  #include <cstring>
  6.  
  7.  using namespace std;
  8.  
  9.  int prime[];//记录0-99所有的质数
  10.  
  11.  int num_map[];//n-1000为索引值
  12.  
  13.  int num_flag[];//n-1000为索引值,标记所有的质数
  14.  
  15.  struct node
  16.  {
  17.      int num;
  18.      int step;
  19.  };
  20.  
  21.  void init()
  22.  {
  23.      prime[]=;
  24.      prime[]=;
  25.      prime[]=;
  26.  
  27.      int i,j,n,pos;
  28.      bool flag;
  29.      for(i=,n=,pos=;i<&&n<;pos=-pos)
  30.      {
  31.          flag = true;
  32.          for(j=;j<i&&prime[j]*prime[j]<=n;j++)
  33.          {
  34.              if(n%prime[j] == )
  35.              {
  36.                  flag = false;
  37.                  break;
  38.              }
  39.          }
  40.          if(flag)//n是质数，然后进行下一个数的判断
  41.              prime[i++]=n;
  42.          n+=pos;
  43.      }
  44.      for(n=,pos=;n<;pos=-pos)
  45.      {
  46.          flag=true;
  47.          for(j=;prime[j]*prime[j]<=n;j++)
  48.          {
  49.              if(n%prime[j] == )
  50.              {
  51.                  flag = false;
  52.                  break;
  53.              }
  54.          }
  55.          if(flag)
  56.              num_flag[n-]=;
  57.          n+=pos;
  58.      }
  59.  }
  60.  
  61.  void bfs(int is,int lnum1,int lnum2)
  62.  {
  63.      if(lnum1 == lnum2)
  64.      {
  65.          cout<<""<<endl;
  66.          return;
  67.      }
  68.      queue<node> Q;
  69.      node n1,n2;
  70.      n1.num = lnum1;
  71.      n1.step = ;
  72.  
  73.      Q.push(n1);
  74.      num_map[n1.num-]=is;
  75.  
  76.      while(!Q.empty())
  77.      {
  78.          n1 = Q.front();
  79.          Q.pop();
  80.  
  81.          for(int i=;i<;i++)
  82.          {
  83.              int es = ;
  84.              for(int ei=;ei<-i;ei++)//根据i值获得处理的对应位数
  85.                  es *= ;
  86.  
  87.              for(int j=;j<;j++)
  88.              {
  89.                  if(i== && j==)
  90.                      continue;
  91.                  if(i==)
  92.                      j++;
  93.  
  94.                  int tmpj1 = n1.num/es/;
  95.                  int tmpj2 = n1.num%es;
  96.                  int tmp   = tmpj1*es* + j*es + tmpj2;
  97.  
  98.                  if(tmp == n1.num || num_map[tmp-]==is)
  99.                      continue;
  100.  
  101.                  n2.num = tmp;
  102.                  n2.step = n1.step + ;
  103.                  if(n2.num == lnum2)
  104.                  {
  105.                      cout<<n2.step<<endl;
  106.                      return;
  107.                  }
  108.  
  109.                  if(num_flag[tmp-])
  110.                  {
  111.                      Q.push(n2);
  112.                      num_map[tmp-]=is;
  113.                  }
  114.              }
  115.          }
  116.      }
  117.      cout<<"Impossible"<<endl;
  118.      return;
  119.  }
  120.  
  121.  int main()
  122.  {
  123.      int n,num1,num2;
  124.      cin>>n;
  125.  
  126.      init();
  127.      while(n> && cin>>num1>>num2)
  128.      {
  129.          bfs(-n,num1,num2);
  130.          n--;
  131.      }
  132.  
  133.      return ;
  134.  }

New one： Shuffle'm Up： http://poj.org/problem?id=3087

Input

The first line of input contains a single integer N, (1 ≤ N ≤ 1000) which is the number of datasets that follow.

Each dataset consists of four lines of input. The first line of a dataset specifies an integer C, (1 ≤ C ≤ 100) which is the number of chips in each initial stack (S1 and S2). The second line of each dataset specifies the colors of each of the C chips in stack S1, starting with the bottommost chip. The third line of each dataset specifies the colors of each of the C chips in stack S2 starting with the bottommost chip. Colors are expressed as a single uppercase letter (A through H). There are no blanks or separators between the chip colors. The fourth line of each dataset contains 2 * C uppercase letters (A through H), representing the colors of the desired result of the shuffling of S1 and S2 zero or more times. The bottommost chip’s color is specified first.

Output

Output for each dataset consists of a single line that displays the dataset number (1 though N), a space, and an integer value which is the minimum number of shuffle operations required to get the desired resultant stack. If the desired result can not be reached using the input for the dataset, display the value negative 1 (−1) for the number of shuffle operations.

Sample Input

  1. 2
  2. 4
  3. AHAH
  4. HAHA
  5. HHAAAAHH
  6. 3
  7. CDE
  8. CDE
  9. EEDDCC

Sample Output

  1. 1 2
  2. 2 -1

好多遍才读明白，s2和s1交叉叠放，再中间切开，下面为s1，上面为s2，再次进行交叉，依次进行直到得到s12的排放输出循环的步数，如果一直都无法得到s12，则输出-1。

那么什么时候标志着肯定无法模拟出来呢？切开后的s1与原始的s1一样并且s2和原始的s2也一致，那么肯定会进入死循环！！！

使用字符串进行模拟是个很好的方法，一直模拟下去，直到成功或者进入死循环输出-1即可。

参考代码：

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  #include <queue>
  4.  #include <cmath>
  5.  #include <cstring>
  6.  
  7.  using namespace std;
  8.  string s1,s2,s0;//把这三个变量当作全局的，方便比对
  9.  
  10.  void shuffle(int len)
  11.  {
  12.      string ns1,ns2,ns0;
  13.      int step=;
  14.      ns1=s1;
  15.      ns2=s2;
  16.  
  17.      while(true)
  18.      {
  19.          ns0="";
  20.          int i;
  21.          for(i=;i<len;i++)
  22.          {
  23.              ns0+=ns2[i];
  24.              ns0+=ns1[i];
  25.          }
  26.          step+=;
  27.  
  28.          if(ns0 == s0)
  29.          {
  30.              cout<<step<<endl;
  31.              return;
  32.          }
  33.          ns1="";
  34.          ns2="";
  35.          for(i=;i<len;i++)
  36.              ns1+=ns0[i];
  37.          for(i=len;i<*len;i++)
  38.              ns2+=ns0[i];
  39.  
  40.          if(ns1==s1 && ns2==s2)
  41.          {
  42.              cout<<"-1"<<endl;
  43.              return;
  44.          }
  45.      }
  46.  }
  47.  
  48.  int main()
  49.  {
  50.      int n;
  51.      cin>>n;
  52.      int i=;
  53.      while(n>)
  54.      {
  55.          int len;
  56.          cin>>len;
  57.          cin>>s1>>s2>>s0;
  58.  
  59.          cout<<i++<<" ";
  60.          shuffle(len);
  61.  
  62.          n--;
  63.      }
  64.  
  65.      return ;
  66.  }

直接使用模拟来做，与搜索无关呀！可否使用广度搜索来进行？？？

New one： Pots： http://poj.org/problem?id=3414

Input

On the first and only line are the numbers A, B, and C. These are all integers in the range from 1 to 100 and C≤max(A,B).

Output

The first line of the output must contain the length of the sequence of operations K. The following K lines must each describe one operation. If there are several sequences of minimal length, output any one of them. If the desired result can’t be achieved, the first and only line of the file must contain the word ‘impossible’.

Sample Input

  1. 3 5 4

Sample Output

  1. 6
  2. FILL(2)
  3. POUR(2,1)
  4. DROP(1)
  5. POUR(2,1)
  6. FILL(2)
  7. POUR(2,1)

倒水，

[ACM训练] 算法初级 之 搜索算法 之 广度优先算法BFS (POJ 3278+1426+3126+3087+3414)的更多相关文章

  1. [ACM训练] 算法初级 之 搜索算法 之 深度优先算法DFS (POJ 2251+2488+3083+3009+1321)

    对于深度优先算法,第一个直观的想法是只要是要求输出最短情况的详细步骤的题目基本上都要使用深度优先来解决.比较常见的题目类型比如寻路等,可以结合相关的经典算法进行分析. 常用步骤: 第一道题目:Dung ...

  2. 【算法入门】广度/宽度优先搜索(BFS)

    广度/宽度优先搜索(BFS) [算法入门] 1.前言 广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广度来描述)是连通图的一种遍历策略.因为它的思想是从一个顶点V0开始,辐射状地优先遍历其周围较 ...

  3. 最近关于ACM训练与算法的总结

            到了大四以后越来越意识到基础知识的重要性,很多高屋建瓴的观点与想法都是建立在坚实的基础之上的, 招式只有在强劲的内力下才能发挥最大的作用,曾经有段时间我有这样的想法:我们出去以后和其他 ...

  4. C语言之广度优先算法

    广度优先算法又称宽度优先搜索,是一种简便的图的搜索算法之一.搜索方式大致是这样的: 直到搜索到目标结点(结点就是那些圆球球,其中有一个或者多个是目标结点)或者搜完了整个图都没找到目标结点就停止搜索. ...

  5. 寒假的ACM训练（一）

    今天开始ACM训练,选择了刘汝佳的<挑战编程>,暂时算是开始了. 测评的网址: http://www.programming-challenges.com 第一个题目是水题啦.3n+1. ...

  6. 广度优先搜索 BFS算法

    广度优先搜索算法(Breadth-First-Search,BFS),又称作宽度优先搜索.BFS算法是从根节点开始,沿着树的宽度遍历树的节点.如果所有节点均被访问,则算法中止. 算法思想 1.首先将根 ...

  7. 2014暑假ACM训练总结

    2014暑假ACM训练总结报告 匆匆之中,一个暑假又过去了,在学校训练的这段日子真的是感觉日子过得好快啊! 时光如箭,日月如梭! 匆忙的学习之中一个暑假就这样结束了,现在就来写一些总结吧,供自己以后阅 ...

  8. 指定url和深度的广度优先算法爬虫的python实现

    本文参考http://zoulc001.iteye.com/blog/1186996 广度优先算法介绍 整个的广度优先爬虫过程就是从一系列的种子节点开始,把这些网页中的"子节点"( ...

  9. golang 实现广度优先算法(走迷宫)

    maze.go package main import ( "fmt" "os" ) /** * 广度优先算法 */ /** * 从文件中读取数据 */ fun ...

随机推荐

  1. ng-disabled 不起作用的解决办法

    不知道这算不算 Angular.js 的一个bug.但搜索一番后找到了一个变通的解决办法. 业务需求是这样的, 按钮被点击一次之后就设置为禁用状态, 以阻止多次无效的点击.但现在很多框架都用 < ...

  2. Thread Safety线程安全

    Thread Safe(线程安全)和None Thread Safe(NTS,非线程安全)之分 如果disabled就选择nts(php_stomp-1.0.9-5.5-nts-vc11-x86.zi ...

  3. 如何在Linux上使用文件作为内存交换区(Swap Area)

    交换区域(Swap Area)有什么作用? 交换分区是操作系统在内存不足(或内存较低)时的一种补充.通俗的说,如果说内存是汽油,内存条就相当于油箱,交换区域则相当于备用油箱. Ubuntu Linux ...

  4. （一）Netty源码学习笔记之概念解读

    尊重原创,转载注明出处,原文地址:http://www.cnblogs.com/cishengchongyan/p/6121065.html  博主最近在做网络相关的项目,因此有契机学习netty,先 ...

  5. repo 修改邮箱地址

    需要重新运行 repo init 被带上参数: --config-name xx@a.com

  6. Java注解基础概念总结

    注解的概念 注解(Annotation),也叫元数据(Metadata),是Java5的新特性,JDK5引入了Metadata很容易的就能够调用Annotations.注解与类.接口.枚举在同一个层次 ...

  7. 你不知道的Spring配置文件

    Spring配置文件是用于指导Spring工厂进行Bean生产.依赖关系注入(装配)及Bean实例分发的"图纸".Java EE程序员必须学会并灵活应用这份"图纸&quo ...

  8. ios 输入框bar设置

    _textView = [[class alloc] init];        _textView.translatesAutoresizingMaskIntoConstraints = NO;   ...

  9. hive 复杂类型

    hive提供一种复合类型的数据 struct:可以使用"."来存取数据 map:可以使用键值对来存取数据 array:array中存取的数据为相同类型,其中的数据可以通过下表获取数 ...

  10. 高性能缓存系统Redis安装与使用

    在互联网后台架构中,需要应付高并发访问数据库,很多时候都会在数据库上层增加一个缓存服务器来保存经常读写的数据以减少数据库压力,可以使用LVS.Memcached或Redis,Memcached和Red ...