POJ3132——Sum of Different Primes

Sum of Different Primes

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 3243		Accepted: 2016

Description

A positive integer may be expressed as a sum of different prime numbers (primes), in one way or another. Given two positive integers n and k, you should count the number of ways to express n as a sum of k different primes. Here, two ways are considered to be the same if they sum up the same set of the primes. For example, 8 can be expressed as 3 + 5 and 5 + 3 but the are not distinguished.

When n and k are 24 and 3 respectively, the answer is two because there are two sets {2, 3, 19} and {2, 5, 17} whose sums are equal to 24. There are not other sets of three primes that sum up to 24. For n = 24 and k = 2, the answer is three, because there are three sets {5, 19}, {7, 17} and {11, 13}. For n = 2 and k = 1, the answer is one, because there is only one set {2} whose sum is 2. For n = 1 and k = 1, the answer is zero. As 1 is not a prime, you shouldn’t count {1}. For n = 4 and k = 2, the answer is zero, because there are no sets of two different primes whose sums are 4.

Your job is to write a program that reports the number of such ways for the given n and k.

Input

The input is a sequence of datasets followed by a line containing two zeros separated by a space. A dataset is a line containing two positive integers n and k separated by a space. You may assume that n ≤ 1120 and k ≤ 14.

Output

The output should be composed of lines, each corresponding to an input dataset. An output line should contain one non-negative integer indicating the number of the ways for n and k specified in the corresponding dataset. You may assume that it is less than 2³¹.

Sample Input

24 3 
24 2 
2 1 
1 1 
4 2 
18 3 
17 1 
17 3 
17 4 
100 5 
1000 10 
1120 14 
0 0

Sample Output

2 
3 
1 
0 
0 
2 
1 
0 
1 
55 
200102899 
2079324314

Source

类似于背包问题，不过有2个代价

设dp[i][j]表示 用j个素数表示出i这个数的方案数

dp[i][j] += dp[ i - prime][j - 1]

大家知道01背包优化到一维时体积需要逆序循环是因为 f[i][j] 需要由 f[i - 1][j - c]推得，而f[i - 1][j - c]又要存在dp[j - c]中，如果顺序循环，dp[j - c]中将存放f[i][j - c]，所以就不对了，对于此题，我们其实已经将状态降到二维了（本来是三维），所以同样的，在循环体积时，需要逆序

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

__int64 dp[1200][16];
int tot;
int prime[1200];
bool valid[1200];

void get_prime()
{
	memset (valid, 0, sizeof(valid));
	for (int i = 2; i <= 1120; ++i)
	{
		valid[i] = 1;
	}
	for (int i = 2; i <= 1120; ++i)
	{
		if (valid[i])
		{
			if (1120 / i < i)
			{
				break;
			}
			for (int j = i * i; j <= 1120; j += i)
			{
				valid[j] = 0;
			}
		}
	}
	for (int i = 2; i <= 1120; ++i)
	{
		if (valid[i])
		{
			prime[++tot] = i;
		}
	}
}

int main()
{
	tot = 0;
	get_prime();
	int n, k;
	memset (dp, 0, sizeof(dp));
	dp[0][0] = 1;
	for (int l = 1; l <= tot; ++l)
	{
		for (int j = 1120; j >= 2; --j)
		{
			for (int i = 14; i >= 1; --i)
			{
				if (j < prime[l])
				{
					continue;
				}
				dp[j][i] += dp[j - prime[l]][i - 1];
			}
		}
	}
	while (~scanf("%d%d", &n, &k))
	{
		if (!n && !k)
		{
			break;
		}
		printf("%I64d\n", dp[n][k]);
	}
	return 0;
}