1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char mp[8][8];
int v[8];
int n,k,w,r;//状态计数器 r
void dfs(int x)//逐行深搜，x 为当前搜索行
{
    if(w==k)//下子数 w
    {
        r++;return;
    }
    if(x==n)return;
    for(int i=0;i<n;i++)
    {
        if(v[i]!=1&&mp[x][i]=='#')
        {
            v[i]=1;
            w++;
            dfs(x+1);
            w--;
            v[i]=0;
        }
    }
    dfs(x+1);//搜索下一行
}

int main()
{
    while(cin>>n>>k)
    {
        if(n==-1&&k==-1)
            return 0;
        memset(mp,0,sizeof(mp));
        memset(v,0,sizeof(v));
        for(int i=0;i<n;i++)
            cin>>mp[i];
        w=0;r=0;
        dfs(0);
        cout<<r<<endl;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include"iostream"
using namespace std;
typedef unsigned long long ll;
int n;
bool sign;

void dfs(ll x,int count)
{
    if(sign)
        return ;
    if(x%n==0){
        sign=true;
        cout<<x<<endl;
        return ;
    }
    if(count==19)//m 最多 200 位
        return ;
    dfs(x*10,count+1);
    dfs(x*10+1,count+1);
    //每两位数后两位有两种情况，10 或 11，深搜所有情况，找到一种就返回，找不到找另外一颗子树
}
int main()
{
    while(cin>>n&&n)
    {
        sign=false;
        dfs(1,0);
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include<bits/stdc++.h>
using namespace std;

int n,m,s;
char maze[107][107];
int vx[8]={-1,1,0,0,-1,-1,1,1};
int vy[8]={0,0,-1,1,-1,1,1,-1};

void dfs(int x,int y){
    maze[x][y]='*';
    for(int i=0;i<8;i++){
        int tx=x+vx[i];
        int ty=y+vy[i];
        if(tx>=0&&tx<m&&ty>=0&&ty<n&&maze[tx][ty]=='@')
            dfs(tx,ty);
    }
}

int main(){
    int i,j;
    while(cin>>m>>n&&m){
        s=0;
        for(i=0;i<m;i++)
            cin>>maze[i];
        for(i=0;i<m;i++){//相当于不连通的情况
            for(j=0;j<n;j++){
                if(maze[i][j]=='@'){
                    dfs(i,j);
                    s++;
                }
            }
        }
        cout<<s<<endl;
    }
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <bits/stdc++.h>
#define N 5
using namespace std;
int maze[N][N] = {//无权有向图邻接矩阵
     { 0, 1, 0, 1, 0 },
     { 0, 0, 1, 0, 0 },
     { 0, 0, 0, 0, 1 },
     { 0, 0, 1, 0, 0 },
     { 0, 0, 0, 0, 0 }
 };
 int visited[N];
 void DFS(int start)
 {
     cout << start<< " ";
     visited[start] = 1;
     for (int i = 0; i < N; i++)
     {
         if (!visited[i] && maze[start][i] == 1)//没访问过且为邻居节点
             DFS(i);
     }
 }
 void BFS(int start){
     queue<int> Q;//队列
     Q.push(start);
     visited[start] = 1;
     while (!Q.empty())
     {
         int front = Q.front();//头
         cout << front << " ";
         Q.pop();
         for (int i = 0; i <N; i++)
         {
             if (!visited[i] && maze[front][i] == 1)
             {
                 visited[i] = 1;
                 Q.push(i);
             }
         }
     }
 }

 int main()
 {
     memset(visited,0,sizeof(visited));
     for (int i = 0; i < N; i++)//不连通的情况
     {
         if (visited[i] == 1)//访问过
             continue;
         DFS(i);
     }
     cout<<endl;
     memset(visited,0,sizeof(visited));
     for (int i = 0; i < N; i++)//不连通的情况
     {
         if (visited[i] == 1)//访问过
             continue;
         BFS(i);
     }
     return 0;
 }