最基础的“穷竭搜索”

时间：2018-08-02 19:14:54 阅读：177 评论：0 收藏：0 [点我收藏+]

标签：分享图片 margin square 实现操作 sed memory 计算比较

栈（Stack）

 1 #include <stack>
 2 #include <cstdio>
 3  
 4 using namespace std;
 5 
 6 int main(int argc, char * argv[])
 7 {
 8     stack<int> s;
 9     s.push(1);
10     s.push(2);
11     s.push(3);
12     printf("%d\n",s.size());
13     printf("%d\n",s.empty()); 
14     printf("%d\n",s.top());
15     s.pop();
16     printf("%d\n",s.top());
17     s.pop();
18     printf("%d\n",s.top());//stack非空 
19     s.pop();
20     printf("%d\n",s.size());
21     printf("%d\n",s.empty()); 
22     return 0; 
23 }

队列（Queue)

 1 #include <queue>
 2 #include <cstdio>
 3 
 4 using namespace std;
 5 
 6 int main(int argc, char * argv[])
 7 {
 8     queue<int> que;
 9     que.push(1);
10     que.push(2);
11     que.push(3);
12     printf("%d\n",que.size());
13     printf("%d\n",que.front());
14     printf("%d\n",que.back());
15     que.pop();
16     printf("%d\n",que.size());
17     printf("%d\n",que.front());
18     printf("%d\n",que.back());
19     que.pop();
20     printf("%d\n",que.size());
21     printf("%d\n",que.front());
22     printf("%d\n",que.back());
23     que.pop();
24     printf("%d\n",que.size());
25     printf("%d\n",que.front());//队列为空，返回值是不确定的
26     printf("%d\n",que.back());//队列为空，返回值是不确定的 
27     printf("%d\n",que.empty());
28 }

部分和问题

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

代码：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 bool dfs(int, int);
 6 
 7 int n,k;
 8 int * a;
 9 
10 int main()
11 {
12     cin >> n >> k;
13     a = new int[n];
14     for (int i=0; i<n; i++)
15     {
16         cin >> a[i];
17     }
18     bool f=dfs(0,0);
19     if (f) cout << "Yes!\n";
20     else cout << "No!\n"; 
21 }
22 
23 bool dfs(int i, int s)//已经从前n项得到了和s
24 {
25     if (i==n) return s==k;//如果前n项都已经计算过了，返回s与k是否相等 
26     if (dfs(i+1,s)) return true;// 不加上a[i]的情况 
27     if (dfs(i+1,s+a[i])) return true;//加上a[i]的情况 
28     return false;//无论是否加上a[i]都不能凑成k就返回false 
29 }

部分和问题

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)

代码：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int n,m;
 6 char ** a;
 7 
 8 void dfs(int, int);
 9 
10 int main()
11 {
12     cin >> n >> m;
13     a = new char*[n];
14     for (int i=0; i<n; i++) a[i]=new char[m];
15     for (int i=0; i<n; i++)
16     {
17         for (int j=0; j<m; j++)
18         {
19             cin >> j[i[a]];
20         }
21     }
22     int s=0;
23     for (int i=0; i<n; i++)
24     {
25         for (int j=0; j<m; j++)
26         {
27             if (j[i[a]]==‘W‘) 
28             {
29                 dfs(i,j);
30                 ++s;
31             }
32         }
33     }
34     cout << s << endl;
35 }
36 
37 void dfs(int x, int y)
38 {
39     y[x[a]] =‘.‘;
40     for (int dx=-1; dx<=1; dx++)
41     {
42         for (int dy=-1; dy<=1; dy++)
43         {
44             int xx=x+dx, yy=y+dy;
45             if (xx>=0 && xx<n && yy>=0 && yy<m && yy[xx[a]]==‘W‘) dfs(xx,yy);
46         }
47     }
48 }

Lake Counting

迷宫的最短路径

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

代码：

 1 #include <iostream>
 2 #include <queue>
 3 using namespace std;
 4 typedef pair<int,int> P;
 5 
 6 const int INF=100000000;
 7 const int MAX_N=100;
 8 const int MAX_M=100;
 9 char maze[MAX_N][MAX_M+1];
10 int n,m;
11 int sx=0,sy=1;
12 int tx=9,ty=8;
13 const int dx[4]{-1,0,0,1};
14 const int dy[4]{0,1,-1,0};
15 int d[MAX_N][MAX_M];
16 
17 int bfs();
18 
19 int main()
20 {
21     cin >> n >> m;
22     for (int i=0; i<n; i++)
23         for (int j=0; j<m; j++)
24             cin >> j[i[maze]];
25     cout << bfs();
26 }
27 
28 int bfs()
29 {
30     queue<P> que;
31     for (int i=0; i<n; i++)
32         for (int j=0; j<n; j++)
33             j[i[d]]=INF;
34     que.push(P(sx,sy));
35     sy[sx[d]]=0;
36     while (que.size())
37     {
38         P p=que.front();
39         que.pop();
40         if (p.first==tx && p.second==ty) break;
41         for (int i=0; i<4; i++)
42         {
43             int xx=p.first+dx[i];
44             int yy=p.second+dy[i];
45             if (xx>=0 && xx<n && yy>=0 && yy<m && yy[xx[maze]]!=‘#‘ && yy[xx[d]]==INF)
46             {
47                 que.push(P(xx,yy));
48                 yy[xx[d]]=p.second[p.first[d]]+1;
49             }
50         }
51     }
52     return ty[tx[d]];
53 }

迷宫的最短路径

特殊状态的枚举

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

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

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

贴一段书上的代码：

 1 bool used[MAX_N];
 2 int perm[MAX_N];
 3 
 4 void permutation1(int pos, int n)
 5 {
 6     if (pos==n)
 7     {
 8         /*
 9          *这里编写需要对perm进行的操作 
10          */
11         return ; 
12     }
13     for (int i=0; i<n; i++)
14         if (!used[i])
15         {
16             perm[pos]=i;
17             used[i]=true;
18             permutation1(pos+1,n);
19             used[i]=false;
20         }
21     return ;
22 }
23 _______________________________________________
24 #include <algorithm>
25 //即使有重复的元素也会生成所有的排列
26 //next_permutation是按照字典序来生成下一个排列的
27 int perm2[MAX_N];
28 void permutation2(int n)
29 {
30     for (int i; i<n; i++) perm2[i]=i;
31     do
32     {
33         /*
34          *这里编写需要对perm2进行的操作 
35          */
36     }
37     while (next_permutation(perm2, perm+n));
38     //所有的排列都生成后，next_permutation会返回false 
39     return ;
40 }

最基础的“穷竭搜索”

标签：分享图片 margin square 实现操作 sed memory 计算比较

原文地址：https://www.cnblogs.com/Ymir-TaoMee/p/9404341.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

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