【算法】DFS

参考：作者：RomanticChopin【DFS–基本入门模板 和 例题 （绝对入门） (最全)】

void dfs()//参数用来表示状态  
{  
    if(到达终点状态)  
    {  
        ...//根据题意添加  
        return;  
    }  
    if(越界或者是不合法状态)  
        return;  
    if(特殊状态)//剪枝
        return ;
    for(扩展方式)  
    {  
        if(扩展方式所达到状态合法)  
        {  
            修改操作;//根据题意来添加  
            标记；  
            dfs（）；  
            (还原标记)；  
            //是否还原标记根据题意  
            //如果加上（还原标记）就是 回溯法  
        }  
    }  
}  

【组合+判断素数】

题目描述
已知 n 个整数b1,b2,…,bn 以及一个整数 k（k＜n）。
从 n 个整数中任选 k 个整数相加，可分别得到一系列的和。
例如当 n=4，k＝3，4 个整数分别为 3，7，12，19 时，可得全部的组合与它们的和为：
3＋7＋12=22
3＋7＋19＝29
7＋12＋19＝38
3＋12＋19＝34
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数：3＋7＋19＝29。

输入 第一行两个整数：n , k （1<=n<=20，k＜n）
第二行n个整数：x1,x2，…,xn （1<=xi<=5000000）

输出 一个整数（满足条件的方案数）。

样例输入 4 3 3 7 12 19
样例输出 1

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
int i,n,k;
int ans=0;
int num[22];

bool isPrime(int num){ //判断素数 
	if(num<=1) return false;
	for(i=2;i*i<=num;i++){
		if(num%i==0) return false;
	}
	return true;
}

//sum：当前数字的和；
//numCnt：当前有几个数字；
//nowIndex：现在正在处理数组元素的下标。 
void DFS(int sum,int count,int index){
	if(count==k){ //此时已经累加了k个数字，检查sum是否是素数（到达终点状态）
		if(isPrime(sum)) ++ans;
		return;
	}
	if(index==n) return; //因为下标从 0 开始计数，如果正在处理的元素下标越过数组界限，直接返回（越界状态）
	DFS(sum+num[index],count+1,index+1); //把当前正在处理的元素算上
	DFS(sum,count,index+1); //跳过当前元素
}

int main(){
	cin>>n>>k;
	for(int i=0;i<n;i++){
		scanf("%d",&num[i]);
	}
	DFS(0,0,0);
	printf("%d",ans);
	return 0;
}

【红色警报】

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序，当失去一个城市导致国家被分裂为多个无法连通的区域时，就发出红色警报。注意：若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报。
输入格式： 输入在第一行给出两个整数N（0 < N ≤ 500）和M（≤
5000），分别为城市个数（于是默认城市从0到N-1编号）和连接两城市的通路条数。随后M行，每行给出一条通路所连接的两个城市的编号，其间以1个空格分隔。在城市信息之后给出被攻占的信息，即一个正整数K和随后的K个被攻占的城市的编号。
注意：输入保证给出的被攻占的城市编号都是合法的且无重复，但并不保证给出的通路没有重复。 输出格式：
对每个被攻占的城市，如果它会改变整个国家的连通性，则输出Red Alert: City k is
lost!，其中k是该城市的编号；否则只输出City k is lost.即可。如果该国失去了最后一个城市，则增加一行输出Game
Over.。
输入样例：

5 4 0 1 1 3 3 0 0 4 5 1 2 0 4 3

输出样例：

City 1 is lost. City 2 is lost. Red Alert: City 0 is lost! City 4 is
lost. City 3 is lost. Game Over.

【递归入门】全排列

排列与组合是常用的数学方法。
先给一个正整数 ( 1 < = n < = 10 ) 例如n＝3，所有组合,并且按字典序输出： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1

输入 输入一个整数n( 1<=n<=10)

输出 输出所有全排列
每个全排列一行，相邻两个数用空格隔开（最后一个数后面没有空格）

样例输入 3
样例输出 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1

#include<iostream>
using namespace std;
 
int num[11];
bool vis[11]={false};
int n;
 
void dfs(int index){
	if (index==n){
		for (int i=0;i<n;i++){
			if(i==0) cout<<num[i];
			else cout<<" "<<num[i];
		}
		cout<<endl;
		return;
	}
	
	for (int i=1;i<=n;i++){
		if (vis[i]==false){
			num[index] = i;
			vis[i] = true;
			dfs(index+1);
			vis[i] = false;
		}
	}
}
 
int main(){
	cin>>n;
	dfs(0);
	return 0;
}

【哥尼斯堡的“七桥问题”】

输入格式:
输入第一行给出两个正整数，分别是节点数N (1≤N≤1000)和边数M；随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个节点的编号（节点从1到N编号）。

输出格式： 若欧拉回路存在则输出1，否则输出0。

输入样例1: 6 10
1 2
2 3
3 1
4 5
5 6
6 4
1 4
1 6
3 4
3 6
输出样例1: 1
输入样例2: 5 8
1 2
1 3
2 3
2 4
2 5
5 3
5 4
3 4
输出样例2: 0

无向图存在欧拉回路有两个条件
1.所有顶点度数为偶数 if(count[i]%2!=0)
2.该图为连通图 用dfs

#include<iostream>
#include<stdio.h>
using namespace std;
int N,M,i,j,a,b;
bool flag[1020];
int count[1020];
int side[1020][1020]; //m=side[i][j]：表示与i点相连 的第j个结点是 m 
int sum=0; 
 
void dfs(int index){
	flag[index]=true; //走过了index点
	sum++; //走过的点数+1
	if(sum==N){ //走过了所有点 
		return;
	} 
	for(int i=0;i<count[index];i++){ //遍历此点的所有连接点 
		if(flag[ side[index][i] ]==false){ //未走过此点 
			dfs(side[index][i]);
		} 
	} 
}
 
int main(){
	cin>>N>>M;
	for(i=0;i<=N;i++){
		flag[i]=false; //用于记录是否走过这个点
		count[i]=0; //记录连接这个点的数目 
	}
	for(i=0;i<M;i++){
		cin>>a>>b;
		side[a][count[a]++]=b; //记录与a连接 
		side[b][count[b]++]=a; //记录与b连接 
	} 
	
	//判断是否所有顶点度数是偶数
	for(i=0;i<=N;i++){
		if(count[i]%2!=0){
			cout<<"0";
			return 0;
		}
	}
	
	dfs(1); //判断是否是连通图 
	
	if(sum!=N) {
		cout<<"0";
		return 0;
	}
	else cout<<"1";
	return 0;
}

【跳马问题】

【八皇后问题】