7-1 Forever (20分)

“Forever number” is a positive integer A with K digits, satisfying the following constrains:

• the sum of all the digits of A is m;
• the sum of all the digits of A+1 is n;
• the greatest common divisor of m and n is a prime number which is greater than 2.

Now you are supposed to find these forever numbers.

Input Specification:

Each input file contains one test case. For each test case, the first line contains a positive integer N (≤5). Then N lines follow, each gives a pair of K (3<K<10) and m (1<m<90), of which the meanings are given in the problem description.

Output Specification:

For each pair of K and m, first print in a line Case X, where X is the case index (starts from 1). Then print n and A in the following line. The numbers must be separated by a space. If the solution is not unique, output in the ascending order of n. If still not unique, output in the ascending order of A. If there is no solution, output No Solution.

Sample Input:

2
6 45
7 80

Sample Output:

Case 1
10 189999
10 279999
10 369999
10 459999
10 549999
10 639999
10 729999
10 819999
10 909999
Case 2
No Solution

思路分析：
直接暴力找A，数字每增1便判断一次，最后有一个测试点超时；
考虑dfs，每次在num末位添加一个数字，当num位数和所给条件相同时便是递归的边界，判断这个数字各位之和是否和m相等，然后判断num和num + 1是否满足条件：最大公因数是大于2的质数。注意点：

• 获取最大公因数的方法是辗转相除法；
• 判断素数的方法叫埃拉托斯特尼筛法，因为两个各位之和的最大公因数不会超过100，所以预先计算好100以内的素数，判断素数时直接返回结果；
• 当递归到某一步，如果后续全部加9，各位之和也达不到条件，则剪枝；

#include <iostream>
#include <algorithm> 
#include <vector>
using namespace std;
vector<pair<int, int> > res;
int n, digitCount, ASum;
//埃拉托斯特尼筛法
bool prime[100];
void getPrime() {
	fill(prime + 2, prime + 100, true);
	for (int i = 2; i < 100; i++) {
		if (prime[i]) {
			for (int j = i + i; j < 100; j += i) {
				prime[j] = false;
			}
		}
	}
}
bool isPrime(int num) {
	return prime[num] == true;
}
int gcd(int a, int b) {
	return b == 0 ? a : gcd(b, a % b);
}
int sumDigit(int num) {
	int n = 0;
	while (num != 0) {
		n += num % 10;
		num /= 10;
	}
	return n;
}
//用dfs找到满足位数、各位之和满足输入要求的数字
//三个参数分别为：当前数字的位数、当前数字各位之和、当前的数字
void dfs(int curDigit, int curSum, int num) {
	//当前位数和A位数一样时是递归边界
	if (digitCount == curDigit) {	
		if (curSum == ASum) {
			int n = sumDigit(num + 1);
			int maxCommon = gcd(ASum, n);
			if (isPrime(maxCommon) && maxCommon > 2) {
				res.push_back(make_pair(n, num));
			}
		}
		return;
	}
	//即使后续末位全部添9也没有Asum大，剪枝
	if (curSum + (digitCount - curDigit) * 9 < ASum) 
		return;
	//每次在最低位添加一个数字0~9
	for (int i = 0; i <= 9; i++) {
		if (curDigit == 0 && i == 0)	//0不能排在最高位
			continue;
		dfs(curDigit + 1, curSum + i, num * 10 + i);
	}
}
int main() {
	cin >> n;
	getPrime();
	for (int i = 1; i <= n; i++) {
		cin >> digitCount >> ASum;
		printf("Case %d\n", i);
		res.clear();
		dfs(0, 0, 0);
		sort(res.begin(), res.end());	//由dfs的执行顺序，res已经自动有序，不必排序
		for (auto e : res) {
			cout << e.first << " " << e.second << endl;
		}
		if (res.empty()) {
			cout << "No Solution" << endl;
		}
	}
}