（更好看的）C语言递归方法，把这道题高度函数化，增加扩展性，能够适应更多人的情况

（灵感来源）:

       首先，6层循环暴力破解太丑陋了，其次如果循环层数变一变就完蛋了，所以（为了偷懒）在想怎么样可以写一个控制循环嵌套次数的代码，于是就在朋友的帮助下想到了使用函数递归。

（分析）：

1. 对于这个题，需要知道最多可以有几个人，然后再对有这么多人数的情况进行输出；

2. 所以写了两个recursion，第一个找出最多人数，第二个对最多人数的情况进行输出（这里recursion（的本质）就是将所有情况分成二叉树）。

3. 然后需要知道当前的情况满不满足题目需要的条件，所以写了一个进行判断的函数    int RTG();//rule team go    进行判断，将所有的判断规则放进去，然后使用switch结构检查目前尝试的情况是否满足条件，做到每尝试一个数就马上进行判断，减少不必要的遍历。

（自吹自擂）优点：

1.全部函数化，并且每个尝试可以立即进行判断，以删除所有不必要的遍历，大大减少尝试次数；

2.判断写成函数，并用switch写的相对工整，不需要&& ||列在一起；

3.可以适应更多人数和更多规则的情况，只需简单对RTG部分进行更改然后调整n的值即可；

4.********最重要的一点********比6层循环和手动解题          更   好   看          。

参考代码:

#include<stdio.h>
#include<math.h>
#define sc scanf
#define pr printf

int n;

void output(int a[], int n);//输出
void initialize(int a[], int n);//初始化
int RTG(int a[], int i);//判断
int sum(int a[], int n);//求和
int recursion(int a[], int i);//递归求最大值
void recursion2(int a[], int i, int max);//递归找最大值对应输出

int main() {
	extern int n;
	n = 6;
	int a[n];
	initialize(a, n);
	int max = 0;
	max = recursion(a, 0);
	recursion2(a, 0, max);
	return 0;
}

int RTG(int a[], int i) {//rule team go进行检测
	switch(i) {
		case 0: {
			break;
		}
		case 1: {
			if(a[0]+a[1] == 0) return 0;
			break;
		}
		case 2: {
			if(a[1] != a[2]) return 0;
			break;
		}
		case 3: {
			if(a[0]+a[3] == 2) return 0;
			if(a[2]+a[3] != 1) return 0;
			break;
		}
		case 4: {
			if(a[3] == 0 && a[4] != 0) return 0;
			break;
		}
		case 5: {
			if(a[0]+a[4]+a[5] != 2) return 0;
			break;
		}
	}
	return 1;
}

void output(int a[], int n) {//输出
	int i;
	for(i = 0; i < n; i++) {
		if(a[i])pr("%c,",'A'+i);
	}
}

void initialize(int a[], int n) {//初始化
	int i;
	for(i = 0; i < n; i++) {
		a[i] = 0;
	}
}

int sum(int a[], int n) {//求和
	int i, sum = 0;
	for(i = 0; i < n; i++) {
		sum += a[i];
	}
	return sum;
}

int recursion(int a[], int i) {//递归求最大值
	extern int n;
	int r0 = 0, r1 = 0;
	if(i == n-1) {
		a[i] = 0;
		if(RTG(a, i)){
			r0 = sum(a, n);
		}
		a[i] = 1;
		if(RTG(a, i)){
			r1 = sum(a, n);
		}
		if(r0 > r1) {
			return r0;
		} else {
			return r1; 
		}
	} else {
		a[i] = 0;
		if(RTG(a, i)) {
			r0 = recursion(a, i+1);
		}
		a[i] = 1;
		if(RTG(a, i)) {
			r1 = recursion(a, i+1);
		}
		if(r0 > r1) {
			return r0;
		} else {
			return r1;
		}
	}
}

void recursion2(int a[], int i, int max) {//递归找最大值对应输出
	extern int n;
	if(i == n-1) {
		a[i] = 0;
		if(RTG(a, i)){
			if(sum(a, n) == max) {
				output(a, n);
			}
		}
		a[i] = 1;
		if(RTG(a, i)){
			if(sum(a, n) == max) {
				output(a, n);
			}
		}
	} else {
		a[i] = 0;
		if(RTG(a, i)) {
			recursion2(a, i+1, max);
		}
		a[i] = 1;
		if(RTG(a, i)) {
			recursion2(a, i+1, max);
		}
	}
}