树型dp
过程：一般先算子树然后进行合并，在实现上与二叉树的后序遍历类似，先遍历子树，遍历完之后把子树的值合并给父亲。
NC24953(树的最小支配集)：一个点被盖，它自己和与它相邻的点都算被覆盖。给你一棵无向树，问你最少用多少个点可以覆盖掉所有其他的点？
若是边覆盖的话，一条边要么被某个结点自己覆盖，要么被其儿子覆盖。但是现在是覆盖点，一个点既可以被儿子覆盖，也可以被自己覆盖，也可以被父亲覆盖，所以要定义三个状态了。
d
p
[
i
]
[
0
]
dp[i][0]
dp[i][0] 表示某个结点自身有覆盖，子树的最小点数，
d
p
[
i
]
[
1
]
dp[i][1]
dp[i][1] 表示某个结点自己没有覆盖，但是某个儿子覆盖，
d
p
[
i
]
[
2
]
dp[i][2]
dp[i][2] 表示某个结点自己没有覆盖，但是其父亲覆盖。
易知
d
p
[
i
]
[
0
]
=
1
+
∑
m
i
n
(
d
p
[
j
]
[
0
]
,
d
p
[
j
]
[
1
]
,
d
p
[
j
]
[
2
]
)
dp[i][0] = 1 + \sum min(dp[j][0], dp[j][1], dp[j][2])
dp[i][0]=1+∑min(dp[j][0],dp[j][1],dp[j][2]) (
j
j
j 为
i
i
i 的儿子)，
d
p
[
i
]
[
2
]
=
∑
m
i
n
(
d
p
[
j
]
[
0
]
,
d
p
[
j
]
[
1
]
)
dp[i][2] = \sum min(dp[j][0], dp[j][1])
dp[i][2]=∑min(dp[j][0],dp[j][1]),
d
p
[
i
]
[
1
]
dp[i][1]
dp[i][1] 比较复杂一些，需要至少有一个儿子覆盖自身，则
d
p
[
i
]
[
1
]
=
∑
m
i
n
(
d
p
[
j
]
[
0
]
,
d
p
[
j
]
[
1
]
)
+
i
n
c
i
n
c
=
m
a
x
(
0
,
m
i
n
d
p
[
j
]
[
0
]
−
d
p
[
j
]
[
1
]
)
dp[i][1] = \sum min(dp[j][0], dp[j][1]) + inc \ inc = max(0, min \ dp[j][0] - dp[j][1])
dp[i][1]=∑min(dp[j][0],dp[j][1])+inc inc=max(0,min dp[j][0]−dp[j][1])
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = 1e4 + 10;
const int INF = 0x3f3f3f3f;
const ll mod = 998244353;
int n, m;
struct edge //链式前向星
{
int to, next;
}e[maxn*2];
int head[maxn], num; //head为0表示搜索到了尽头
void add_edge(int u, int v)
{
e[++num].to = v;
e[num].next = head[u];
head[u] = num;
}
int dp[maxn][3];
void dfs(int x, int fa)
{
int flag = 0, tmp = INF;
dp[x][0] = 1;
for(int i = head[x]; i; i = e[i].next)
{
int to = e[i].to;
if(to == fa) continue;
dfs(to, x);
dp[x][0] += min(dp[to][0], min(dp[to][1], dp[to][2]));
dp[x][2] += min(dp[to][0], dp[to][1]);
if(dp[to][0] <= dp[to][1])
{
dp[x][1] += dp[to][0];
flag = 1;
}
else
{
dp[x][1] += dp[to][1];
tmp = min(tmp, dp[to][0] - dp[to][1]);
}
}
if(flag == 0) dp[x][1] += tmp;
}
int main()
{
scanf("%d", &n);
for(int i = 1; i < n; i++)
{
int x, y;
scanf("%d %d", &x, &y);
add_edge(x, y); add_edge(y, x);
}
dfs(1, 0);
printf("%d\n", min(dp[1][0], dp[1][1]));
}
NC24953(二分)： 给定一棵
n
n
n 个结点的树，每条边有个边权，然后切去一些边，让根结点和除根结点外的叶子结点不连通，切去边的总值不能超过
m
m
m， 问所有的方案中，切去最大边最小是多少？
可以知道最大边越大，越容易实现，所求的值是单调的，所以可以进行二分，进行树上的 dp；我的二分方法是让
L
L
L 一定不可行，让
R
R
R 一定可行，只要这两个值差距小于等于
1
1
1， 答案就是
R
R
R。
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = 1010;
const int INF = 0x3f3f3f3f;
const ll mod = 998244353;
int n;
struct edge //链式前向星
{
int to, next, w;
}e[maxn*2];
int head[maxn], num; //head为0表示搜索到了尽头
void add_edge(int u, int v, int w)
{
e[++num].to = v;
e[num].w = w;
e[num].next = head[u];
head[u] = num;
}
int mx, m, cur, d[maxn];
bool dfs(int x, int fa) //x的子树断掉所有叶子结点是否可行，若可行，最小值记录在d[x]中
{
if(e[head[x]].next == 0 && fa > 0) //若 x 不是根结点且为叶子结点
return false;
d[x] = 0;
for(int i = head[x]; i; i = e[i].next)
{
//cout<<x<<" "<<e[x].w<<" "<<cur<<endl;
if(e[i].to == fa) continue;
if(!dfs(e[i].to, x))
{
if(e[i].w > cur) return false;
d[x] += e[i].w;
}
else if(e[i].w > cur) d[x] += d[e[i].to];
else d[x] += min(d[e[i].to], e[i].w);
}
if(d[x] > m) return false;
return true;
}
int main()
{
scanf("%d %d", &n, &m);
for(int i = 1; i < n; i++)
{
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
mx = max(mx, z);
add_edge(x, y, z); add_edge(y, x, z);
}
cur = mx;
if(!dfs(1, 0)) //判断右端点是否可行
{
printf("%d\n", -1);
return 0;
}
int l = 1, r = mx;
while(r - l > 1) //二分
{
cur = (l + r) / 2;
if(dfs(1, 0)) r = cur;
else l = cur;
}
printf("%d\n", r);
}
状压dp
过程：一种直观而高效地表示复杂状态的手段
NC20240(按行考虑)：在N×N的棋盘里面放K个国王，使他们互不攻击，共有多少种摆放方案。国王能攻击到它上下左右，以及左上 左下右上右下八个方向上附近的各一个格子，共8个格子。
若是要单独考虑每一个国王的摆放，有一些困难(插头dp ?)，所以可以按照行来考虑，以一个二进制数
x
x
x 表示一行，首先这一行不能有相邻的 1， 即
(
x
&
(
x
+
1
)
)
!
=
0
(x \& (x+1)) != 0
(x&(x+1))!=0, 其次与上一行(记录状态为
y
y
y )也不能互相攻击，即
(
x
&
(
y
+
1
)
)
!
=
0
(x \& (y+1)) != 0
(x&(y+1))!=0,
(
x
&
(
y
−
1
)
)
!
=
0
(x \& (y-1)) != 0
(x&(y−1))!=0,
(
x
&
y
)
!
=
0
(x \& y) != 0
(x&y)!=0。所以我们可以得到转移方程： 第
i
i
i 行 摆了
j
j
j 个国王且状态为
k
k
k：
f
[
i
]
[
j
]
[
k
]
+
=
f
[
i
−
1
]
[
j
−
n
u
m
[
k
]
]
[
p
]
f[i][j][k] += f[i-1][j - num[k]][p]
f[i][j][k]+=f[i−1][j−num[k]][p]
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = 1010;
const int INF = 0x3f3f3f3f;
const ll mod = 998244353;
int n, K;
ll dp[10][82][600], ans;
int getNum(int x)
{
int cnt = 0;
while(x)
{
cnt += x & 1;
x >>= 1;
}
return cnt;
}
int main()
{
scanf("%d %d", &n, &K);
dp[0][0][0] = 1;
for(int i = 1; i <= n; i++)
{
for(int j = 0; j < (1 << n); j++)
{
if(j & (j<<1)) continue;
int num = getNum(j);
if(num > K) continue;
for(int k = 0; k < (1 << n); k++)
{
if((k & (k<<1)) || (k & j) || (k & (j<<1)) || (k & (j>>1)))
continue;
for(int h = 0; h + num <= K; h++)
dp[i][h+num][j] += dp[i-1][h][k];
}
}
}
for(int i = 0; i < (1 << n); i++)
ans += dp[n][K][i];
printf("%lld\n", ans);
}
NC16544(压缩初始状态)：题目很简单，给定一个无向图，求出长度大于2的简单环(顶点不重复出现)的数量，相应的取模。(
n
≤
20
n ≤ 20
n≤20)
若是用搜索的话，当完全图时复杂度会到达
O
(
n
！
)
O(n！)
O(n！)。若是用状压 dp 的话，一维用01串表示去过的点的话，那必须还得记录这条路径的起点和终点，若是开成三维数组的话，内存较大，并且最后答案肯定还有去重，比较麻烦。其实01串不仅可以表示去过的点，还可以表示出路径的起始位置，我们不妨用最低为 1 的位表示路径的起始位置，并规定这条路径只能走到标号比起始位置大的点，这样的话我们更新只会将后面的 0 变成 1， 前面的 1 永远是 1(详细的转移方程见代码)，而由于一个环可以顺时针也可以逆时针，所以最后答案要除以2。
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = (1<<20) + 10;
const int INF = 0x3f3f3f3f;
const ll mod = 998244353;
ll dp[maxn][20], ans[22], a[22];
int n, m, K, d[22][22];
int main()
{
scanf("%d %d %d", &n, &m, &K);
for(int i = 1; i <= m; i++)
{
int x, y;
scanf("%d %d", &x, &y);
d[x-1][y-1] = d[y-1][x-1] = 1; //切记状压从第0位开始，所以点也是从0计数
}
for(int i = 0; i < n - 2; i++) //以点 i 为起始点
dp[1<<i][i] = 1;
for(int i = 1; i < (1<<n); i++)
{
int s = 0; //s记录最低位1，即路径的起点
for(;;s++)
if(i & (1<<s))
break;
if(s >= n - 2) continue;
for(int j = s; j < n; j++) //s前面不会有1
{
if(((1<<j) & i) == 0 || dp[i][j] == 0) continue; //找到要扩展出路径的点
for(int k = s + 1; k < n; k++) //找到被扩展的点
{
if(((1<<k) & i) || d[j][k] == 0) continue;
dp[i | (1<<k)][k] += dp[i][j];
dp[i | (1<<k)][k] %= mod;
}
if(d[j][s]) //如果可以形成一个环
{
int num = __builtin_popcount(i); //统计1的个数
if(num >= 3)
ans[num] += dp[i][j], ans[num] %= mod;
}
}
}
for(int i = 3; i <= n; i++)
a[i%K] = (a[i%K] + ans[i]) % mod;
for(int i = 0; i < K; i++)
printf("%lld\n", (a[i] * (mod + 1) / 2) % mod);
}
数位dp
过程：按位考虑。
NC15035：题意是说令人讨厌的数字定义成含有4或者38的数字，给定一个区间，问里面有多少个这样令人讨厌的数？
首先可以将各个位置上的数字拆分，
f
[
i
]
[
s
t
]
f[i][st]
f[i][st]表示 从高往低数前
i
−
1
i - 1
i−1 位的状态确定为 st，给第
i
i
i 位到第
1
1
1 位填数字有多少种填法。0 表示既没有4也没有 38， 1 表示既没有4也没有38并且第
i
−
1
i - 1
i−1 位为3， 2 表示前面已经有 4 和 38。
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const ll mod = 998244353;
int f[10][3], a[10];
int dp(int pos, int st, int flag)
{
//flag 表示是否能直接返回值，也就是前pos - 1位和原数是否一样
if(pos == 0) return st == 2;
if(flag && f[pos][st] != -1) return f[pos][st];
int x = flag? 9: a[pos];
int ans = 0;
for(int i = 0 ; i <= x; i++)
{
if(i == 4 || st == 2 || (st == 1 && i == 8))
ans += dp(pos - 1, 2, flag || i < a[pos]);
else if(i == 3) ans += dp(pos - 1, 1, flag || i < a[pos]);
else ans += dp(pos - 1, 0, flag || i < a[pos]);
}
if(flag) f[pos][st] = ans;
return ans;
}
int calc(int x)
{
if(x <= 0) return 0;
memset(a, 0, sizeof(a));
int pos = 0;
while(x)
{
a[++pos] = x % 10;
x /= 10;
}
return dp(pos, 0, 0);
}
int main()
{
int n, m;
memset(f, -1, sizeof(f));
while(~scanf("%d %d", &n, &m))
{
if(n == 0 && m == 0) break;
printf("%d\n", calc(m) - calc(n - 1));
}
}
NC20665：给定一个区间，问这个里面有多少数能被7整除且位数和为7。
在数位dp的时候，比较好维护的是数位和(%7结果) 和前面的数 %7 的结果，维护这两个即可。
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 20020219;
ll l, r, f[30][7][7];
int n, a[25];
ll dp(int pos, int pre, int sum, int flag)
{
if(pos == 0) return (pre == 0 && sum == 0);
if(flag && f[pos][pre][sum] != -1) return f[pos][pre][sum];
int maxi = flag? 9: a[pos], tmp = 10 * pre;
ll ans = 0;
for(int i = 0 ; i <= maxi; i++)
{
ans += dp(pos - 1, (tmp + i) % 7, (sum + i) % 7, flag || i < maxi);
}
if(flag) f[pos][pre][sum] = ans;
return ans;
}
ll calc(ll x)
{
if(x < 0) return 0;
memset(a, 0, sizeof(a));
int pos = 0;
while(x)
{
a[++pos] = x % 10;
x /= 10;
}
return dp(pos, 0, 0, 0);
}
int main()
{
for(int i = 0; i < 25; i++)
for(int j = 0; j < 7; j++)
for(int k = 0; k < 7; k++)
f[i][j][k] = -1;
while(~scanf("%lld %lld", &l, &r))
{
if(r == 0 && l == 0) break;
printf("%lld\n", calc(r) - calc(l - 1));
}
}
扫一扫
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
