ZR8.2 DP

DP

1CF1101D

我们发现,最终答案一定和质因数有关

我们发现(w_i <= 2*10^5)级别的树,他的素因子的个数不会非常多((<=10))

然后我们就设

gcd是(dp_{u,v})表示(u)节点的第(v)个素因子的倍数答案

很明显答案只能从相同的质因子去转移

[dp_{u,v} = max_{p_v = p_{v'}}{(dp_{son_u,v'})} + 1 ]

每次合并子树时利用dp数组更新ans就好了

2 CF1039D

很明显,当(k > frac{2}{n})时答案是(1)或者(0)

这种情况提前预处理一下直径就好了

当(k <= frac{2}{n})时

我们设(dp_{i})表示(i)子树内的最长链

每次在合并时,如果存在长度和大于(k)的两条链,我们就贪心合并

这样的话时间复杂度是

(O(n^2/2))

CF开(7s)卡卡常吧

接下来想想怎么优化时间复杂度

我们发现

答案是类似于数论分块那样递减的

且(max_{ans} <= sqrt n)

对于(sqrt n)段中的每一段我们都二分他的边界

每次check就做上面的DP

时间复杂度(O(nsqrt nlogn))

CF1097G

首先(k = 1)时我们有做法

枚举边,计算边的贡献

比如我们当前枚举了((u,v))

那么贡献就是((2^{size_u} - 1)*(2^{size_v} - 1))

但是这种做法只适用于(k = 1)

因为我们是枚举了边,判断有多少点集(S)满足条件

但是如果(k>1),很明显这条边在不同点集的贡献不一定相同,所以上述方法就莫得了

我们先考虑多项式做法

考虑设$dp_{u,v} (表示)u(为根的子树,选了)v(条边,且同时满足)u$点被选择了的方案数

当然,这种情况要考虑的情况有些复杂

要考虑根选不选的情况之类的

这样的树形背包时间复杂度是(n^2)的

首先

[x^k = sum_{i = 0}^kC_x^i*i!*S(k,i) ]

其中(S(k,i))表示第二类斯特林数,将(k)个元素划分成(i)个集合(集合是相同的)的方案数

[S(i,j) = S(i - 1,j - 1) + S(i - 1,j) * j ]

(x^k)其实就是(x)球放到(k)的个筐里的方案数

右边就是我们强制

我们将原题中的式子带进去

[egin{align} ans &= sum_{X}sum_{i = 0}^kC_{f(X)}^i*i!*S(f(X),i)\ &=sum_{i = 0}^ki!S(f(X),i)sum_{X} C_{f(X)}^i end{align} ]

我们发现这个东西平方没有了

边数大小相同的集合就可以放在一起计算了,我们设(dp_{i,j})表示(i)为子树的根同时满足有(j)条边的方案数

dp的时候就是树上背包合并,注意枚举一条边选不选

CF 1061 CMultiplicity

我们设(f_{i,j})表示前(i)个数长度为(j)的方案数

很明显如果选的话(j)应该是(a_i)的因子

我们(j)只需要枚举(a_i)的因子

所以时间复杂度(O(nsqrt n))

CF 886E Maximum Element

我们考虑补集法正难则反

先考虑这个程序完全运行完毕的方案数

另外这种只和大小关系有关的题目每一步都可以去看做一个排列去做

我们设(dp _{i})表示(1-i)的排列的最终运行完毕的方案数

首先(i)必须在([i - k + 1,i])这个区间内

我们考虑转移时枚举最大值出现的位置(j)

[egin{align} dp_{i} &= sum_{j = i -k + 1}^idp_{j - 1}C_{i - 1}^{j - 1}*(i - j)!\ &= sum_{j = i - k + 1}^idp_{j - 1}frac{(i - 1)!(i - j)!}{(j - 1)!(i - j)!}\ &= sum_{j = i - k + 1}^idp_{j - 1}frac{i - 1}{j - 1}\ &=(i- 1)!sum_{j = i - k}^{i - 1}frac{dp_j}{j} end{align} ]

我们发现我们转移的时候只需要顺便记录一下(frac{dp_j}{j})的前缀和就可以做到(O(1))转移了

但这只是答案补集的一部分

我们还需要考虑在中途就遇到了(n)然后停止的情况

设这一部分的方案为(S),枚举(n)出现的位置

[S = sum_{i = 1}^ndp_{i - 1}*(n - i)! ]

最后用(n!)减去(dp_n)和(S)就是答案

CF1096D

