最基础的“穷竭搜索”

---

 栈（Stack）

#include <stack>
#include <cstdio>
 
using namespace std;

int main(int argc, char * argv[])
{
    stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    printf("%d
",s.size());
    printf("%d
",s.empty()); 
    printf("%d
",s.top());
    s.pop();
    printf("%d
",s.top());
    s.pop();
    printf("%d
",s.top());//stack非空 
    s.pop();
    printf("%d
",s.size());
    printf("%d
",s.empty()); 
    return 0; 
} 

---

队列（Queue)

#include <queue>
#include <cstdio>

using namespace std;

int main(int argc, char * argv[])
{
    queue<int> que;
    que.push(1);
    que.push(2);
    que.push(3);
    printf("%d
",que.size());
    printf("%d
",que.front());
    printf("%d
",que.back());
    que.pop();
    printf("%d
",que.size());
    printf("%d
",que.front());
    printf("%d
",que.back());
    que.pop();
    printf("%d
",que.size());
    printf("%d
",que.front());
    printf("%d
",que.back());
    que.pop();
    printf("%d
",que.size());
    printf("%d
",que.front());//队列为空，返回值是不确定的
    printf("%d
",que.back());//队列为空，返回值是不确定的 
    printf("%d
",que.empty());
} 

---

部分和问题

• 题目大意：给定整数a₁,a₂,…,a_n,判断是否可以从中选出若干数，使它们的和恰好为k
• 限制条件：
  • 1≤n≤20
  • -10⁸≤a_i≤10⁸
  • -10⁸≤k≤10⁸
• 题解：深度优先搜索，从a₁开始按顺序决定每个数加或不加，在全部n个数都决定后在判断它们的和是不是k即可。因为状态数是2ⁿ，所以复杂度是O(2ⁿ)。
• 代码：

  #include <iostream>
  
  using namespace std;
  
  bool dfs(int, int);
  
  int n,k;
  int * a;
  
  int main()
  {
      cin >> n >> k;
      a = new int[n];
      for (int i=0; i<n; i++)
      {
          cin >> a[i];
      }
      bool f=dfs(0,0);
      if (f) cout << "Yes!
  ";
      else cout << "No!
  "; 
  }
  
  bool dfs(int i, int s)//已经从前n项得到了和s
  {
      if (i==n) return s==k;//如果前n项都已经计算过了，返回s与k是否相等 
      if (dfs(i+1,s)) return true;// 不加上a[i]的情况 
      if (dfs(i+1,s+a[i])) return true;//加上a[i]的情况 
      return false;//无论是否加上a[i]都不能凑成k就返回false 
  }

---

Lake Counting(POJ 2386)

• 原题如下：
  Lake Counting

  Time Limit: 1000MS	Memory Limit: 65536K
  Total Submissions: 44746	Accepted: 22116

  Description

  Due to recent rains, water has pooled in various places in Farmer John's field, which is represented by a rectangle of N x M (1 <= N <= 100; 1 <= M <= 100) squares. Each square contains either water ('W') or dry land ('.'). Farmer John would like to figure out how many ponds have formed in his field. A pond is a connected set of squares with water in them, where a square is considered adjacent to all eight of its neighbors. 
  
  Given a diagram of Farmer John's field, determine how many ponds he has.

  Input

  * Line 1: Two space-separated integers: N and M 
  
  * Lines 2..N+1: M characters per line representing one row of Farmer John's field. Each character is either 'W' or '.'. The characters do not have spaces between them.

  Output

  * Line 1: The number of ponds in Farmer John's field.

  Sample Input

  10 12
  W........WW.
  .WWW.....WWW
  ....WW...WW.
  .........WW.
  .........W..
  ..W......W..
  .W.W.....WW.
  W.W.W.....W.
  .W.W......W.
  ..W.......W.

  Sample Output

  3

  Hint

  OUTPUT DETAILS: 
  
  There are three ponds: one in the upper left, one in the lower left,and one along the right side.
• 题解：从任意的'W'开始，不停地把邻接的部分用'.'代替，1次dfs后与初始的这个W连接的所有'W'就都被替换成了'.'，因此直到图中不再存在w为止，总共进行dfs的次数就是答案了，复杂度是O(8*n*m)=O(m*n)
• 代码：

  #include <iostream>
  
  using namespace std;
  
  int n,m;
  char ** a;
  
  void dfs(int, int);
  
  int main()
  {
      cin >> n >> m;
      a = new char*[n];
      for (int i=0; i<n; i++) a[i]=new char[m];
      for (int i=0; i<n; i++)
      {
          for (int j=0; j<m; j++)
          {
              cin >> j[i[a]];
          }
      }
      int s=0;
      for (int i=0; i<n; i++)
      {
          for (int j=0; j<m; j++)
          {
              if (j[i[a]]=='W') 
              {
                  dfs(i,j);
                  ++s;
              }
          }
      }
      cout << s << endl;
  }
  
  void dfs(int x, int y)
  {
      y[x[a]] ='.';
      for (int dx=-1; dx<=1; dx++)
      {
          for (int dy=-1; dy<=1; dy++)
          {
              int xx=x+dx, yy=y+dy;
              if (xx>=0 && xx<n && yy>=0 && yy<m && yy[xx[a]]=='W') dfs(xx,yy);
          }
      }
  }

---

 迷宫的最短路径

• 题目大意：给定一个大小为N*M的迷宫，迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动，要求出从起点到终点所需的最小步数。假定从起点一定可以移动到终点。
• 限制条件：N,M≤100
• 题解：宽度优先搜索按照距开始状态由近及远的顺序进行搜索（只要将已经访问的状态用标记管理起来），因此可以很容易地用来求最短路径、最少操作之类问题的答案。这个问题中状态仅仅是目前所在位置的坐标，因此可以构造成pair或者编码成int来表达状态。当状态更加复杂时，就需要封装成一个类来表示状态了。复杂度是O(4*n*m)=O(n*m)
• 代码：

  #include <iostream>
  #include <queue>
  using namespace std;
  typedef pair<int,int> P;
  
  const int INF=100000000;
  const int MAX_N=100;
  const int MAX_M=100;
  char maze[MAX_N][MAX_M+1];
  int n,m;
  int sx=0,sy=1;
  int tx=9,ty=8;
  const int dx[4]{-1,0,0,1};
  const int dy[4]{0,1,-1,0};
  int d[MAX_N][MAX_M];
  
  int bfs();
  
  int main()
  {
      cin >> n >> m;
      for (int i=0; i<n; i++)
          for (int j=0; j<m; j++)
              cin >> j[i[maze]];
      cout << bfs();
  }
  
  int bfs()
  {
      queue<P> que;
      for (int i=0; i<n; i++)
          for (int j=0; j<n; j++)
              j[i[d]]=INF;
      que.push(P(sx,sy));
      sy[sx[d]]=0;
      while (que.size())
      {
          P p=que.front();
          que.pop();
          if (p.first==tx && p.second==ty) break;
          for (int i=0; i<4; i++)
          {
              int xx=p.first+dx[i];
              int yy=p.second+dy[i];
              if (xx>=0 && xx<n && yy>=0 && yy<m && yy[xx[maze]]!='#' && yy[xx[d]]==INF)
              {
                  que.push(P(xx,yy));
                  yy[xx[d]]=p.second[p.first[d]]+1;
              }
          }
      }
      return ty[tx[d]];
  }

---

 特殊状态的枚举

虽然生成可行解空间多数采用深度优先搜索，但在状态空间比较特殊时其实可以很简短地实现

如，C++标准库中提供了next_permutation函数，可以把n个元素共n!种不同的排列生成出来

又如，通过位运算，可以枚举n个元素中取出k个的共C(n,k)种状态或是某个集合中的全部子集等

贴一段书上的代码：

bool used[MAX_N];
int perm[MAX_N];

void permutation1(int pos, int n)
{
    if (pos==n)
    {
        /*
         *这里编写需要对perm进行的操作 
         */
        return ; 
    }
    for (int i=0; i<n; i++)
        if (!used[i])
        {
            perm[pos]=i;
            used[i]=true;
            permutation1(pos+1,n);
            used[i]=false;
        }
    return ;
}
_______________________________________________
#include <algorithm>
//即使有重复的元素也会生成所有的排列
//next_permutation是按照字典序来生成下一个排列的
int perm2[MAX_N];
void permutation2(int n)
{
    for (int i; i<n; i++) perm2[i]=i;
    do
    {
        /*
         *这里编写需要对perm2进行的操作 
         */
    }
    while (next_permutation(perm2, perm+n));
    //所有的排列都生成后，next_permutation会返回false 
    return ;
}