HJ28 素数伴侣

描述

题目描述
若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的 N （ N 为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。

输入:

有一个正偶数 n ，表示待挑选的自然数的个数。后面给出 n 个具体的数字。

输出:

输出一个整数 K ，表示你求得的“最佳方案”组成“素数伴侣”的对数。

数据范围： 1 \le n \le 100 \1≤n≤100 ，输入的数据大小满足 2 \le val \le 30000 \2≤val≤30000

输入描述：

输入说明
1 输入一个正偶数 n
2 输入 n 个整数

输出描述：

求得的“最佳方案”组成“素数伴侣”的对数。

示例1

输入：

4
2 5 6 13
2
3 6

复制输出：

2
0

示例2

输入：

2
3 6

输出：

0

主要是看的牛客网的题解，但是觉得题解中有一部分有点解释不太清楚，甚至于GIF图还有点让人误解（。

由于大于2的偶数一定不是素数，那么，素数一定是由一个奇数加上一个偶数来配对完成的。

将所有的数字分为两个数组，一个是偶数数组，一个是奇数数组。

其实这样一看，这个匹配问题更像是 二部图的结点匹配问题。

然后要求求匹配数的最大值。

这里我想直接引用题解的原话：

引用地址 素数伴侣_牛客题霸_牛客网

题解作者：摸鱼学大师

感谢作者提供的思路以及实现代码！

以下为原题解的解释：

我们对于统计的数组分成奇数数组和偶数数组，如果其中有一个数组为空，则不可能构成“素数伴侣”。 然后就相当于是左边一些奇数元素的点，要连到右边偶数元素上面，这就是二分图连线最多的问题，我们可以用匈牙利算法。

首先我们遍历左边奇数数组，对每一个元素都查找能否在偶数数组中找到配对的数，查找时我们遍历偶数数组，如果该偶数能和这个奇数匹配，且在这一轮这个偶数没被用过，我们再检查这个match数组（表示现阶段偶数匹配的对象），如果match数组中这个偶数没有匹配对象，或者递归查找这个匹配对象可以有其他的偶数匹配，那我们修改该匹配对象为这个奇数，代表能找到匹配。

我一开始理解的是说，我们每匹配到一个就把match那边赋值，然后如果出现了你即将放进match这个数组的数的对应位置已经被别人捷足先登了，那么就去找这个捷足先登人的另一个可以放的位置，由于我们前面匹配的时候已经放了，所以说就可以直接把自己要放的位置给占下来。

就如同原题解的GIF动图一样。

但是只通过了6个例子。

我想啊，为啥错了呢，因为如果你前面一个奇数a假如匹配了2个位置，你把那两个位置先放了，后面来了一个奇数b，他十分厉害，所有的偶数和他加起来都能凑素数。那么他匹配到你这个a占用的第一个位置了，去判断，发现你还有个位置可以放，滚开滚开，让我来坐，然后霸道地把a的两个家的其中一个占了。后来来了个c，他只有一个位置可以放，恰好就是a剩下的那个房子，然后a也不让出来，c也坐不下去，a和c说，那你去把b从我上一个家里赶走啊，你把他赶走，我去住那个，把这个让给你！c说，不行，程序没有设定我这么干。于是这个结果就会偏小了。

后来在看了题解的代码之后，我发现这个解法的流程其实有点像是另一种类型的哈希表的散列函数处理冲突的时候的再寻址。只不过这次的再寻址，不像哈希表，哈希表是你这个地方被人占了，那你去找其他地方占去，而这里是如果你这个地方被人占了，你去和他协商，你能不能换个地方住啊，然后他去找能住的地方，然后如果他下一个能住的地方也被占了，那么他就去和下一个人说同样的话，只不过这个下一个人也不能来占你现在想要的这个房子了，不然不就闭环了吗（。不断循环递归，直到所有人都有房子住了，或者找到最后，最后一个人说，我没地方住了，不行！然后返回上一层递归，上一层递归的人再去找其他地方，直到所有的人说了不行，然后回来告诉你，实在是不能协调了，请你回去罢。这时候就不能让count++了。

下面贴代码

顺带一提，这里我复习了一下之前学的筛法求素数，所以素数判断和原来的题解不同

#include<iostream>
#include<vector>
#include<unordered_map>
#include<memory>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
bool st[80000];
int primes[20000];
int cnt = 0;
void Prime(int n);
bool find(const int& n, vector<int>& evens, vector<bool>& used, vector<int>& match);
int main()
{
	int n, i, j;
	while (cin >> n)
	{
		vector<int> odds, evens;

		int maxum = 0;
		for (i = 0; i < n; i++)
		{
			int temp;
			cin >> temp;
			maxum = max(maxum, temp);
			if (temp % 2)
			{
				odds.push_back(temp);
			}
			else
			{
				evens.push_back(temp);
			}
		}
		int count = 0;
		if (odds.size() == 0 || evens.size() == 0)
		{
			cout << 0;
			continue;
		}
		Prime(maxum * 2);
		vector<int> match(evens.size(), -1);
		for (i = 0; i < odds.size(); i++)
		{
			vector<bool> used(evens.size(), false);
			if (find(odds[i], evens, used, match))
			{
				count++;
			}
		}
		cout << count<<endl;
	}

	return 0;
}
void Prime(int n)
{
	memset(st, true, n + 1);
	int i = 0;
	int j;
	for (i = 2; i <= n; i++)
	{
		if (st[i])
		{
			primes[cnt++] = i;
		}
		for (j = 0; primes[j] <= n / i; j++)
		{
			st[primes[j] * i] = false;
			if (i % primes[j] == 0) break;
		}
	}
}
bool find(const int& num, vector<int>& evens, vector<bool>& used, vector<int>& match)
{
	for (int i = 0; i < evens.size(); i++)
	{
		if (st[num + evens[i]]&&!used[i])
		{
			used[i] = true;
			if (match[i] == -1 || find(match[i], evens, used, match))
			{
				match[i] = num;
				return true;
			}
		}
	}
	return false;
}