团体程序设计天梯赛-练习集 L2-018. 多项式A除以B 模拟-优快云博客

本文链接：https://blog.youkuaiyun.com/EventQueue/article/details/66976179

L2-018. 多项式A除以B

时间限制

400 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

陈越

这仍然是一道关于A/B的题，只不过A和B都换成了多项式。你需要计算两个多项式相除的商Q和余R，其中R的阶数必须小于B的阶数。

输入格式：

输入分两行，每行给出一个非零多项式，先给出A，再给出B。每行的格式如下：

N e[1] c[1] ... e[N] c[N]

其中N是该多项式非零项的个数，e[i]是第i个非零项的指数，c[i] 是第i个非零项的系数。各项按照指数递减的顺序给出，保证所有指数是各不相同的非负整数，所有系数是非零整数，所有整数在整型范围内。

输出格式：

分两行先后输出商和余，输出格式与输入格式相同，输出的系数保留小数点后1位。同行数字间以1个空格分隔，行首尾不得有多余空格。注意：零多项式是一个特殊多项式，对应输出为“0 0 0.0”。但非零多项式不能输出零系数（包括舍入后为0.0）的项。在样例中，余多项式其实有常数项“-1/27”，但因其舍入后为0.0，故不输出。

输入样例：

4 4 1 2 -3 1 -1 0 -1
3 2 3 1 -2 0 1

输出样例：

3 2 0.3 1 0.2 0 -1.0
1 1 -3.1

来自wiki百科

多项式长除法[编辑]

维基百科，自由的百科全书

本条目部分链接不符合格式手册规范。跨语言链接及章节标题等处的链接可能需要清理。（2015年12月13日）
请协助改善此条目。参见WP:LINKSTYLE、WP:MOSIW以了解细节。突出显示跨语言链接可以便于检查。

多项式长除法 是代数中的一种算法，用一个同次或低次的多项式去除另一个多项式。是常见算数技巧长除法的一个推广版本。它可以很容易地手算，因为它将一个相对复杂的除法问题分解成更小的一些问题。

例[编辑]

计算

{\frac {x^{3}-12x^{2}-42}{x-3}}.

把被除式、除式按某个字母作降幂排列，并把所缺的项用零补齐，写成以下这种形式：

{\frac {x^{3}-12x^{2}+0x-42}{x-3}}.

然后商和余数可以这样计算：

将分子的第一项除以分母的最高次项（即次数最高的项，此处为x）。结果写在横线之上(x³ ÷ x = x²).

${\begin{matrix}x^{2}\\\qquad \qquad \quad x-3{\overline {)x^{3}-12x^{2}+0x-42}}\end{matrix}}$
将分母乘以刚得到结果（最终商的第一项），乘积写在分子前两项之下（同类项对齐） (x² · (x − 3) = x³ − 3x²).

${\begin{matrix}x^{2}\\\qquad \qquad \quad x-3{\overline {)x^{3}-12x^{2}+0x-42}}\\\qquad \;\;x^{3}-3x^{2}\end{matrix}}$
从分子的相应项中减去刚得到的乘积（消去相等项，把不相等的项结合起来），结果写在下面。((x³ − 12x²) − (x³ − 3x²) = −12x² + 3x² = −9x²)然后，将分子的下一项“拿下来”。

${\begin{matrix}x^{2}\\\qquad \qquad \quad x-3{\overline {)x^{3}-12x^{2}+0x-42}}\\\qquad \;\;{\underline {x^{3}-3x^{2}}}\\\qquad \qquad \qquad \quad \;-9x^{2}+0x\end{matrix}}$
把减得的差当作新的被除式，重复前三步（直到余式为零或余式的次数低于除式的次数时为止．被除式=除式×商式+余式）

${\begin{matrix}\;x^{2}-9x\\\qquad \quad x-3{\overline {)x^{3}-12x^{2}+0x-42}}\\\;\;{\underline {\;\;x^{3}-\;\;3x^{2}}}\\\qquad \qquad \quad \;-9x^{2}+0x\\\qquad \qquad \quad \;{\underline {-9x^{2}+27x}}\\\qquad \qquad \qquad \qquad \qquad -27x-42\end{matrix}}$
重复第四步。这次没什么可以“拿下来”了。

${\begin{matrix}\qquad \quad \;\,x^{2}\;-9x\quad -27\\\qquad \quad x-3{\overline {)x^{3}-12x^{2}+0x-42}}\\\;\;{\underline {\;\;x^{3}-\;\;3x^{2}}}\\\qquad \qquad \quad \;-9x^{2}+0x\\\qquad \qquad \quad \;{\underline {-9x^{2}+27x}}\\\qquad \qquad \qquad \qquad \qquad -27x-42\\\qquad \qquad \qquad \qquad \qquad {\underline {-27x+81}}\\\qquad \qquad \qquad \qquad \qquad \qquad \;\;-123\end{matrix}}$

横线之上的多项式即为商，而剩下的 (−123) 就是余数。

{\frac {x^{3}-12x^{2}-42}{x-3}}=\underbrace {x^{2}-9x-27} _{q(x)}\underbrace {-{\frac {123}{x-3}}} _{r(x)/g(x)}

算数的长除法可以看做以上算法的一个特殊情形，即所有 x 被替换为10的情形。

除法变换[编辑]

使用多项式长除法可以将一个多项式写成除数-商的形式（经常很有用）。考虑多项式 P(x), D(x) （(D)的次数 < (P)的次数）。然后，对某个商多项式 Q(x) 和余数多项式 R(x) （(R)的系数 < (D)的系数），

{\frac {P(x)}{D(x)}}=Q(x)+{\frac {R(x)}{D(x)}}\implies P(x)=D(x)Q(x)+R(x).

