ACM_程序设计竞赛：穷举法：DFS(深度优先)

DFS的伪码

• 从顶点v出发；
• 访问v相邻且未被访问的顶点$w_1$
• 依次$w_2,....,$,直到不能继续
• 退回到出发点v，
• 若v的领域还有为访问结点，重复上述

//结果：abdceghf

bool visited[MAX_VERTEX_NUM]; //访问数组标记
void DFSTraverse(Graph G)
{
   //对图G深度遍历，访问函数是visit()
   for(v=0; v<G.vexnum;++v)
     visited[v]=FALSE; // 初始化访问标记
   for(v=0;v<G,vexnum;++v) //从v=0开始遍历
     if(!visited[v])
        DFS(G,v);
}

void DFS(Graph G, int v)
{ //从顶点v出发，采用递归，深度遍历
    visit(v); // 访问顶点v
    visited[v]=TRUE; //标记访问
    for(w=FirstNeighbor(G,v); w>=0;w=NextNeighor(G,v,w))
    //FirstNeighbor()=图G中顶点x的第一个领接点，有则返回序列号
    //NextNeighor()=如果y是x的一个领接点，返回除y之外的顶点x的下一个领接点号
      if(!visited[w])
        DFS(G,w);  
}

• 复杂度
  
  1. 借助栈工作：空间复杂度：O(|V|)
  2. 领接矩阵：查找每个顶点的时间复杂度是$O(|v|^2)$
  3. 领接表：查找的时间(O(|E|)),访问的时间O(|v|); 总时间=O（|V|+|E|）

---

部分和问题

• 给定整数：$a_1,a_2,...,a_n$， 判断是否可以从中选出若干数，是其和恰好是k
  *限制条件
  $1 <= n <=20$
  $-10^8 <=a_i <=10^8$
  $-10 ^8 <=k <= 10^8$

• 例子
  输入：
  n=4
  a={1,2,4,7}
  k=13
  输出：
  YES {13=2+4+7}

• 例子
  输入：
  n=4
  a={1,2,4,7}
  k=15
  输出：
  NO

---

• 伪代码

//  输入：
int a[MAX_N];
int n;  //数组个数 
int k； //部分和

//前i项得到了和sum，现在对i项之后分支计算
dfs(项数i，部分和sum)
1.0 如果，i==n ; 判断是否sum==k；
2.0 不加a[i]；
2.1 如果，dfs（i+1，sum）成立，返回，true；
3.0 加上a[i]
3.1 如果dfs(i+1,sum+a[i])成立，返回，true
4.0 都不成立返回，false

solve()

1.0  if(dfs(0,0)), true，打印
2.0  if(dfs(0,0))，false，打印

#include <iostream>
using namespace std;

bool dfs (int i, int sum, int* a, int n, int k) {
    if (i==n) return sum == k;
    if(dfs(i+1, sum, a, n, k)) return true;
    if(dfs(i+1, sum+a[i], a, n, k)) return true;
    return false;
}

void solve(int* a, int n, int k) {
    if (dfs(0,0,a,n,k)) 
        cout<<"Yes"<<'\n';
    else 
        cout <<"No"<<'\n';
);
}


int main(void)
{
    const int MAX_N = 20;
    int a[MAX_N] = {1, 2, 4, 7};
    int n = 4, k = 13; //k位需要找到的数字

    solve(a, n, k);

    return 0;
}

• 赋值度
  $O(2^n)$

---

lake counting

• 题目
  大小为 N*M 的园子，雨后积水，八连通的积水被认为是联系在一起的，求园子有多少水洼

//八连通
***
*w*
***
//输入：N=10，M=12；
（w表示积水，*表示没有水）

w*********ww*
*www******www
****ww***ww*
*********ww*
*********w**
**w******w**
*w*w*****ww*
w*w*w*****w*
*w*w******w*
**w*******w*

//输出：3

• 算法：

  1. 从任意w开始，将领接部分用”*”替换
  2. 1次DFS后，与初始$w$连接的所有w都被替换为$*$
  3. 知道图中没有w
  4. 总共进行的DFS次数就是水洼数

• 复杂度：O（8*N*M）

#include <iostream>
using namespace std;

const int MAX_N = 10;
const int MAX_M = 12;

char field[MAX_N][MAX_M+1] = {
"+********++*",
"*+++*****+++",
"****++***++*",
"*********++*",
"*********+**",
"**+******+**",
"*+*+*****++*",
"+*+*+*****+*",
"*+*+******+*",
"**+*******+*"
};

//现在位置(x,y)
void dfs(int x, int y){
    field[x][y]='.';

    //循环遍历移动的8个方向
    for(int dx=-1;dx<=1;dx++){
        for(int dy=-1;dy<=1;dy++){
            //x方向移动dx，y方向移动dy，移动结果(nx,ny)
            int nx=x+dx,ny=y+dy;
            //判断(nx,ny)是不是园子内及是否有积水
            if(0<=nx && nx<MAX_N && 0<=ny && ny<MAX_M && field[nx][ny]=='+')
                dfs(nx,ny);
        }
    }
    return ;
}

void solve(){
    int res=0;
    for(int i=0;i<MAX_N;i++){
        for(int j=0;j<MAX_M;j++){
            if(field[i][j]=='+'){
                dfs(i,j);
                res++;
            }
        }
    }
    cout<<res<<'\n'<<endl;
}

int main(int argc, char* argv[])
{
    solve();
    return 0;
}

---