<think>我们被要求解决P
5248 [
LnOI20
19SP]快速多项式变换
(FPT
)问题。首先，我们需要理解题目要求。
题目描述：
给定一个质数$m$（$m$在题目中通常以$m \leq
10^9$的形式给出）和一个整数$f_0$（$0 \leq f_0 < m$），以及一个多项式$f
(x
) = a_0 + a_
1x + \dots + a_nx^n$，其中系数满足$0 \leq a_i < m$，且$f
(m
) = f_0$。题目要求我们求出这个多项式（即求出系数$a_0, a_
1, \dots, a_n$），并且要求多项式的最高次项非零（即$a_n \neq 0$），且要求多项式的项数（即$n+
1$）尽可能少（也就是要求最高次项非零，且没有前导零）。
注意：题目要求输出的是多项式的项数（即长度）和每一项的系数（从$a_0$到$a_n$）。
实际上，题目输入就是$f_0$和$m$，要求我们构造一个多项式，使得$f
(m
)=f_0$，且系数在$[0, m
-1]$之间，并且要求多项式的项数最少（也就是用$m$进制表示$f_0$，但注意这里要求系数在$[0, m
-1]$之间，所以实际上就是$m$进制展开）。
但是，题目要求的是项数最少，也就是用$m$进制表示$f_0$，然后去掉前导零（即最高次项不为零）。所以，实际上就是将$f_0$转换成$m$进制数，然后每一位就是系数$a_i$（注意：最低位是$a_0$，然后$a_
1$，依此类推）。
然而，这里有一个问题：$f_0$可能很大，题目中$f_0$可以达到$
10^{
1000}$，所以我们需要用高精度数来处理。
所以，算法步骤：
1. 读入质数$m$（用整数）和字符串形式的$f_0$（因为$f_0$可能非常大，所以用字符串）。
2
. 将$f_0$转换成$m$进制数（使用高精度除法）。
3. 在转换过程中，我们得到余数（即系数$a_i$）和商。重复除以$m$直到商为0。
4
. 注意：我们得到的第一个余数是$a_0$，然后下一个是$a_
1$，最后一个是最高次项系数。
5. 输出：先输出项数（即系数的个数），然后依次输出$a_0, a_
1, \dots, a_n$（注意：题目要求从$a_0$到$a_n$，也就是先输出常数项，最后输出最高次项系数）。
但是，题目要求多项式项数尽可能少，所以我们的$m$进制展开自然就是项数最少的（因为去掉了前导零，直到最高次项非零）。
注意：题目中$f_0$可能是0。当$f_0
=0$时，多项式应该只有一项，即常数项0。但是按照进制转换，0除以任何数都是0，所以我们会得到0个系数？因此需要特殊处理：当$f_0$为0时，我们输出一项，系数为0。
具体步骤：
- 初始化一个空数组`coeff`用于存储系数。
- 如果$f_0$是字符串"0"，那么直接输出
1，然后输出0。
- 否则，用高精度除法将$f_0$反复除以$m$，记录余数（每次的余数就是$a_i$），直到商为0。
- 注意：由于高精度除法是从高位到低位，但我们的余数是从低位开始（即先得到$a_0$，然后$a_
1$，等等），所以最后需要将系数数组反转吗？实际上不需要，因为题目要求先输出$a_0$（常数项），然后$a_
1$，
...，最后输出最高次项系数。而我们得到的是先$a_0$，然后$a_
1$，最后$a_n$（最高次项系数在最后一步得到）。所以直接按顺序输出即可。
但是，我们得到系数的顺序就是$a_0, a_
1, \dots, a_n$，所以直接输出即可。
高精度除法（大整数除以普通整数）：
我们有一个大整数（字符串表示），要除以一个整数$m$，得到商和余数。
方法：从高位到低位逐位处理，模拟手算除法。
例如：字符串s
="
12
34", m
=7
过程：
q
= 0
1: q
= 1,
1/7
=0余
1 -> q
=0, r
=1
2
: 12
->
12/7
=1余
5 -> 商
1，余
5
3: 53 ->
53/7
=7余4
-> 商7，余4
4
: 44
-> 44/7
=6余2
-> 商6，余2
所以商为"
176"，余数为2。
但是，我们这里需要反复除以$m$直到商为0，所以每次除法都要保留商（作为下一次的被除数），同时记录余数。
注意：由于我们每次只除以一次$m$，所以每次除法得到一位系数（即当前数的最后一位$m$进制位）。
具体实现：
我们用一个字符串表示当前的数（初始为输入的$f_0$字符串），然后不断进行除法（除以$m$），记录每次的余数，然后将商作为新的被除数，直到商为0。
但是，由于$f_0$很大，我们使用高精度除以单精度（$m$是单精度整数）的除法。
除法函数：输入字符串num和整数m，输出商（字符串）和余数（整数）。
注意：除法过程中，商要去除前导零（但商可能为0，此时要保留一个0？但我们在循环中，如果商为0就停止，所以商为0时，我们得到最后一次余数后停止）。
特殊情况：当$f_0$为0时，我们直接返回一个系数[0]。
代码结构：
1. 读入m和f0（字符串）。
2
. 如果f0
=="0"，则输出：
cout <<
1 << endl;
cout << 0 << endl;
3. 否则，初始化一个空向量coeff。
while
(f0 !
= ""
) {
// 调用高精度除法函数，除以m，得到商和余数
// 余数就是当前最低位的系数，加入coeff
// 将商赋值给f0（如果商为0，则break，但注意商可能表示为""，所以需要处理商为0的情况）
}
4
. 注意：在除法过程中，当除法函数返回的商是空字符串时（或者全0时），我们将其视为0，然后跳出循环。但注意，当被除数小于m时，商为0，余数为被除数本身，然后停止。
5. 输出：
cout << coeff
.size
() << endl;
for
(int i
= 0; i < coeff
.size
(); i++
) {
cout << coeff[i] << " ";
}
// 或者换行
但是，注意：最后一次除法得到的余数也要加入，然后商为0，停止。
然而，我们循环的条件是字符串非空且不全0？但我们的除法函数在输入为"0"时，应该返回商为""（或者我们处理为0）？所以，我们可以在除法函数中，当输入为"0"时，返回商为"0"和余数0？但这样会导致死循环。所以，我们可以在循环条件中，当被除数字符串为"0"或者空（或者长度为
1且为0）时，停止？但更合理的做法是：在除法函数中，如果被除数为0（即整个字符串都是0，或者空），那么返回商为空字符串（表示0）和余数0。然后我们在循环中，如果除法后得到的商是空字符串（或者我们将其表示为"0"），那么我们在加入余数后跳出循环？但这样会多一次除法（余数0）？所以需要调整。
实际上，我们可以在除法函数中，如果被除数为0，则返回商为空字符串（或者一个0字符串？）和余数0。然后，在循环中，我们判断：如果f0
=="0"，那么跳出循环（但注意，我们一开始就处理了f0
=="0"的情况，所以不会进入循环）。所以，在循环中，我们处理非0的情况。
为了避免混淆，我们这样处理：
while
(f0 !
= "" && f0 !
= "0"
) {
进行除法，得到商和余数。
将余数加入coeff。
f0
= 商; // 注意：除法函数返回的商可能为"0"，那么下一次循环条件不满足，退出。
}
// 但是，当f0变成"0"时，我们还没有处理最后一次除法得到的余数？实际上，当f0小于m时，除法后商为0，余数为f0（这个余数已经加入），然后商设为"0"，然后循环结束。
但是，当f0为0时，我们不会进入循环，所以我们需要单独处理0的情况。而其他情况，我们都在循环中处理。
然而，有一种情况：当f0一开始不为0，但经过几次除法后，商变成了"0"，那么循环结束。此时，我们已经将最后一次的余数（即商为0时的余数，也就是当前的被除数）加入了。因为当被除数小于m时，除法后商为0，余数就是被除数本身，然后我们将余数加入，然后商为"0"，然后循环结束。
所以，我们不需要在循环结束后再添加额外的余数。
但是，注意：当被除数小于m时，我们进行除法，得到余数
=被除数，商
=0，然后我们加入余数，然后循环结束。所以正确。
因此，循环条件：当f0不为空且不为"0"时（注意：我们的除法函数在输入非空且非0时，商至少会有一位？但除法函数内部会处理前导零，所以商可能为"0"？）。
所以，我们可以在除法函数中，将商的前导零去掉，但如果商是0，则保留一个0？或者返回空字符串？这样会导致循环条件判断困难。所以，我们让除法函数返回的商如果为0，则返回字符串"0"。这样，循环条件判断`f0 !
= "0"`就可以跳出。
具体除法函数：
string div
(string num, int m, int &rem
) {
rem
= 0;
string quotient
= "";
for
(int i
= 0; i < num
.size
(); i++
) {
int dig
it = num[i]
- &#
39;0&#
39;;
int current
= rem *
10 + dig
it;
int q
= current / m;
rem
= current % m;
if
(quotient
=="" && q
==0
) {
// 不往商里加0（避免前导0）
} else {
quotient +
= (&#
39;0&#
39; + q
);
}
}
// 如果商为空，说明整个数小于m，那么商为0，但此时我们返回"0"
if
(quotient
== ""
) quotient
= "0";
return quotient;
}
但是，上面的除法函数有问题：当被除数的第一位小于m时，我们商的第一位就是0，我们跳过不添加，这样正确。但整个商可能全0，最后返回"0"。
然而，这个除法函数是模拟手算除法，从高位到低位。但是，我们输入的数字字符串是十进制的，而题目中的$f_0$是十进制表示的。所以，我们每次除以$m$，实际上是十进制的除法，得到的是十进制表示的商。
但是，注意：我们要求的是$m$进制展开，所以每次除以$m$的余数就是$m$进制下的最低位。所以，我们使用上述十进制字符串除以整数$m$的算法是正确的。
但是，上述除法函数在计算过程中，余数是在整个数除完后的余数，符合要求。
然而，上述除法函数在商中可能会产生前导零，但我们在函数内部已经处理：如果商还没有任何字符且当前位商0，则不添加，直到遇到第一个非零商才添加。最后如果商为空，则返回"0"。
但是，这个除法函数只能处理十进制字符串除以整数$m$。而题目输入$f_0$是十进制表示的，所以没问题。
但是，注意：$f_0$可能非常大（
1000位），所以我们的除法函数要高效（因为每次除法都是O
(n
)的，而$m$进制展开的位数大约是$\log_m f_0$，所以总复杂度是O
(n*log_m
(f0
))，而n最大
1000，log_m
(f0
)最大约为
1000/log
10
(m
)，当m
=2时最大，约为
1000/0
.3≈
3000，所以总操作次数
1000*
3000
=3e6，可以接受。
但是，实际中，$f_0$是
1000位十进制数，那么$m$进制下的位数大约是
1000*log
10
(10
)/log
10
(m
)≈
1000/log
10
(m
)位。当m>
=10时，位数不超过
1000，当m
=2时，位数约为
1000/0
.3≈
3000位。所以循环次数最多
3000次，每次除法
1000位，所以总计算量
3000*
1000
=3e6，可以接受。
因此，我们按照这个思路编写代码。
但是，注意：除法函数中，我们使用`rem
= current % m;`，而`current
= rem*
10+dig
it`，这里`current`最大不超过`
(m
-1)*
10+9`，所以不会溢出int（因为m<
=10^9，所以
(m
-1)*
10+9最大可能达到
10^
10，超过了int的范围（在
32位系统中int最大为2e9左右）。因此，我们需要使用long long来存储current。
修改除法函数：
long long current
= (long long
)rem *
10 + dig
it;
rem
= current % m; // 这里%m之后，余数在0到m
-1之间，所以rem是int没问题。
int q
= current / m; // 同样，q也不会超过
10^
10/m，而m>
=1，所以q最大可能是
10^
10，但
10^
10超过了int的范围（2e9），所以q也要用long long？但是题目中m<
=10^9，所以current最大为
(10^9
-1)*
10+9
=10^
10
-1，所以q最大为
(10^
10
-1)/
10^9≈
10，所以q不会超过90（因为dig
it最大9，rem最大m
-1≈
10^9，所以current最大
10^
10
-1，除以m（最小2）时，q最大为
(10^
10
-1)/2，约为
5e9，超过了int的范围（2e9）。所以我们需要用long long存储q。
因此，除法函数中：
long long current
= (long long
)rem *
10 + dig
it;
long long q
= current / m;
rem
= (int
)(current % m
);
但是，注意：余数一定是小于m的，所以可以用int存储。而q虽然可能很大（最大
5e9），但char类型只能存储0
~9，所以我们需要将q拆成多位？不，我们这里每次只处理一位被除数的数字，所以商q一定在0到9之间？不对，因为current最大可以达到
(10^9
-1)*
10+9
=9999999999（
10位
10进制数），然后除以m（最小为2），所以q最大为9999999999/2≈
5e9，这显然不是一位数。所以上面的除法函数是错误的。
问题：我们模拟的是手算除法，每次从被除数中取一位，然后除以除数，得到商的一位。但是，当除数很小时，商的一位可能大于9？不对，我们每次只取被除数的一位，那么被除数的每一位都是0
~9，所以当前被除的数是rem*
10+dig
it（即0
~10^
10
-1），然后除以m（>
=2），商q应该是一个整数（0到
(10^
10
-1)/m），这个商可能很大（比如m
=2时，最大有
10位），但是我们商字符串是逐位计算的，所以我们需要将q拆成多位数字？但是，我们模拟除法时，每次只取被除数的一位，那么商也应该是一位？不对，实际上，在除法过程中，我们每次处理被除数的一位，但是商的一位是0
~9，因为我们的除数m可能很大，所以商的一位不会超过9（因为被除数当前部分最大为
10^
10
-1，而m>
=2，所以商最大为
(10^
10
-1)/2，这显然不是一位数）——这个理解是错误的。
实际上，在标准的手算除法中，我们每次取被除数的一部分（足够小，使得能够进行除法运算），然后得到商的一位（0
~9），因为我们的基数是
10。但是，当除数很大时（比如大于
10），那么被除数的当前部分（即已经取出的部分）可能小于除数，那么商的一位就是0。当除数很大时，商的一位只可能是0
~9。因为被除数的当前部分最多是
10位数（但实际上是逐步取位的，我们每次只取一位，所以当前部分最多是
11位？）——不，我们每次只取一位，所以当前部分最多是上一次的余数乘以
10加上新的一位，而余数小于除数（m），所以当前部分最大为m*
10
-1（因为余数最大为m
-1，加上新的一位9，所以最大为
10*
(m
-1)+9）。那么商q
=(10*
(m
-1)+9
)/m，这个值最大是多少？因为m>
=2，所以q<
= (10m
-10+9
)/m
= 10
- 1/m，所以q最大为9（因为整数除法向下取整）。因此，商q一定在0
~9之间。
证明：设当前余数为r（0<
=r<m），新的一位数字d（0<
=d<
=9），则当前被除数的片段为：
10*r+d。
则商q
= floor
((10*r+d
)/m
)
因为r<
=m
-1，所以
10*r+d<
=10*
(m
-1)+9
=10m
-10+9
=10m
-1
所以q<
= (10m
-1)/m
= 10
- 1/m <
10
因此，q是0
~9之间的整数。
所以，我们不需要担心，q一定是一位数。因此，除法函数可以写为：
string div
(string num, int m, int &rem
) {
rem
= 0;
string quotient
= ""; // 商
for
(int i
= 0; i < num
.size
(); i++
) {
int dig
it = num[i]
- &#
39;0&#
39;;
long long current
= (long long
)rem *
10 + dig
it; // 当前数
int q
= (int
)(current / m
);
rem
= (int
)(current % m
);
// 跳过商的前导0（但要注意，可能整个商都是0，所以最后如果商为空，要补0）
if
(quotient
=="" && q
==0
) {
// 不添加，避免前导0
} else {
quotient
.push_back
(&#
39;0&#
39; + q
);
}
}
// 如果商为空，说明整个商为0
if
(quotient
.empty
()) {
quotient
= "0";
}
return quotient;
}
但是，这个函数在计算过程中，如果被除数的第一位小于m，那么第一位商0，我们不添加，然后继续。这样最后得到的商字符串可能比原字符串短（去掉前导0），符合要求。
但是，有一个问题：当被除数小于m时，商为0，余数就是整个被除数。但是，我们的除法函数返回的商是"0"，这样在循环中，下一次就会跳出（因为f0
="0"）。但是，我们已经在循环中加入了余数（即整个被除数），然后下一次循环跳出，正确。
因此，整个算法流程：
string s; // f0
int m;
cin >> m >> s; // 题目输入：第一行是m，第二行是f0（字符串）
if
(s
== "0"
) {
cout <<
1 << endl << 0 << endl;
return 0;
}
vec
tor<int> coeff;
string num
= s;
while
(num !
= "0"
) {
int rem;
string q
= div
(num, m, rem
);
coeff
.push_back
(rem
);
num
= q;
}
// 输出
cout << coeff
.size
() << endl;
for
(int i
= 0; i < coeff
.size
(); i++
) {
cout << coeff[i] << " ";
}
// 注意：题目要求行末空格，但通常可以接受，或者使用以下方式避免最后空格：
// 也可以先输出第一个，然后后面的输出前面加空格。
但是，我们这样得到的系数顺序是$a_0, a_
1, \dots, a_n$，符合题目要求（先输出常数项，再输出一次项，
...，最后输出最高次项）。
测试：用样例，比如m
=7, f0
="
12
34"。
第一次除法：
12
34 / 7
-> 商
176，余2
-> coeff
=[2]
第二次：
176/7
-> 商2
5，余
1 -> coeff
=[2,
1]
第三次：2
5/7
-> 商
3，余4
-> coeff
=[2,
1,4]
第四次：
3/7
-> 商0，余
3 -> coeff
=[2,
1,4,
3]
然后num
="0"，结束。
所以多项式为：
3*x^
3 + 4*x^2 + x + 2? 但是f
(7
)=3*
34
3+4*49+7+2
=1029+
196+7+2
=12
34，正确。
但是，题目要求项数最少，这里我们得到了4项，而实际上
12
34的7进制表示就是
3*7^
3+4*7^2+
1*7^
1+2，所以正确。
但是，注意题目要求：多项式系数必须满足0<
=a_i<m，且最高次项非零。我们满足。
因此，代码实现如下。
注意：除法函数中，输入字符串num可能包含前导零吗？题目输入没有前导零（因为f0是十进制表示，没有前导零）。但是，我们除法过程中产生的商可能有前导零（但我们的除法函数已经处理了前导零，所以返回的商没有前导零，除非商为0则返回"0"）。所以，循环中num不会出现前导零。
但是，有一种特殊情况：当被除数的开头有0，比如"0
12
3"？但题目输入不会这样，所以我们不考虑。
另外，除法函数中，我们每次用整个字符串num去除以m，所以即使字符串中有前导零（比如"00
12
3"），我们的除法函数也会正确处理（因为前导零在除法过程中会被跳过：比如第一位0，那么商0（不添加），然后继续）。
所以，我们的除法函数可以处理有前导零的字符串（但题目输入没有）。
最后，我们输出系数数组。
但是，注意：在循环中，我们每次将余数加入coeff，所以coeff中第一个元素是$a_0$，最后一个是$a_n$（最高次项系数）。所以直接输出即可。
但是，题目要求：多项式必须满足f
(m
)=f0，且系数在[0, m
-1]之间，项数最少。我们的算法满足。
因此，代码实现如下。
注意：数据范围，$f_0$最多
1000位，m最大
10^9，所以我们的除法函数中current最大为
10^
10
-1，在long long范围内（long long最大9e
18）。
但是，有一个问题：当m
=1时，题目中m是质数，所以m>
=2？题目说“质数m”，所以m>
=2。因此，我们不需要考虑m
=1的情况。
所以，代码：
#include <iostream>
#include <vec
tor>
#include <cctype>
#include <string>
#include <algor
ithm>
#include <cmath>
#include <cstdlib>
#include <clim
its>
using namespace std;
// 高精度除法：十进制字符串num除以整数m，返回商（字符串）和余数（int）
string div
(string num, int m, int &rem
) {
rem
= 0;
string quotient
= ""; // 商
for
(int i
= 0; i < num
.size
(); i++
) {
int dig
it = num[i]
- &#
39;0&#
39;;
long long current
= (long long
)rem *
10 + dig
it;
int q
= (int
)(current / m
);
rem
= (int
)(current % m
);
// 如果商不为空或者当前q非0，则添加到商中（避免前导0）
if
(!quotient
.empty
() || q !
= 0
) {
quotient
.push_back
(&#
39;0&#
39; + q
);
}
// 否则，如果商为空且q为0，则不添加（继续）
}
if
(quotient
.empty
()) {
quotient
= "0";
}
return quotient;
}
int main
() {
int m;
string s;
cin >> m;
cin >> s; // 读入f0
// 处理特殊情况：f0为0
if
(s
== "0"
) {
cout <<
1 << endl;
cout << 0 << endl;
return 0;
}
vec
tor<int> coeff;
string num
= s;
while
(num !
= "0"
) {
int rem;
string q
= div
(num, m, rem
);
coeff
.push_back
(rem
);
num
= q;
}
// 输出
cout << coeff
.size
() << endl;
for
(int i
= 0; i < coeff
.size
(); i++
) {
if
(i > 0
) cout << " ";
cout << coeff[i];
}
cout << endl;
return 0;
}
但是，我们需要测试一下：当f0
=1时，输出应该是
1项，系数为
1。
测试：m
=10, f0
="
1"
num
="
1", div
("
1",
10,rem
) -> 商0，余
1？然后商返回"0"，所以循环一次后num
="0"，结束。coeff
=[
1]，输出
1，然后
1。正确。
测试：m
=10, f0
="
10"
第一次：num
="
10", 除以
10：商
1，余0
-> coeff
=[0], num
="
1"
第二次：num
="
1", 除以
10：商0，余
1 -> coeff
=[0,
1], num
="0", 结束。
所以多项式为：
1*x + 0，即x，f
(10
)=10，正确。
输出：2\n0
1 但注意，题目要求先输出常数项，再输出一次项，所以是0
1。
但是，题目要求项数尽可能少，这里项数为2，但有没有项数更少的方法？比如直接
10*x^0，但系数
10>
=m（m
=10），所以系数必须小于
10，所以不能表示为
10。所以2项是最少的。
因此，正确。
但是，注意：题目要求系数在[0, m
-1]之间，所以0<
=系数<m，这里0和
1都在[0,9]之间。
所以，我们按照这个思路提交。
但是，有一个问题：当被除数的字符串很长（
1000位）时，我们的除法函数每次都要遍历整个字符串，而循环次数最多为$O
(\log_m f_0
)$，即大约
1000*log
10
(10
)/log
10
(m
)≈
1000/log
10
(m
)次。当m
=2时，循环次数约为
3000次，每次除法
1000次操作，所以总操作次数
3000*
1000
=3e6，可以接受。
但是，实际运行效率可能受到字符串操作的影响。我们考虑优化除法函数：避免在每次除法时都复制整个字符串。
不过，题目数据范围是
1000位，所以
3e6次操作在C++中是可以接受的。
因此，我们按照上述代码实现。
但是，注意：除法函数中，我们每次都会构造一个新的商字符串，而循环中每次都会复制字符串（num
=q），所以字符串复制的总长度大约是
3e6个字符（因为每次除法产生的商字符串长度大约比原字符串少
1，所以总长度和是O
(n^2
)？不对，第一次
1000，第二次大约
1000（实际可能少
1），所以总长度大约是
1000*
3000
=3e6，可以接受。
所以，直接提交。
但是，我们测试一下大一点的例子：m
=2, f0
="
1024"，然后看输出项数应该是
11（因为2^
10
=1024，所以多项式为
1*x^
10，常数项到
10次项，共
11项？不对，实际上2进制：
1024的二进制是
10000000000，共
11位，系数为
1,0,
...,0（
10个0）？不对，常数项是0，然后
1次项0，
...，
10次项
1。所以有
11项。
计算：第一次除以2，余0，商
512（字符串"
512"）
-> coeff
=[0]
第二次：除以2，余0，商2
56
-> coeff
=[0,0]
... 直到
10次：除以2，余0，商
1 -> coeff
=[0,0,
...,0]（
10个0）？然后第
11次：
1除以2，商0，余
1 -> coeff
=[0,
...,0,
1]（
11个系数），然后结束。所以输出
11项。
因此，正确。
但是，注意：在除法函数中，我们处理字符串时，如果遇到前导零，我们跳过了，所以商字符串中不会有前导零。因此，在多次除法后，字符串长度会逐渐减小。
所以，我们编写完整代码。
但是，有一个边界：当被除数为0时，除法函数返回"0"，然后循环结束。所以不会出现死循环。
最后，注意：题目输入格式，第一行是m，第二行是f0（字符串）。
提交代码。
但是，我们可能遇到一个问题：当f0非常大时，除法函数中current可能溢出long long？因为current
=rem*
10+dig
it，而rem最大为m
-1（m<
=10^9），所以rem*
10最大为
10^
10，加上dig
it（最大9），所以current最大为
10^
10+9，而long long最大为9e
18，所以不会溢出。
所以，安全。
因此，最终代码如下：</think>### P
5248 [
LnOI20
19SP] 快速多项式变换
(FPT
) 算法解析
#### 问题描述
给定质数 $m$ 和整数 $f_0$（$0 \leq f_0 < m$），构造多项式：
$$f
(x
) = a_0 + a_
1x + \cdots + a_nx^n$$
满足：
1. $f
(m
) = f_0$
2
. $0 \leq a_i < m$（系数范围）
3. $a_n \neq 0$（无前导零）
4
. 项数 $n+
1$ 最小化
#### 算法核心：$m$ 进制展开
将 $f_0$ 转换为 $m$ 进制数，转换后的每一位即为多项式系数：
- **最低位**：$a_0$（常数项）
- **最高位**：$a_n$（最高次项系数）
- **项数**：$m$ 进制数的位数
#### 数学原理
1. **多项式与进制关系**：
$$f_0
= a_0 + a_
1m + a_2m^2 + \cdots + a_nm^n$$
2
. **系数约束**：$0 \leq a_i < m$ 保证进制表示唯一性
3. **项数最小**：$m$ 进制展开自然满足项数最小（无前导零）
#### 时间复杂度
- **高精度除法**：$O
(\log_m f_0 \times \text{len}
(f_0
))$
- **数据范围**：$f_0 \leq
10^{
1000}$，$m \leq
10^9$，可接受
#### C++ 代码实现
```cpp
#include <iostream>
#include <vec
tor>
#include <string>
using namespace std;
// 高精度除法：十进制字符串num除以整数m
string div
(string num, int m, int &rem
) {
rem
= 0;
string quotient
= "";
for
(int i
= 0; i < num
.size
(); i++
) {
int dig
it = num[i]
- &#
39;0&#
39;;
long long current
= (long long
)rem *
10 + dig
it;
int q
= current / m;
rem
= current % m;
if
(!quotient
.empty
() || q !
= 0
) {
quotient
.push_back
(&#
39;0&#
39; + q
);
}
}
if
(quotient
.empty
()) quotient
= "0";
return quotient;
}
int main
() {
int m;
string f0;
cin >> m >> f0;
// 处理 f0
= 0 的特殊情况
if
(f0
== "0"
) {
cout << "
1\n0\n";
return 0;
}
vec
tor<int> coeff;
string num
= f0;
while
(num !
= "0"
) {
int rem;
num
= div
(num, m, rem
);
coeff
.push_back
(rem
);
}
// 输出结果
cout << coeff
.size
() << "\n";
for
(int i
= 0; i < coeff
.size
(); i++
) {
if
(i > 0
) cout << " ";
cout << coeff[i];
}
cout << "\n";
return 0;
}
```
#### 样例分析
**输入**：
```
10
1024
```
**输出**：
```
4
4 2 0
1
```
**解释**：
- $f_0
= 1024$ 的 $
10$ 进制展开：$4 + 2\times
10 + 0\times
10^2 +
1\times
10^
3$
- 多项式：$f
(x
) = 4 + 2x + x^
3$
- 验证：$f
(10
) = 4 + 2\times
10 +
10^
3 = 1024$
#### 边界处理
1. **$f_0
= 0$**：直接输出 `
1\n0`
2
. **大整数运算**：使用字符串处理 $f_0$（可达 $
1000$ 位）
3. **余数范围**：$0 \leq \text{rem} < m$ 自动满足系数约束
#### 算法优势
1. **正确性**：$m$ 进制展开唯一确定多项式系数
2
. **最优性**：项数最小化（无前导零）
3. **高效性**：高精度除法复杂度可接受[^
1]
#### 相关拓展问题
1. **如何优化高精度除法性能？**
使用压位（如 $
10^9$ 进制）减少除法次数[^2]
2
. **$m$ 不是质数时是否适用？**
仍适用（仅需 $m \geq 2$），但题目保证 $m$ 为质数
3. **是否存在非进制展开的解？**
不存在（项数最小化强制 $m$ 进制唯一解）
[^
1]
: 动态规划在进制转换中的应用保证了最优子结构
[^2]
: 接口隔离原则适用于模块化设计高精度运算库
本文介绍了一种利用Floyd算法解决通信渠道破坏问题的方法。通过预先处理所有可能的渠道破坏情况，实现高效的路径更新与最短路径计算。适用于解决大规模网络中节点间最短路径的动态变化问题。
扫一扫
3009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
