最长公共子序列与最长公共子串
子序列转移到
i
i
i 求的就是考虑前
i
i
i 个所有的子序列，而子串是考虑以第
i
i
i 个结尾的子串数量，需要把每一个以
i
i
i 结尾的子串数量都加起来
D - FG operation
ABC简单计数dp
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 2e5 + 9;
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
int a[maxn];
int f[maxn][10];
// f[i][j] 表示处理1-i 这一段 最后剩余 j 的方案数
void work()
{
cin >> n;
for(int i = 1; i <= n; ++i) cin >> a[i];
f[1][a[1]] = 1;
for(int i = 2; i <= n; ++i){
for(int j = 0; j < 10; ++j){
int k = (j + a[i]) % 10;
f[i][k] = (f[i][k] + f[i-1][j]) % mod;
k = (j * a[i]) % 10;
f[i][k] = (f[i][k] + f[i-1][j]) % mod;
}
}
for(int i = 0; i < 10; ++i)
cout << f[n][i] << endl;
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
work();
return 0;
}
躲藏
题意：
给定一个字符串，找出有多少子序列
c
w
b
c
cwbc
cwbc
思路：
初始考虑
f
[
i
]
[
j
]
f[i][j]
f[i][j] 表示
s
s
s 串前
i
i
i 个字符中，匹配了字符串
c
w
b
c
cwbc
cwbc 前
j
j
j 位
那么有转移方程
f
[
i
]
[
1
]
=
(
f
[
i
−
1
]
[
1
]
+
(
s
[
i
]
=
=
′
c
′
)
)
%
m
o
d
f
[
i
]
[
2
]
=
(
f
[
i
−
1
]
[
2
]
+
(
s
[
i
]
=
=
′
w
′
)
∗
f
[
i
−
1
]
[
1
]
)
%
m
o
d
f
[
i
]
[
3
]
=
(
f
[
i
−
1
]
[
3
]
+
(
s
[
i
]
=
=
′
b
′
)
∗
f
[
i
−
1
]
[
2
]
)
%
m
o
d
f
[
i
]
[
4
]
=
(
f
[
i
−
1
]
[
4
]
+
(
s
[
i
]
=
=
′
c
′
)
∗
f
[
i
−
1
]
[
3
]
)
%
m
o
d
f[i][1]=(f[i-1][1]+(s[i]=='c')) \ \% \ mod \\ f[i][2]=(f[i-1][2]+(s[i]=='w')*f[i-1][1]) \ \% \ mod \\ f[i][3]=(f[i-1][3]+(s[i]=='b')*f[i-1][2]) \ \% \ mod \\ f[i][4]=(f[i-1][4]+(s[i]=='c')*f[i-1][3]) \ \% \ mod \\
f[i][1]=(f[i−1][1]+(s[i]==′c′)) % modf[i][2]=(f[i−1][2]+(s[i]==′w′)∗f[i−1][1]) % modf[i][3]=(f[i−1][3]+(s[i]==′b′)∗f[i−1][2]) % modf[i][4]=(f[i−1][4]+(s[i]==′c′)∗f[i−1][3]) % mod
但是这样会
M
L
E
MLE
MLE，因此需要考虑空间优化
显然转移方程只与前一位有关，考虑滚动数组优化掉第一维
这样转移方程就变成了
f
[
1
]
=
(
f
[
1
]
+
(
s
[
i
]
=
=
′
c
′
)
∗
1
)
%
m
o
d
f
[
2
]
=
(
f
[
2
]
+
(
s
[
i
]
=
=
′
w
′
)
∗
f
[
1
]
)
%
m
o
d
f
[
3
]
=
(
f
[
3
]
+
(
s
[
i
]
=
=
′
b
′
)
∗
f
[
2
]
)
%
m
o
d
f
[
4
]
=
(
f
[
4
]
+
(
s
[
i
]
=
=
′
c
′
)
∗
f
[
3
]
)
%
m
o
d
f[1]=(f[1]+(s[i]=='c')*1) \ \% \ mod \\ f[2]=(f[2]+(s[i]=='w')*f[1])\ \% \ mod \\ f[3]=(f[3]+(s[i]=='b')*f[2])\ \% \ mod \\ f[4]=(f[4]+(s[i]=='c')*f[3])\ \% \ mod \\
f[1]=(f[1]+(s[i]==′c′)∗1) % modf[2]=(f[2]+(s[i]==′w′)∗f[1]) % modf[3]=(f[3]+(s[i]==′b′)∗f[2]) % modf[4]=(f[4]+(s[i]==′c′)∗f[3]) % mod
未优化空间：
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 2e5 + 9;
const ll mod = 2000120420010122;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
string t = "@cwbc", s;
ll f[maxn][5];
void work()
{
n = s.size();
for(int i = 0; i <= n; ++i)
f[i][1] = f[i][2] = f[i][3] = f[i][4] = 0, f[i][0] = 1;
s = "@" + s;
for(int i = 1; i <= n; ++i)
{
s[i] = tolower(s[i]);
for(int j = 1; j <= 4; ++j)
f[i][j] = (f[i-1][j] + (s[i] == t[j]) * f[i-1][j-1]) % mod;
}
cout << f[n][4] << endl;
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
while(cin >> s)
work();
return 0;
}
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 2e5 + 9;
const ll mod = 2000120420010122;
ll n, m;
ll f[5];
string s, op = "@cwbc";
void work()
{
memset(f, 0, sizeof(f));
n = s.size();
s = "@" + s;
ll ans = 0;
f[0] = 1;
for(int i = 1; i <= n; ++i)
{
s[i] = tolower(s[i]);
for(int j = 4; j >= 1; --j)
f[j] = (f[j] + (s[i] == op[j]) * f[j - 1]) % mod;
}
cout << f[4] << endl;
}
int main()
{
ios::sync_with_stdio(0);
//int TT;cin>>TT;while(TT--)
while(cin >> s)
work();
return 0;
}
Nun Heh Heh Aaaaaaaaaaa
题意：
给定串
s
s
s，求有多少子序列满足前缀是
n
u
n
h
e
h
h
e
h
nunhehheh
nunhehheh，后边至少有一个
a
a
a。
思路：
考虑动态规划
首先我们肯定要用动态规划统计前缀
n
u
n
h
e
h
h
e
h
nunhehheh
nunhehheh 的个数，然后知道如果知道它后边有多少个
a
a
a，那么这次的贡献很好求了，假设有
m
m
m 个
a
a
a，我们可以选
1
,
2
,
3
,
.
.
.
m
1,2,3,...m
1,2,3,...m 个，也就是
C
m
1
+
C
m
2
+
C
m
3
+
.
.
.
+
C
m
m
=
2
m
−
1
C_m^1+C_m^2+C_m^3+...+C_m^m=2^m-1
Cm1+Cm2+Cm3+...+Cmm=2m−1（减去
C
m
0
C_m^0
Cm0）
统计前缀的过程与上边那道题目一样，然后我们只需要再统计每个前缀后边有多少个
a
a
a，就可以求出答案了
注意要减去之前用过的子序列
code：（没有优化空间
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e5 + 9;
const int mod = 998244353;
ll n, m;
ll q_pow(ll a, ll n, ll ans = 1){
while(n){
if(n & 1) ans=ans*a%mod;a=a*a%mod;n>>=1;
}return ans;
}
ll f[maxn][15];
string op = "@nunhehheh";
void work()
{
memset(f, 0, sizeof(f));
string s;cin >> s;
n = s.size();
m = 0;
s = "@" + s;
for(int i = 1; i <= n; ++i) if(s[i] == 'a')
++m;
ll ans = 0, tmp = 0;
for(int i = 0; i <= n; ++i) f[i][0] = 1;
for(int i = 1; i <= n; ++i)
{
for(int j = 9; j >= 1; --j)// 因为没有优化空间，遍历方向无所谓
f[i][j] = (f[i-1][j] + (s[i] == op[j]) * f[i - 1][j - 1]) % mod;
ans = (ans + (f[i][9] - f[i-1][9] + mod) % mod * (q_pow(2, m) - 1 + mod) % mod) % mod;
if(s[i] == 'a') --m;
}
cout << ans << endl;
}
int main()
{
ios::sync_with_stdio(0);
int TT;cin>>TT;while(TT--)
work();
return 0;
}
滚动数组优化空间
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e5 + 9;
const int mod = 998244353;
ll n, m;
ll q_pow(ll a, ll n, ll ans = 1){
while(n){
if(n & 1) ans=ans*a%mod;a=a*a%mod;n>>=1;
}return ans;
}
ll f[15];
string op = "@nunhehheh";
void work()
{
memset(f, 0, sizeof(f));
string s;cin >> s;
n = s.size();
m = 0;
s = "@" + s;
for(int i = 1; i <= n; ++i) if(s[i] == 'a')
++m;
ll ans = 0, tmp = 0;
f[0] = 1;
for(int i = 1; i <= n; ++i)
{
for(int j = 9; j >= 1; --j)
f[j] = (f[j] + (s[i] == op[j]) * f[j - 1]) % mod;
ans = (ans + (f[9] - tmp + mod) % mod * (q_pow(2, m) - 1 + mod) % mod) % mod;
tmp = f[9];
if(s[i] == 'a') --m;
}
cout << ans << endl;
}
int main()
{
ios::sync_with_stdio(0);
int TT;cin>>TT;while(TT--)
work();
return 0;
}
E. Divisible by 3
一段区间的权重指的是：区间内所有两个元素的乘积之和
子段是连续的，与子序列不同
两个状态转移的区别就是，子序列要考虑当前位置选与不选，而子段、子串，这一位必选，直接转移
也就是子段不能直接承接上一层状态
一道子序列的计数题目
开始考虑
f
[
i
]
[
j
]
f[i][j]
f[i][j] 表示以
i
i
i 结尾，权重为
j
j
j 的子段和数量
发现权重无法根据上一层得到，分析权重的变化
每次添加一个
a
[
i
]
a[i]
a[i]，那么权重
w
[
i
]
=
w
[
i
−
1
]
+
s
u
m
[
i
−
1
]
∗
a
[
i
]
w[i]=w[i-1]+sum[i-1]*a[i]
w[i]=w[i−1]+sum[i−1]∗a[i]
可以发现维护子段和可以很好的推出权重，因此
f
[
i
]
[
j
]
[
k
]
f[i][j][k]
f[i][j][k] 表示以
i
i
i 为结尾，子段的
w
e
i
g
h
t
weight
weight 模
3
3
3 为
j
j
j ，子段和模
3
3
3 为
k
k
k 的子段数量。
状态转移方程只与前一位有关，可以滚掉第一维
code：（没有滚掉第一维
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 5e5 + 9;
const int mod = 1e9 + 7;
ll n, m;
ll f[maxn][3][3], a[maxn];
//f[i][j][k]表示以i为结尾，子段的 weight模 3 为 j ,子段和模3为 k 的子段数量。九种状态直接转移即可。
void work()
{
cin >> n;
for(int i = 1; i <= n; ++i){
cin >> a[i]; a[i] %= 3; f[i][0][a[i]]++;
}
ll ans = 0;
for(int i = 1; i <= n; ++i)
{
for(int j = 0; j < 3; ++j)
for(int k = 0; k < 3; ++k)
{
ll x = (j + a[i] * k) % 3;
ll y = (a[i] + k) % 3;
f[i][x][y] += f[i - 1][j][k];
}
for(int k = 0; k < 3; ++k)// 注意子序列与子串的计数区别
ans += f[i][0][k];
}
cout << ans << endl;
}
int main()
{
ios::sync_with_stdio(0);
//int TT;cin>>TT;while(TT--)
work();
return 0;
}
滚掉第一维，比较难理解，更接近题目的本质，代码来源
d
l
s
dls
dls
简化一下其实就是一种计数的方法
类似于
if(){
ans += cnt;
++cnt;
}
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 5e5 + 9;
const int mod = 1e9 + 7;
ll n, m;
ll cnt[3][3], a[maxn];
//cnt[j][k]子段的 子段和模3 为 j, weight模 3 为 k 的子段数量
void work()
{
cin >> n;
for(int i = 1; i <= n; ++i){
cin >> a[i]; a[i] %= 3;
}
cnt[0][0] = 1;
ll ans = 0, x = 0, y = 0;
for(int i = 1; i <= n; ++i)
{
x = (x + a[i]) % 3;// 子段和
y = (y + a[i] * a[i]) % 3; // 子段平方和
for(int j = 0; j < 3; ++j)
for(int k = 0; k < 3; ++k)
{
ll tmp = (x - j) * (x - j) - (y - k);// 子段
if(tmp % 3 == 0) ans += cnt[j][k];
}
cnt[x][y]++;
}
cout << ans << endl;
}
int main()
{
ios::sync_with_stdio(0);
//int TT;cin>>TT;while(TT--)
work();
return 0;
}
子序列个数-FZU - 2129（已炸
题解
先考虑没有相同整数的情况，每个元素有选或不选两种情况，一共
n
n
n 个元素，又不能有空集，答案为
2
n
−
1
2n−1
2n−1 。
如果要写递推方程的话就是
d
p
[
i
]
=
d
p
[
i
−
1
]
∗
2
+
1
dp[i]=dp[i−1]∗2+1
dp[i]=dp[i−1]∗2+1，其中
d
p
[
i
]
dp[i]
dp[i] 表示考虑前
i
i
i 个元素所能构成的不同子序列数量，
d
p
dp
dp 方程含义为：在长度为
i
−
1
i−1
i−1 的序列中是否加入一个
a
[
i
]
a[i]
a[i] 以及只选
a
[
i
]
a[i]
a[i] 的情况 。
假设就按照这个方程推下去，如果前面某一位
j
j
j上的数与
a
[
i
]
a[i]
a[i] 相同，会对
d
p
[
i
]
dp[i]
dp[i] 造成什么影响呢？
首先，只选
a
[
i
]
a[i]
a[i] 这一个数的情况已经在前面统计过了，然后
j
j
j 前面的所有方案都不能转移到
d
p
[
i
]
dp[i]
dp[i] 上面来，因为它们已经转移到
d
p
[
j
]
dp[j]
dp[j] 上。
这里的 “ 所有方案 ” 其实就是
d
p
[
j
−
1
]
dp[j−1]
dp[j−1]，且
j
j
j 必须为最接近
i
i
i 的那一个位置，否则就不能代表所有被算重复的情况。
d
p
[
i
]
=
d
p
[
i
−
1
]
∗
2
+
1
，
l
a
s
t
[
a
[
i
]
]
=
0
d
p
[
i
]
=
d
p
[
i
−
1
]
∗
2
−
d
p
[
l
a
s
t
[
a
[
i
]
]
−
1
]
，
l
a
s
t
[
a
[
i
]
]
!
=
0
(
前
边
出
现
过
这
个
数
，
因
此
不
需
要
方
案
+
1
，
然
后
总
方
案
数
减
去
重
复
的
方
案
数
)
注
意
每
次
减
掉
的
方
案
数
必
须
是
左
边
离
i
最
近
的
dp[i]=dp[i-1]*2+1，last[a[i]]=0 \\ dp[i]=dp[i-1]*2 - dp[last[a[i]]-1]，last[a[i]] \ !=0 \ (前边出现过这个数，因此不需要方案+1，然后总方案数减去重复的方案数)\\ 注意每次减掉的方案数必须是左边离 \ i \ 最近的
dp[i]=dp[i−1]∗2+1，last[a[i]]=0dp[i]=dp[i−1]∗2−dp[last[a[i]]−1]，last[a[i]] !=0 (前边出现过这个数，因此不需要方案+1，然后总方案数减去重复的方案数)注意每次减掉的方案数必须是左边离 i 最近的
code：
#include<cstdio>
#include<iostream>
#include<string>
#include<algorithm>
#include<cstring>
#define endl '\n'
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const int Max = (int)1e6 + 9;
ll a[Max], dp[Max], last[Max];
int n, t, x;
void work()
{
memset(last, 0, sizeof(last));
for(int i = 1; i <= n; i++)
{
scanf("%d", &x);
dp[i] = (dp[i-1] << 1) % mod;// 先乘个2
if(!last[x]) // 之前没有出现过这个数字
{
last[x] = i;// 标记下
dp[i]++;// 单个该数字算一个
}
else
{
dp[i] = (dp[i] - dp[last[x] - 1] + mod) % mod;// 结合前边的分析
last[x] = i;// 更新上一个重复的数字的下标
}
}
cout << dp[n] % mod << endl;
}
int main()
{
while(~scanf("%d", &n)) work();
return 0;
}
P2516 [HAOI2010]最长公共子序列
题意：
求最长公共子序列，以及最长公共子序列的个数
思路：
看大佬题解
滚动数组优化
由
f
[
i
]
[
j
]
=
m
a
x
(
f
[
i
−
1
]
[
j
]
,
f
[
i
]
[
j
−
1
]
)
f[i][j]=max(f[i-1][j],f[i][j-1])
f[i][j]=max(f[i−1][j],f[i][j−1]) 可知
c
n
t
[
i
]
[
j
]
cnt[i][j]
cnt[i][j] 可以由
c
n
t
[
i
−
1
]
[
j
]
o
r
c
n
t
[
i
]
[
j
−
1
]
cnt[i-1][j] \ or \ cnt[i][j-1]
cnt[i−1][j] or cnt[i][j−1] 转移过来
如果存在一个情况，
c
n
t
[
i
−
1
]
[
j
−
1
]
cnt[i-1][j-1]
cnt[i−1][j−1] 转移到了
c
n
t
[
i
−
1
]
j
]
cnt[i-1]j]
cnt[i−1]j] 和
c
n
t
[
i
]
[
j
−
1
]
cnt[i][j-1]
cnt[i][j−1] 上，并且
c
n
t
[
i
−
1
]
j
]
cnt[i-1]j]
cnt[i−1]j] 和
c
n
t
[
i
]
[
j
−
1
]
cnt[i][j-1]
cnt[i][j−1] 也同时转移到了
c
n
t
[
i
]
[
j
]
cnt[i][j]
cnt[i][j] 上，那么就发生了重复计数
显然这种情况仅会在
c
n
t
[
i
]
[
j
]
=
c
n
t
[
i
−
1
]
[
j
−
1
]
cnt[i][j]=cnt[i-1][j-1]
cnt[i][j]=cnt[i−1][j−1] 时出现
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 5e3 + 9;
const int mod = 1e8;
ll n, m;
string s, t;
int f[2][maxn], cnt[2][maxn];
void work()
{
cin >> s >> t;
n = s.size() - 1, m = t.size() - 1;
s = "@" + s; t = "@" + t;
cnt[1][0] = 1;
for(int i = 0; i <= m; ++i) cnt[0][i] = 1;
for(int i = 1; i <= n; ++i)
{
int op = i % 2;
for(int j = 1; j <= m; ++j)
{
cnt[op][j] = 0;// 滚动数组注意初始化
if(s[i] == t[j])
f[op][j] = f[op^1][j-1] + 1, cnt[op][j] = cnt[op^1][j-1];
else
f[op][j] = max(f[op^1][j], f[op][j-1]);
if(f[op][j] == f[op^1][j])
cnt[op][j] += cnt[op^1][j], cnt[op][j] %= mod;
if(f[op][j] == f[op][j-1])
cnt[op][j] += cnt[op][j-1], cnt[op][j] %= mod;
if(f[op][j] == f[op^1][j-1])// 发生重复计数
cnt[op][j] = (cnt[op][j] - cnt[op^1][j-1] + mod) % mod;
}
}
cout << f[n%2][m] << endl << cnt[n%2][m];
}
int main()
{
ios::sync_with_stdio(0);
//int TT;cin>>TT;while(TT--)
work();
return 0;
}
北京化工大学周赛
题意：
给定一个字符串，每个字符为
0
−
9
0-9
0−9 或者
?
?
?，把
?
?
? 用
0
−
9
0-9
0−9 的数字代替，对于所有通过这种方式得到的数，有多少个数除以
13
13
13 余数是
5
5
5？
答案对
1
0
9
+
7
10^9+7
109+7 取模。
思路：
f
[
i
]
[
j
]
f[i][j]
f[i][j] 表示考虑前
i
i
i 个字符，除以
13
13
13 余
j
j
j 的方案数
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 1e5 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
ll f[maxn][15];
void work()
{
string s;cin >> s;
n = s.size();
s = "#" + s;
f[0][0] = 1;
for(int i = 1; i <= n; ++i)
{
for(int j = 0; j < 13; ++j)
{
if(s[i] == '?')
{
for(int k = 0; k < 10; ++k){
int p = (k + j * 10) % 13;
f[i][p] = (f[i-1][j] + f[i][p]) % mod;
}
}
else{
int k = (j * 10 + s[i] - '0') % 13;
f[i][k] = (f[i][k] + f[i-1][j]) % mod;
}
}
}
cout << f[n][5];
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
work();
return 0;
}
满意的集合–牛客小白月赛43
题意：
给定
1
−
9
1-9
1−9 这
9
9
9 个数字每个数字的个数
c
n
t
i
cnt_i
cnti，从中选出一些数组成可重集合，如果这些数可以拼接成
3
3
3 的倍数，那么这个集合被称作满意集合，空集也是满意集合；两个集合相同，当且仅当集合元素个数相同，且排序后对应数字相同。求满意集合数量，答案对
1
0
9
+
7
10^9+7
109+7 取模
思路：
考虑
f
[
i
]
[
j
]
f[i][j]
f[i][j] 表示从
1
−
i
1-i
1−i 中选数，拼接数
%
3
\%3
%3 为
j
j
j 的方案数
f[0][0] = 1;
for(int i = 1; i <= n; ++i){
for(int j = 0; j <= a[i]; ++j){// 直接去枚举选择i的数量，显然会T
for(int k = 0; k < 3; ++k){
int d = (j * i + k) % 3;
f[i][d] = (f[i][d] + f[i-1][k]) % mod;
}
}
}
找规律可以发现，如果一个数选择
1
,
4
,
7...3
k
+
1
1,4,7...3k+1
1,4,7...3k+1 次，他们对应的集合拼接出的数对
3
3
3 取模是等价的
同理，如果选择
0
,
3
,
6
,
.
.
.
3
k
0,3,6,...3k
0,3,6,...3k 次 和
2
,
5
,
8...3
k
+
2
2,5,8...3k+2
2,5,8...3k+2 次
因此选择的数次数种类只有三种即
0
,
1
,
2
0,1,2
0,1,2
这样就可以把
c
n
t
i
cnt_i
cnti 分解为三个数相加，也就是
%
3
=
0
,
1
,
2
\%3 = 0,1,2
%3=0,1,2 的三种数
由于可以选
0
0
0 个，因此
n
u
m
3
num3
num3 需要加
1
1
1
1
∗
i
%
3
1*i\%3
1∗i%3 贡献
n
u
m
1
num1
num1 次
2
∗
i
%
3
2*i\%3
2∗i%3 贡献
n
u
m
2
num2
num2 次
3
∗
i
%
3
3*i\%3
3∗i%3 贡献
n
u
m
3
num3
num3 次
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 10 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
ll cnt[maxn];
ll f[maxn][3];
void work()
{
n = 9;
for(int i = 1; i <= n; ++i) cin >> cnt[i];
f[0][0] = 1;
for(int i = 1; i <= n; ++i){
ll x = i % 3, y = i * 2 % 3, z = i * 3 % 3;
ll num1 = cnt[i] / 3 + (cnt[i] % 3 >= 1);
ll num2 = cnt[i] / 3 + (cnt[i] % 3 >= 2);
ll num3 = cnt[i] / 3 + 1;
for(int k = 0; k < 3; ++k){
int d = (x + k) % 3;
f[i][d] = (f[i][d] + num1 * f[i-1][k]) % mod;
d = (y + k) % 3;
f[i][d] = (f[i][d] + num2 * f[i-1][k]) % mod;
d = (z + k) % 3;
f[i][d] = (f[i][d] + num3 * f[i-1][k]) % mod;
}
}
cout << f[n][0];
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
work();
return 0;
}
虽然思路和上边的差不多，但是这个写法看起来很简洁，但是不知道得到 num 的原理是啥
for(int i = 1; i <= n; ++i){
for(int j = 0; j < 3; ++j){
int num = (cnt[i] - j + 3) / 3;
for(int k = 0; k < 3; ++k){
int d = (j * i + k) % 3;
f[i][d] = (f[i][d] + num * f[i-1][k]) % mod;
}
}
}
月之暗面
思路：
直接树形 dp，记录当根节点颜色假如已经被确定时的两种方案对应方案数即可。
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
ll a, b;
vector <int> e[maxn];
ll f[maxn][2];// 0普通颜色，1特殊颜色
void dfs(int x, int fa){
f[x][0] = f[x][1] = 1;// 假设x节点的颜色是确定的
for(int to : e[x]) if(to != fa)
{
dfs(to, x);// 转移是给 to 涂颜色
f[x][0] = f[x][0] * ((f[to][0] * a % mod + f[to][1] * b % mod) % mod) % mod;
f[x][1] = f[x][1] * ((f[to][0] * a % mod + f[to][1] * (b - 1) % mod) % mod) % mod;
}
}
void work()
{
cin >> n >> a >> b;
for(int i = 1; i < n; ++i){
int x, y;cin >> x >> y; e[x].push_back(y);e[y].push_back(x);
}
dfs(1, -1);
cout << (f[1][0] * a % mod + f[1][1] * b % mod) % mod;
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
work();
return 0;
}
另外一种思路的
d
p
dp
dp 公式
设
x
x
x 为当且节点，
t
o
to
to 为子节点
普通颜色：
f
[
x
]
[
0
]
=
f
[
x
]
[
0
]
∗
(
f
[
t
o
]
[
0
]
+
f
[
t
o
]
[
1
]
)
f[x][0] = f[x][0] * (f[to][0]+f[to][1])
f[x][0]=f[x][0]∗(f[to][0]+f[to][1])，这部分没什么好说的
考虑特殊颜色
如果子节点是普通颜色就加上即可
子节点为某种特殊颜色，我们给
x
x
x 确定为某种颜色，那么
t
o
to
to 就可以选剩下的
y
−
1
y-1
y−1 种，而这些特殊颜色都是等价的，所以总的合法方案的比例也是
y
−
1
y
\frac{y-1}{y}
yy−1，因此增加的合法的方案数即为
f
[
t
o
]
[
1
]
∗
y
−
1
y
f[to][1]*\frac{y-1}{y}
f[to][1]∗yy−1
看到这个合法方案数的占比就想到了这道题
code：
#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
ll a, b, ib;
vector <int> e[maxn];
ll f[maxn][2];
ll q_pow(ll a, ll b){
ll ans = 1;while(b){
if(b & 1) ans = ans * a % mod;b >>= 1; a = a * a % mod;
}return ans;
}
void dfs(int x, int fa){
f[x][0] = a;f[x][1] = b;
for(auto to : e[x]){
if(to == fa) continue;
dfs(to, x);
(f[x][0] *= (f[to][0] + f[to][1]) % mod) %= mod;
(f[x][1] *= (f[to][0] + f[to][1] * ib % mod * (b - 1) % mod) % mod) %= mod;
}
}
void work()
{
cin >> n >> a >> b;
for(int i = 1; i < n; ++i){
int x, y;cin >> x >> y;
e[y].push_back(x);e[x].push_back(y);
}
ib = q_pow(b, mod - 2);
dfs(1, -1);
cout << (f[1][0] + f[1][1]) % mod;
}
int main()
{
ios::sync_with_stdio(0);
// int TT;cin>>TT;while(TT--)
work();
return 0;
}
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
