openjudge.分成互质组（C语言）

openjudge.分成互质组（C语言）

描述

给定n个正整数，将它们分组，使得每组中任意两个数互质。至少要分成多少个组？

输入
第一行是一个正整数n。1 <= n <= 10。
第二行是n个不大于10000的正整数。
输出
一个正整数，即最少需要的组数。
样例输入

6
14 20 33 117 143 175

样例输出

3

思路：dfs，深度优先搜索

把分组看成一个选择的过程，我们需要知道的是当前的组数和当前是哪一个数在面临着选择，所以一深度优先搜索的入口参数是当前面临选择地数和当前的组数，然后分析递归出口，很显然，当面临所有数都有了选择时候就可以结束（return），出口时只要判断出当前优解就行了，然后递归的主题就是那当前要做比较的数跟每一组的数判断是否互质就行，如果满足条件就进入下一层递归，最后自己可以生成一个新的组，这样就完成了一个数的所有面临的选择。

1.递归入口参数：当前已有质数组，当前面临选择的数

2.递归出口：所有数都已近选择完，找到自己的组；出口时，保留当前最有答案。

3.递归过程：对于每一组，判断当前数是否可以进组，若可以，则进入下一层递归，别忘了，还可以自己生成新的一组。

其中判断是否互质使用欧几里得算法（辗转相除法）

#include<stdio.h>
typedef struct node
{
	int num;
	int a[10];
}strnode;
strnode b[10];
int k, ans = 20, n;
int date[10];
int gcd(int a, int b)
{
	if (b == 0)
		return a;
	return gcd(b, a % b);
}
void dfs(int i, int k)
{
	int j = 0, m = 0;
	if (i == n)
	{
		ans = ans < k ? ans : k;
		return;
	}
	else
	{
		for (j = 0; j < k; j++)
		{
			for (m = 0; m < b[j].num; m++)
			{
				if (gcd(date[i], b[j].a[m]) != 1)
				{
					break;
				}
			}
			if (m == b[j].num) {
				b[j].a[b[j].num++] = date[i];
				dfs(i + 1, k);
				b[j].num--;
			}
		}
		b[k].num = 1;
		b[k].a[0] = date[i];
		dfs(i + 1, k + 1);
		b[k].num = 0;
	}
}
int main()
{

	scanf("%d", &n);
	int  i = 0;
	for (i = 0; i < n; i++)
	{
		scanf("%d", &date[i]);
	}
	b[0].num = 1;
	b[0].a[0] = date[0];
	dfs(1, 1);
	printf("%d", ans);
	return 0;
}

上面这种写法使用了结构体储存了每一组质数组。
下面这种算法没有如此：

#include<stdio.h>
int n, a[12], b[12] = { 0 }, ans = 20;
int gcd(int a, int b)
{
	if (b == 0)
		return a;
	else
		return gcd(b, a % b);
}
void bfs(int x, int y)
{
	if (x == n) {
		ans = ans < y ? ans : y;
		return;
	}
	int i = 0, j = 0, flag;
	for (i = 1; i <= y; i++)
	{
		flag = 1;
		for (j = 0; j < x; j++)
		{
			if (b[j] == i && gcd(a[x], a[j]) != 1)  
			{
				flag = 0;
				break;
			}
		}
		if (flag) {
			b[x] = i;
			bfs(x + 1, y);
			b[x] = 0;
		}
	}
	b[x] = y + 1;
	bfs(x + 1, y + 1);
	b[x] = 0;
}
int main()
{
	int i = 0;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
		scanf("%d", &a[i]);
	b[0] = 1;
	bfs(1, 1);
	printf("%d", ans);
	return 0;
}

上面代码用的是用另外一组数组来储存对应的数的组数
有一个小细节的地方
在判断是否符合进组条件时，因为这里是直接把之前的数都判断一遍所以会有两个条件；
if (b[j] == i && gcd(a[x], a[j]) != 1)
首先是看这个数是否是当前在做判断的那一组，b[j]==i,是前提条件，然后才是判断gcd(a[x], a[j]) != 1

总结：不能对dfs理解的太死板，还是要对相应题目，能构思出dfs的搜索模型，把递归的哪三大块给解决就行了