D - Magic Multiplication（The 2018 ACM-ICPC Asia Qingdao Regional Contest）（找规律+构造）

D - Magic Multiplication（The 2018 ACM-ICPC Asia Qingdao Regional Contest）（找规律+构造）

Time limit：1000 ms
Memory limit：65536 kB
judge：
ZOJ 4061
vjudge

Description

BaoBao is now learning a new binary operation between two positive integers, represented by $\otimes$, in his magic book. The book tells him that the result of such operation is calculated by concatenating all multiple results of each digit in the two integers.

Formally speaking, let the first integer be $A=a_1{a}_2\dots a_n$, where $a_i$ indicates the $i$-th digit in $A$, and the second integer be $B=b_1{b}_2\dots b_m$, where $b_i$ indicates the $i$-th digit in $B$. We have $$A\otimes B=\sum _{i=1}^n\sum _{j=1}^m{a}_i{b}_j=a_1{b}_1+a_1{b}_2+\cdots +a_1{b}_m+a_2{b}_1+\cdots +a_n{b}_m$$ Note that the result of $a_i{b}_j$ is considered to be a \textbf{string} (without leading zeros if $a_i{b}_j>0$, or contains exactly one `0’ if $a_i{b}_j=0$), NOT a normal integer. Also, the sum here means \textbf{string concatenation}, NOT the normal addition operation.

For example, 23 $\otimes$ 45 = 8101215. Because $8=2\times 4$, $10=2\times 5$, $12=3\times 4$ and $15=3\times 5$.

BaoBao is very smart and soon knows how to do the inverse operation of $\otimes$. Now he gives you the result of a $\otimes$ operation and the numbers of digits in the two original integers. Please help him to restore the two original integers $A$ and $B$.

Input

There are multiple test cases. The first line of the input contains an integer $T$, indicating the number of test cases. For each test case:

The first line contains two positive integers $n$ and $m$ ($1\le n,m\le 2\times 10^5$), where $n$ indicates the length of $A$ and $m$ indicates the length of $B$. Here length of an integer means the length of the string when writing the number in decimal notation without leading zeros.

The second line contains only one positive integer $C$ without leading zeros, indicating the result of $A\otimes B$. The length of $C$ is no more than $2\times 10^5$.

It’s guaranteed that the sum of lengths of $C$ over all test cases will not exceed $2\times 10^6$.

Output

For each test case output one line.

If there exist such $A$ and $B$ that $A\otimes B=C$, output one line containing two integers $A$ and $B$ separated by one space. Note that $A$ and $B$ should be positive integers without leading zeros, the length of $A$ should be exactly $n$, and the length of $B$ should be exactly $m$.

If there are multiple valid answers, output the answer with the smallest $A$; If there are still more than one answer, output one of them with the smallest $B$.

If such $A$ and $B$ do not exist, print “Impossible” (without quotes) on a single line.

Sample Input

4
2 2
8101215
3 4
100000001000
2 2
80101215
3 4
1000000010000

Sample Output

23 45
101 1000
Impossible
Impossible

题意

这里又三个数字：$A,B,C$。给你 $A$ 和 $B$ 的长度和 $C$ ，问你是否能还原出 $A$ 和 $B$ ，如果能就输出 $A$ 和 $B$ 。

有如下运算：$$A\otimes B=\sum _{i=1}^n\sum _{j=1}^m{a}_i{b}_j=a_1{b}_1+a_1{b}_2+\cdots +a_1{b}_m+a_2{b}_1+\cdots +a_n{b}_m$$

例：23 $\otimes$ 45 = 8101215. Because $8=2\times 4$, $10=2\times 5$, $12=3\times 4$ and $15=3\times 5$。

题解

难点在于我们在枚举 $C$ 时无法确定该取一位数字还是两位数字。

但我们知道，两个长度为 $1$ 的数字相乘，其最小值是 $0$ ，最大值是 $81$ ，即乘积的长度不超过 $2$ 。其次，若乘积的长度是 $2$ ，则乘积的十位数字小于两个数字的任意一个；如果乘积的长度是 $1$ ，则乘积大于两个数字的任意一个。

所以我们在枚举数字时，只需要判断一下 $C$ 的数字和我们枚举的数字的大小就可知道该取 $1$ 位还是该取两位：如果 $C$ 的数字小于枚举数字，就取两位，然后判断是否能整除；如果 $C$ 的数字小于枚举数字，就取 $1$ 位，然后判断是否能整除。

因为 $A$ 和 $B$ 的长度是已知的，所以我们可以先枚举 $A[0]$ ，然后利用 $C$ 的前半部分和 $A[0]$ 枚举 $B$ （一个 $A[0]$ 对应 $1$ 个或 $0$ 个 $B$ ），然后再利用枚举的 $B$ 去推导剩余的 $A$ 。如果推导成功就得出了答案，而且因为推导的过程是由大到小的，所以第一个满足要求的答案就是最小的答案。

代码

#include <bits/stdc++.h>
#define maxn 200005
#define _for(i, a) for(int i = 0; i < (a); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define scl(x) scanf("%lld", &x)
#define sc(x) scanf("%d", &x)
using namespace std;

int T, n, m;
int a[maxn], b[maxn];
char c[maxn];

bool getb() {
    
    
	int len = strlen(c), pos = 0;
	_for(i, m) {
    
    
		if (pos == len) return 0;					//C不够用了
		int x = c[pos++] - '0';
		if (pos < len && x && x < a[0]) x = x * 10 + c[pos++] - '0';
		if (x % a[0] || x / a[0] > 9) return 0;		//除不尽或者商是两位数
		b[i] = x / a[0];
	}
	_rep(i, 1, n - 1) {
    
    
		_for(j, m) {
    
    
			if (pos == len) return 0;				//C不够用了
			int x = c[pos++] - '0';
			if (pos < len && x && x < b[j]) x = x * 10 + c[pos++] - '0';
			if (x && (b[j] == 0 || j && a[i] == 0)) return 0;	//a和b都为0但c不为0
			if (x == 0) {
    
    
				if (j && a[i] && b[j]) return 0;	//c为0但a和b都不为0；j不为0代表a已经被赋值
				if (!j) a[i] = 0;
			}
			else {
    
    
				if (x % b[j] || j && x / b[j] != a[i] || x / b[j] > 9) return 0;	//除不尽或者商是两位数
				a[i] = x / b[j];
			}
		}
	}
	return pos == len;
}

bool sol() {
    
    
	sc(n), sc(m);
	scanf("%s", c);
	int x = c[0] - '0';
	_rep(i, 1, 9) {
    
    		//利用a[0]找出b
		if (x % i == 0) {
    
    
			a[0] = i;
			if (getb()) return 1;
		}
	}
	x = x * 10 + c[1] - '0';
	_rep(i, 1, 9) {
    
    		//利用b找出a
		if (x % i == 0) {
    
    
			a[0] = i;
			if (getb()) return 1;
		}
	}
	return 0;
}

int main() {
    
    
	while (cin >> T) {
    
    
		_for(i, T) {
    
    
			if (sol()) {
    
    
				_for(j, n) printf("%d", a[j]);
				printf(" ");
				_for(j, m) printf("%d", b[j]);
				printf("\n");
			}
			else printf("Impossible\n");
		}
	}
	return 0;
}