（回溯算法）有向无环图G(V,E),该图的顶点集合为V,边集E由E1与E2两部分组成,求出所有满足下列条件的路径(1)路径中至多包含E1中的两条边(2)可以包含E2中的任意条边(3)包含的边的数量≥3

题目

现有一有向无环图G(V,E),该图的顶点集合为V,边集E由E1与E2两部分组成,要求设计一个算法,求出所有满足下列条件的路径：
(1)路径中至多包含E1中的两条边
(2)路径中可以包含E2中的任意条边
(3)路径中包含的边的数量大于等于3

设计思路

采用回溯法解决此问题，找到所有满足条件的路径
数据结构采用邻接矩阵的方式存储图的信息
A[i][j] = 1; 代表有一条从顶点i到顶点j的属于边集E1的边
A[i][j] = 2; 代表有一条从顶点i到顶点j的属于边集E2的边
A[i][j] = 0; 代表没有从顶点i到顶点j的边
以每一顶点为起点回溯搜索边，若i,j之间有边，且满足：E1的边且当前路径中E1的边小于2条或者E2的边。则将顶点j加入到路径数组path中；当递归的层数大于等于四的时候，每进入一次递归输出一条满足条件的路径信息。

测试用例

input:
5 4 4
1 3
1 4
3 5
2 5
1 5
2 1
4 3
4 5
注：意思是有向无环图G有五个顶点（1，2，3，4，5），有四条属于集合E1的边，有四条属于集合E2的边，总共八条。边(1,3)，(1,4)，(3,5)，(2,5)属于集合E1。边(1,5)，(2,1)，(4,3)，(4,5)属于集合E2。如下图：

output:
1 4 3 5
2 1 3 5
2 1 4 3
2 1 4 3 5
2 1 4 5
注解：满足条件的路径一共五条，分别是：
1→4→3→5
2→1→3→5
2→1→4→3
2→1→4→3→5
2→1→4→5

代码实现

#include<cstdio>
#include<iostream>
#define N 100
using namespace std;
int A[N][N];
int path[N];	//保留路径信息
int n;	//代表图的顶点数
int sum1 = 0; //记录路径中属于边集E1的边的数量 
int e1,e2;		//边集E1的边数，边集E2的边数 
void initiation(){
	scanf("%d%d%d",&n,&e1,&e2); 
	if(n <= 3 || e1 + e2 < 3 || e2 == 0){
		printf("不存在满足条件的路径\n");
		// 因为题目设定是有向无环图，且路径中包含边的数量要求大于等于3
		// 则该图至少需要四个顶点才能产生三条边的路径 
		// 若总边数小于3,也不满足条件
		// 因为E1最多只能有两条边，所以如果E2的边数e2为零，
		// 满足条件的路径中边数也不可能大于等于3 
		return ; 
	}
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= n; j++)
			A[i][j] = 0;
	int x,y;
	for(int i = 1; i <= e1; i++){
		scanf("%d%d",&x,&y);
		A[x][y] = 1;
	} 
	for(int i = 1; i <= e2; i++){
		scanf("%d%d",&x,&y);
		A[x][y] = 2;
	} 
}
void output(int k){
	for(int i = 1; i <= k; i++)
		printf("%d ",path[i]);
	printf("\n");
}
void backtrack(int t);
void func(int k, int t){
	for(int j = 1; j <= n; j++){
		if(A[k][j] == 1 && sum1 < 2){
			sum1++;
			path[t + 1] = j;
			backtrack(t + 1);
			sum1--; 
		} else if(A[k][j] == 2 && sum1 <= 2){
			path[t + 1] = j;
			backtrack(t + 1);
		}
	}
}
void backtrack(int t){
	if(t == 1){
		for(int i = 1; i <= n; i++){
			path[t] = i;
			func(i, t);
		}
	}
	else{
		if(t >= 4){
			//当进入第四层以上的递归时，路径已经选好四个顶点了
			//也就是已经满足路径上的边数大于等于3了
			output(t);
		}
		int k = path[t];
		func(k, t); 
	}
}
int main(){
	initiation(); 
	backtrack(1);
	return 0;
}