这种变换叫做除法变换，是从算数等式 ${\mathrm {dividend} =\mathrm {divisor} \times \mathrm {quotient} +\mathrm {remainder} }$ .^[1] 得到的。

应用[编辑]

多项式的因式分解[编辑]

有时某个多项式的一或多个根已知，可能是使用有理数根定理得到的。如果一个 $n$ 次多项式 $P(x)$ 的一个根 $r$ 已知，那么 $P(x)$ 可以使用多项式长除法因式分解为 $(x-r)Q(x)$ 的形式，其中 $Q(x)$ 是一个 $n-1$ 次的多项式。简单来说， $Q(x)$ 就是长除法的商，而又知 $r$ 是 $P(x)$ 的一个根、余式必定为零。

相似地，如果不止一个根是已知的，比如已知 $r$ 和 $s$ 这两个，那么可以先从 $P(x)$ 中除掉线性因子 $x-r$ 得到 $Q(x)$ ，再从 $Q(x)$ 中除掉 $x-s$ ，以此类推。或者可以一次性地除掉二次因子 $x^{2}-(r+s)x+rs$ 。

使用这种方法，有时超过四次的多项式的所有根都可以求得，虽然这并不总是可能的。例如，如果有理数根定理可以用来求得一个五次方程的一个（比例）根，它就可以被除掉以得到一个四次商式；然后使用四次方程求根的显式公式求得剩余的根。

寻找多项式的切线[编辑]

多项式长除法可以用来在给定点上查找给定多项式的切线方程。^[2] 如果 R(x) 是 P(x)/(x-r)² 的余式——也即，除以 x²-2rx+r²——那么在 x=r 处 P(x) 的切线方程是 y=R(x)，不论 r 是否是 P(x) 的根。

#include <cstdio>
#include <cstring>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int maxn = 1000000;

int lena, lenb, maxa, maxb, cntc, cnta;
double a[maxn + 5], b[maxn + 5], c[maxn + 5];

int main()
{
	maxa = maxb = -1;
	scanf("%d", &lena);
	for (int i = 0; i < lena; i++) {
		int x;
		double y;
		scanf("%d%lf", &x, &y);
		a[x] = y;
		maxa = max(maxa, x);
	}
	scanf("%d", &lenb);
	for (int i = 0; i < lenb; i++) {
		int x;
		double y;
		scanf("%d%lf", &x, &y);
		b[x] = y;
		maxb = max(maxb, x);
	}
	for (int i = maxa; i >= maxb; i--) {
		c[i - maxb] = a[i] / b[maxb];
		for (int j = maxb; j >= 0; j--) {
			a[j + i - maxb] -= b[j] * c[i - maxb];
		}
	}

	cntc = 0;
	for (int i = maxa - maxb; i >= 0; i--) {
		if (fabs(c[i]) < 1e-8) {
			continue;
		}
		else {
			if (fabs(c[i]) < 0.05) {
				c[i] = 0.0;
			}
			else {
				cntc++;
			}
		}
	}
	cnta = 0;
	for (int i = maxb; i >= 0; i--) {
		if (fabs(a[i]) < 1e-8) {
			continue;
		}
		else {
			if (fabs(a[i]) < 0.05) {
				a[i] = 0.0;
			}
			else {
				cnta++;
			}
		}
	}
	if (cntc == 0) {
		puts("0 0 0.0");
	}
	else {
		printf("%d", cntc);
		for (int i = maxa - maxb; i >= 0; i--) {
			if (fabs(c[i]) < 1e-8) {
				continue;
			}
			else {
				printf(" %d %.1f", i, c[i]);
			}
		}
		puts("");
	}
	if (cnta == 0) {
		puts("0 0 0.0");
	}
	else {
		printf("%d", cnta);
		for (int i = maxb - 1; i >= 0; i--) {
			if (fabs(a[i]) < 1e-8) {
				continue;
			}
			else {
				printf(" %d %.1f", i, a[i]);
			}
		}
		puts("");
	}
	return 0;
}

简单代码重构后

#include <cstdio>
#include <cstring>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int maxn = 1000000;

int x, lena, lenb, maxa, maxb, cntc, cnta;
double y, a[maxn + 5], b[maxn + 5], c[maxn + 5];

void input(int len, double *arr, int *maxx) {
	for (int i = 0; i < len; i++) {
		scanf("%d%lf", &x, &y);
		arr[x] = y;
		*maxx = max(*maxx, x);
	}
}

void clearzero(int &cnt, int be, double *arr) {
	cnt = 0;
	for (int i = be; i >= 0; i--) {
		if (!(fabs(arr[i]) < 1e-8)) {
			fabs(arr[i]) < 0.05 ? arr[i] = 0.0 : cnt++;
		}
	}
}

void output(int cnt, int be, double *arr) {
	if (cnt == 0) {
		puts("0 0 0.0");
	}
	else {
		printf("%d", cnt);
		for (int i = be; i >= 0; i--) {
			if (!(fabs(arr[i]) < 1e-8)) {
				printf(" %d %.1f", i, arr[i]);
			}
		}
		puts("");
	}
}

int main()
{
	maxa = maxb = -1;

	scanf("%d", &lena);
	input(lena, a, &maxa);

	scanf("%d", &lenb);
	input(lenb, b, &maxb);

	for (int i = maxa; i >= maxb; i--) {
		c[i - maxb] = a[i] / b[maxb];
		for (int j = maxb; j >= 0; j--) {
			a[j + i - maxb] -= b[j] * c[i - maxb];
		}
	}

	clearzero(cntc, maxa - maxb, c);
	clearzero(cnta, maxb, a);

	output(cntc, maxa - maxb, c);
	output(cnta, maxb - 1, a);

	return 0;
}