先 说 一 下 自 己 的 歪 解 ( 找 规 律 ) \color{Red}{先说一下自己的歪解(找规律)} 先说一下自己的歪解(找规律)
n = 1 是 答 案 是 10 n=1是答案是10 n=1是答案是10
n = 2 时 答 案 是 180 n=2时答案是180 n=2时答案是180
n = 3 时 模 拟 一 下 , 很 容 易 发 现 答 案 是 2610 180 10 n=3时模拟一下,很容易发现答案是2610\ \ 180\ \ 10 n=3时模拟一下,很容易发现答案是2610 180 10
然 后 我 们 大 胆 推 测 , n 增 加 后 , 只 有 答 案 第 一 位 发 生 变 化 , 其 余 照 搬 n − 1 的 答 案 然后我们大胆推测,n增加后,只有答案第一位发生变化,其余照搬n-1的答案 然后我们大胆推测,n增加后,只有答案第一位发生变化,其余照搬n−1的答案
然 后 发 现 n = 3 有 1000 个 三 位 数 , 每 个 数 有 3 个 数 字 加 起 来 是 1000 ∗ 3 个 数 字 然后发现n=3有1000个三位数,每个数有3个数字加起来是1000*3个数字 然后发现n=3有1000个三位数,每个数有3个数字加起来是1000∗3个数字
刚 才 得 出 n = 3 时 连 续 块 长 3 有 10 种 ( 0000 , 1111 , . . . , 9999 ) , 也 就 用 掉 了 10 ∗ 3 个 数 字 刚才得出n=3时连续块长3有10种(0000,1111,...,9999),也就用掉了10*3个数字 刚才得出n=3时连续块长3有10种(0000,1111,...,9999),也就用掉了10∗3个数字
n = 3 时 连 续 块 长 2 有 180 种 , 也 就 用 掉 了 180 ∗ 2 个 数 字 n=3时连续块长2有180种,也就用掉了180*2个数字 n=3时连续块长2有180种,也就用掉了180∗2个数字
所 以 易 得 连 续 块 长 1 有 3000 − 30 − 360 = 2610 所以易得连续块长1有3000-30-360=2610 所以易得连续块长1有3000−30−360=2610
于 是 我 们 可 以 开 始 递 推 。 于是我们可以开始递推。 于是我们可以开始递推。
递 推 方 法 是 : 当 前 总 数 字 − 当 前 所 用 数 字 = 块 长 1 的 数 字 递推方法是:当前总数字-当前所用数字=块长1的数字 递推方法是:当前总数字−当前所用数字=块长1的数字
要代码点我
− − − − − − − − − − − − − − − − − − − − 无 敌 的 分 割 线 ( ● ˇ ∀ ˇ ● ) − − − − − − − − − − − − − − − − − − − − − − − − − − \color{Green}{--------------------无敌的分割线(●ˇ∀ˇ●)--------------------------} −−−−−−−−−−−−−−−−−−−−无敌的分割线(●ˇ∀ˇ●)−−−−−−−−−−−−−−−−−−−−−−−−−−
还 有 一 种 解 法 是 组 合 数 学 的 思 想 \color{Purple}{还有一种解法是组合数学的思想} 还有一种解法是组合数学的思想
如 当 n = 10 我 们 怎 么 构 造 一 个 长 度 为 L = 3 的 块 的 数 量 呢 ? 如当n=10我们怎么构造一个长度为L=3的块的数量呢? 如当n=10我们怎么构造一个长度为L=3的块的数量呢?
实 际 上 这 个 长 度 为 3 的 连 续 串 可 以 从 ( 10 − 3 + 1 ) 个 位 置 开 头 , 分 别 是 1 、 2 、 3...7 、 8 实际上这个长度为3的连续串可以从(10-3+1)个位置开头,分别是1、2、3...7、8 实际上这个长度为3的连续串可以从(10−3+1)个位置开头,分别是1、2、3...7、8
如 果 从 1 和 8 开 头 , 只 需 要 相 邻 的 一 个 元 素 和 串 不 同 其 他 随 意 , 方 案 数 是 如果从1和8开头,只需要相邻的一个元素和串不同其他随意,方案数是 如果从1和8开头,只需要相邻的一个元素和串不同其他随意,方案数是
10 ( 块 可 以 是 000 , 111 等 10 种 ) ∗ 9 ( 相 邻 元 素 有 9 种 选 法 ) ∗ 1 0 n − L − 1 ( 剩 下 n − L − 1 元 素 每 个 10 种 选 法 ) 10(块可以是000,111等10种)*9(相邻元素有9种选法)*10^{n-L-1}(剩下n-L-1元素每个10种选法) 10(块可以是000,111等10种)∗9(相邻元素有9种选法)∗10n−L−1(剩下n−L−1元素每个10种选法)
如 果 从 2 到 7 开 头 , 那 么 需 要 相 邻 两 个 元 素 不 同 , 方 案 数 是 如果从2到7开头,那么需要相邻两个元素不同,方案数是 如果从2到7开头,那么需要相邻两个元素不同,方案数是
10 ( 块 可 以 是 000 , 111 等 10 种 ) ∗ 9 ∗ 9 ∗ ( 相 邻 元 素 有 9 种 选 法 ) ∗ 1 0 n − L − 2 ( 剩 下 n − L − 2 元 素 每 个 10 种 选 法 ) 10(块可以是000,111等10种)*9*9*(相邻元素有9种选法)*10^{n-L-2}(剩下n-L-2元素每个10种选法) 10(块可以是000,111等10种)∗9∗9∗(相邻元素有9种选法)∗10n−L−2(剩下n−L−2元素每个10种选法)
下面引用博主EchoZQN的一段话
这 个 会 不 会 出 现 重 复 呢 ? 或 者 会 不 会 少 统 计 了 呢 ? 这个会不会出现重复呢?或者会不会少统计了呢? 这个会不会出现重复呢?或者会不会少统计了呢?
这 两 个 看 起 来 有 矛 盾 的 提 问 , 其 实 就 解 决 了 这 两 个 问 题 。 这两个看起来有矛盾的提问,其实就解决了这两个问题。 这两个看起来有矛盾的提问,其实就解决了这两个问题。
因 为 我 每 一 个 位 置 只 统 计 了 一 次 , 但 是 可 能 我 假 设 的 这 个 位 置 出 现 大 小 为 i 的 块 不 止 一 个 , 所 以 才 会 有 疑 问 会 不 会 少 统 计 了 。 因为我每一个位置只统计了一次,但是可能我假设的这个位置出现大小为 i 的块不止一个,所以才会有疑问会不会少统计了。 因为我每一个位置只统计了一次,但是可能我假设的这个位置出现大小为i的块不止一个,所以才会有疑问会不会少统计了。
同 时 因 为 每 一 个 位 置 都 统 计 了 一 次 , 所 以 可 能 会 有 两 个 位 置 , 出 现 大 小 为 i 的 块 的 数 量 及 位 置 都 相 同 , 所 以 才 会 有 疑 问 会 不 会 重 复 统 计 了 。 同时因为每一个位置都统计了一次,所以可能会有两个位置,出现大小为 i 的块的数量及位置都相同,所以才会有疑问会不会重复统计了。 同时因为每一个位置都统计了一次,所以可能会有两个位置,出现大小为i的块的数量及位置都相同,所以才会有疑问会不会重复统计了。
确 实 有 可 能 会 出 现 x 个 位 置 , 此 时 出 现 大 小 为 i 的 块 的 数 量 及 位 置 都 相 同 确实有可能会出现 x 个位置,此时出现大小为 i 的块的数量及位置都相同 确实有可能会出现x个位置,此时出现大小为i的块的数量及位置都相同
但 是 每 一 次 我 只 统 计 了 一 次 , 并 没 有 乘 以 x 这 个 数 , 所 以 不 会 重 复 , 也 不 会 丢 掉 一 些 数 。 但是每一次我只统计了一次,并没有乘以 x 这个数,所以不会重复,也不会丢掉一些数。 但是每一次我只统计了一次,并没有乘以x这个数,所以不会重复,也不会丢掉一些数。
#include
using namespace std;
const int maxn=2e5+10;
const int mod=998244353;
typedef long long ll;
ll dp[maxn],fac[maxn];
int main()
{
int n;
cin>>n;
dp[n]=10,dp[n-1]=180,fac[0]=1;
for(int i=1;i<=n;i++) fac[i]=fac[i-1]*10%mod;
for(int i=n-2;i>=1;i--)
{
int l=n-i+1;//
dp[i]=(l-2)*10*9*9*fac[n-i-2]%mod;
dp[i]+=2*10*9*fac[n-i-1];
dp[i]%=mod;
}
for(int i=1;i<=n;i++) cout<