设(f_{i,0,1,2,3})表示(1-i)组成的子序列,求满足已经有(s_{0,1,,2,3})结尾的子序列的方案数

转移看当前字符是啥就好了

子串的话就把所有连续的h和d压成一个

每次遇到hard贪心就好

CF979E

如果一个图是给你的

直接(dp_{i,0,1})表示到达(i)点且当前路径条数奇偶性为(0,1)的方案数

如果没给你,我们考虑一下最暴力的转移方法

设

(f_{i,ow,ob,ew,eb})表示当前在第(i)个点,且同时满足有偶白(ow)个,偶黑(ob)个,奇白(ew)个,奇黑(eb)个的奇偶性

Hero Meet Devil(HDU4899)

本来(LCS)就是一个不太平凡的DP问题

结果我们发现我们总的DP转移时还要用到LCS

之后我们考虑LCS的DP过程

当(a_i = b_i)时

[f_{i,j} = f_{i - 1,j - 1} + 1 ]

当(a_i!=b_i)时

[f_{i,j} = max{(f_{i - 1,j},f_{i,j - 1})} + 1 ]

我们发现一个神奇的东西

[f_{i,j- 1} <= f_{i,j} <= f_{i,j} + 1 ]

然后我们就可以用差分序列把这个东西给 压起来

考虑外层转移

我们设(state_{i,j})表示在状态(i)后面添加字符(s_j(s_j in(A,C,G,T)))将要转移到的状态

[dp_{len + 1,state_{i,j}}+=dp_{len,i} ]

发现外层转移就比较简单了

说一下在我在做这个题中犯的错误吧

我们新加入一个(i)时

由于我用来求DP的(g)数组是滚动的

所以应该倒序枚举或者记录原来状态,我直接正序枚举用了更新以后的状态.

#include<iostream>
#include<algorithm>
#include<queue>
#include<cctype>
#include<cstring>
#include<vector>
#include<cstdio>
#define debugint(x) cerr << #x << ' ' << x << std::endl
#define int long long
using namespace std;
const int N = 1003;
const int M = (1 << 15) + 111;
const int mod = 1e9 + 7;
int f[3][M];
int n,m;
int state[M][5];
char s[N];
int g[17],gg[N];
int ans[17];
inline int calc(int st,char x){
    int now = 0;
    //printf("char:%c ",x);debugint(st);
    for(int i = 1;i <= n;++i)
        gg[i] = g[i] = g[i - 1] + ((st & (1 << (i - 1))) ? 1 : 0);
  //  printf("g:");
    //for(int i = 1;i <= n;++i) printf("%d ",g[i]);puts("");
    for(int i = 1;i <= n;++i){
        if(x == s[i]) g[i] = gg[i - 1] + 1;
        else g[i] = max(g[i],g[i - 1]);
        now |= (g[i] - g[i - 1]) << (i - 1);
    }
	//printf("g:");for(int i = 1;i <= n;++i) printf("%d ",g[i]);puts("");
    return now;
}
inline int count(int x){
    int res = 0;
    while(x){
        if(x & 1) res++;
        x >>= 1;
    }
    return res;
}
inline void up(int &x,int y){
    x += y;
    if(x >= mod) x -= mod;
}
signed main(){
    int T;scanf("%d",&T);
    while(T--){
        memset(ans,0,sizeof(ans));
        memset(f,0,sizeof(f));
        scanf("%s",s + 1);
        n = strlen(s + 1);
        scanf("%d",&m);
        for(int i = 0;i < (1 << n);++i){
            state[i][1] = calc(i,'A');
            state[i][2] = calc(i,'C');
            state[i][3] = calc(i,'G');
            state[i][4] = calc(i,'T');
        }
        f[0][0] = 1;
		int now = 0;
        for(int i = 0;i < m;++i){
			memset(f[now ^ 1],0,sizeof(f[now ^ 1]));
            for(int j = 0;j < (1 << n);++j){
                for(int k = 1;k <= 4;++k)
                up(f[now ^ 1][state[j][k]],f[now][j]);
            }
			now ^= 1;
        }
        for(int i = 0;i < (1 << n);++i) up(ans[count(i)],f[now][i]);
        for(int i = 0;i <= n;++i) printf("%d
",ans[i]);
    }
    return 0;
}

XHXJ’s LIS(HDU4352)

CF1043F

我们发现最终答案不会大于(7)。。。。

因为(2 imes 3 imes 5 imes 7 imes11 imes 13 imes 17 >=3 imes10^5)

咕咕咕