深度优先搜索（DFS）

深度优先搜索算法（Depth-First-Search），是搜索算法的一种。是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止（属于盲目搜索）。

“一路走到头，不撞墙不回头"

https://www.jianshu.com/p/bff70b786bb6

部分和问题

给定整数a1、a2、.......an，判断是否可以从中选出若干数，使它们的和恰好为K。

输入

首先，n和k，n表示数的个数，k表示数的和。
接着一行n个数。
（1<=n<=20,保证不超int范围）

输出

如果和恰好可以为k，输出“YES”，并按输入顺序依次输出是由哪几个数的和组成，否则“NO”

样例输入

4 13
1 2 4 7

样例输出

YES
2 4 7

#include<bits/stdc++.h>
using namespace std;
int n,k,a[50];
int dfs(int i,int sum)
{
	if(n==i) return sum==k;
	if(dfs(i+1,sum)) return 1;
	if(dfs(i+1,sum+=a[i])) return 1;
	return 0;
}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	cin>>a[i];
	cin>>k;
	if(dfs(0,0))
	printf("Yes\n");
	else 
	printf("No\n");
	return 0;
 } 

http://poj.org/problem?id=2386

#include<stdio.h>
#include<iostream>
using namespace std;
int n,m;
char mp[106][106];
int d[8][2]={0,1,1,0,0,-1,-1,0,1,1,1,-1,-1,1,-1,-1};
void dfs(int x,int y)
{
	mp[x][y]=0;
	for(int i=0;i<8;i++)
	{
		int dx=x+d[i][0],dy=y+d[i][1];
		if(dx>=0&&dx<n&&dy>=0&&dy<m&&mp[dx][dy]=='W')
		dfs(dx,dy);
	}
	return;
}
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	for(int j=0;j<m;j++)
	cin>>mp[i][j];
	int ans=0;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			if(mp[i][j]=='W')
			{
				ans++;dfs(i,j);
			}
		 } 
	}
	printf("%d\n",ans);
	return 0;
 } 

http://acm.hdu.edu.cn/showproblem.php?pid=2553

#include<stdio.h>
#include<iostream>
using namespace std;
int n,m,ans=0;
int a[20][20],b[20],o;
int check(int x,int y)
{
	for(int i=0;i<x;i++)
	if(a[i][y]==1) return 0;
	for(int i=x-1,j=y-1;i>=0&&j>=0;i--,j--)
	if(a[i][j]==1) return 0;
	for(int i=x-1,j=y+1;i>=0&&j<o;i--,j++)
	if(a[i][j]==1) return 0;
	return 1;
}
void dfs(int x)
{
	if(x==o)
	{
		b[o]++;return;
	}
	for(int i=0;i<o;i++)
	{
		if(check(x,i))
		{
			a[x][i]=1;	
			dfs(x+1);
			a[x][i]=0;
		}
	}
}
int main()
{
	for(o=1;o<=10;o++)
	{
		dfs(0);
	}
	while(cin>>n)
	{
		if(n==0) break;
		 printf("%d\n",b[n]);
	}
	return 0;
 } 

V是节点数E是边的个数 
邻接矩阵
复杂度是V*V 
 就是用数组来存各个节点的关系 s->e有一条价值为v的边 a[s][e]=v; 
邻接表 
 复杂度是V+E 
 strcut edge
 {
 	int to,cost;//to是到哪个节点cost是价值 
  } 
 vector<int> G[N]；
 edge w; w.to=e;w.cost=e;
 s->e有一条价值为v的边 G[s].push_back(w);
 for(int i=0;i<V;i++)
 {
 	for(int j=0;j<G[s].size();j++)
 	{
 		
	 }
 }
  for(int i=0;i<V;i++)
       G[i].clear();