备战蓝桥杯---DP刷题2

1.树形DP：

即问那几个点在树的直径上，类似ROAD那题，我们先求一下每一个子树根的子树的最大值与次大值用d1,d2表示，直径就是d1+d2的最大值，那么我们如何判断是否在最大路径上，其实就是看一下从某一点出发的所有路劲（可以向父节点）的最大2条的和==直径，就在！因此我们还要维护一下向上的最大值（自上而下），我们假设j是i的父节点,此时i如果选择向j走，那么它可以向上即up[j]，也可以向下即d1[j]，假如d1[j]就是i到J的边，那么我们选d2[j],

下面是AC代码（注意更新时只考虑d1,对于一个父节点，不会用d2，否则就冲突了）：

#include<bits/stdc++.h>
using namespace std;
const int N=200010,M=2*N;
int n;
int h[N],e[M],ne[M],idx;
int d1[N],d2[N],p1[N],up[N];
int maxd;
void add(int a,int b){
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
void dfs_d(int u,int fa){
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        if(j==fa) continue;
        dfs_d(j,u);
        int dis=d1[j]+1;
        if(dis>d1[u]){
            d2[u]=d1[u];
            d1[u]=dis;
            p1[u]=j;
        }
        else if(dis>d2[u]) d2[u]=dis;
        
    }
    maxd=max(maxd,d1[u]+d2[u]);
}
void dfs_u(int u,int fa){
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        if(j==fa) continue;
        up[j]=up[u]+1;
        if(p1[u]==j){
            up[j]=max(up[j],d2[u]+1);
        }
        else up[j]=max(up[j],d1[u]+1);
        dfs_u(j,u);
    }
}
int main(){
    cin>>n;
    memset(h,-1,sizeof(h));
    for(int i=0;i<n-1;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    dfs_d(0,-1);
    dfs_u(0,-1);
    for(int i=0;i<n;i++){
        int d[3]={d1[i],d2[i],up[i]};
        sort(d,d+3);
        if(d[1]+d[2]==maxd) printf("%d\n",i);
    }
}

2.DP+矩阵快速幂：

首先不考虑规模，我们用f[i][j]表示由i个帅子在一起最上面数字为j的所有合法方案。

我们枚举第i-1个帅子的最上面，总共就是f[i][j]=4(f[i-1][1]+...+f[i-1][6]).

我们考虑限制，我们假设2不能贴1，也就是说最上面是2的话加1后最上面不能是5，那么前面的系数要么是0，要么是4.

又由于每一层的限制完全一样，我们考虑矩阵快速幂。

【f[i][1],f[1][2],f[i][3],f[i][4],f[i][5],f[i][6]】=【f[i-1][1],f[i-1][2],f[i-1][3],f[i-1][4],f[i-1][5],f[i-1][6]】*A(6*6的矩阵）

如何构造矩阵？原来填满了4

假如1与2不能相邻，即1不能5，2不能4，即我们把第一行第5列变为0，同理(2,4)变为0，即题目给了（x,y)，我们就把（x,y(对应）),(y,x(对应）)变为0。

下面是AC代码：

注意这里我们扩充了含有f的矩阵（为了方便）

#include<bits/stdc++.h>
using namespace std;
const int N=6;
int n,m,mod=1e9+7;
int ge(int x){
    if(x>=3) return x-3;
    return x+3;
}
int t[N][N];
void mul(int c[][N],int a[][N],int b[][N]){

    memset(t,0,sizeof(t));
    for(int i=0;i<6;i++){
        for(int j=0;j<6;j++){
            for(int k=0;k<6;k++){
                t[i][j]=(t[i][j]+(long long)a[i][k]*b[k][j])%mod;
            }
        }
    }
    memcpy(c,t,sizeof(t));
}
int main(){
    cin>>n>>m;
    int a[N][N];
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=4;
        }
    }
    while(m--){
        int x,y;
        cin>>x>>y;
        x--,y--;
        a[x][ge(y)]=0;
        a[y][ge(x)]=0;
    }
    int f[N][N]={4,4,4,4,4,4};//其他扩充0
    for(int k=n-1;k;k>>=1){
        if(k&1) mul(f,f,a);
        mul(a,a,a);
    }
    int res=0;
    for(int i=0;i<6;i++) res=(res+f[0][i])%mod;
    cout<<res;
}

3.DP

我们令f[i][j][k][c]表示走到（i，j)已经取了k个物品最后物品价值c的集合。

首先我们按照往下走和往右走来分，我们再分取和不取，取的话再枚举前一个即可。

注意边界f[1][1][0][-1](这里就可以让后面任何数都可）f[1][1][1][w[1]]

下面是AC代码：

#include<bits/stdc++.h>
using namespace std;
const int N=55,mod=1e9+7;
int n,m,k;
int w[N][N];
int f[N][N][13][14];
int main(){
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>w[i][j];
            w[i][j]++;
        }
    }
    f[1][1][1][w[1][1]]=1;
    f[1][1][0][0]=1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int u=0;u<=k;u++){
                for(int v=0;v<=13;v++){
                    int &vv=f[i][j][u][v];
                    vv=(vv+f[i-1][j][u][v])%mod;
                    vv=(vv+f[i][j-1][u][v])%mod;
                    if(u>0&&v==w[i][j]){
                        for(int c=0;c<v;c++){
                            vv=(vv+f[i-1][j][u-1][c])%mod;
                            vv=(vv+f[i][j-1][u-1][c])%mod;
                        }
                    }
                }
            }
        }
    }
    int res=0;
    for(int i=0;i<=13;i++) res=(res+f[n][m][k][i])%mod;
    cout<<res;
}

4.DP

我们假设第一项x，第二项x+d1,第三项x+d1+d2.

nx+(n-1)d1+(n-2)d2+...dn-1=s

此时x属于任意整数，我们转化一下，x=(s-(n-1)d1-...)/n为整数。

于是我们只要让(n-i)di%n求和与s%n相同，这样子就是组合问题。

我们令f[i][j]表示所有只考虑前i项当前和%n==j的方案，

易得转移方程：f[i][j]=f[i-1][(j-ia)%n]+f[i-1][(j+ib)%n].