训练---复杂dp

---

一、鸣人的影分身（线性dp,整数划分问题）

任意门
由于这道题目数据量很小，我们可以用爆搜来写，或者是说，超时了，我们也可以打表来写。

最后得到的式子是$f[i][j]$$=f[i-j][j]+f[i][j-1]$
转移是$O（1）$的，状态数量是$O（n^2）$
这一题与顺序无关，所以不能用到之前的那个隔板法。

#include<bits/stdc++.h>

using namespace std;
const int N=11;
// int f[N][N];

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>m>>n;
        int f[N][N]={0};
        f[0][0]=1;//没有能量，没有分身，可以生成一种情况
        for(int i=0;i<=m;i++)//由于可以每一个分身的能量可以从0开始，所以一开始的总和可以为0
            for(int j=1;j<=n;j++)
            {
                f[i][j]=f[i][j-1];//此时是最小数为0的情况
                if(i>=j)f[i][j]+=f[i-j][j];
            }
            cout<<f[m][n]<<endl;
    }
    return 0;
}

这一题的数据很小，暴力也是可以的

#include <iostream>
using namespace std;
int m, n;
int res;
void dfs(int t, int start, int state){  //state  已经完成的分身   start下一个分身的值   t剩余的能量
    if(state == n && t == 0){
        res ++;
    }
    if(state >= n)   return ;
    for(int i = start; i <= t; i ++ ){
        dfs(t-i, i, state+1);
    }
}
int main(){
    int T;
    cin >> T;
    while(T -- ){
        cin >> m >> n;
        res = 0;
        dfs(m, 0, 0);
        cout << res << endl;
    }
    return 0;
}

用分苹果的思想来做，也真的很妙！

任意门
允许有盘子空着不放，大佬写的哦！

#include<cstdio>
#include<algorithm>
#include<iostream>

using namespace std;

int f(int x,int y){
    if(x == 0) return 1;//没有苹果，全部盘子为0
    if(y == 0) return 0;//没有盘子，没法放
    if(y > x){//盘子数大于苹果数，至多只能x个盘子上都放一个 
        return f(x,x);
    }
    return f(x - y, y) + f(x, y - 1);//盘子数小于等于苹果数 -> 分类讨论： 有盘子为空，没有盘子为空
//有盘子为空的时候即至少有一个盘子为空，f(x,y-1);没有盘子为空即最少每个盘子都有一个,f(x-y,y)     
}

int main(){
    int t,n,m;//n个苹果分到m个盘子里去，运行盘子为空 
    cin >> t;
    while(t --){
        cin >> n >> m;
        cout << f(n,m) << endl;
    }
    return 0;
}

故引申到这点道题目来说，就是这样子的！！！很爱这种写法。
实际上我们可以发现，在递归的过程中就是要用到之前的数据，继而这道题可以转换为记忆化搜索将结果保存来做，即dp做法，但是这个dp是从递归去思考出来的- -而不是像y总那样直接思考dp做法.

#include<iostream>
#include<cstdio>
using namespace std;
int a[25][25],m,n;
int main()
{
    int t,m,n;
    for(m=0;m<=10;m++)
        {
            for(n=0;n<=10;n++)
            {
                if(m<n)a[m][n]=a[m][m]; 
                else if(m==0)a[m][n]=1;
                else if(n==0)a[m][n]=0;
                else a[m][n]=a[m-n][n]+a[m][n-1];
            }
        }
    scanf("%d",&t);
    for(int i=1;i<=t;i++)
    {
        scanf("%d%d",&m,&n);

        printf("%d\n",a[m][n]);//正数划分没有个数要求，这道题目有个数要求
    }
    return 0;
}

二、糖果（背包问题，线性dp）

任意门
我们在考试的时候都是通过已经学到的东西来做。
背包问题：选择模型，让我们选择满足条件的最大值。
$f[i][j]$状态表示：所有从前i个物品中选，且和除以k的余数是j的所有方案。属性：最大值。
$f[i][j]$①包含物品$i$②不包含物品$i$

#include<bits/stdc++.h>

using namespace std;
const  int N=110;


int n,k;
int f[N][N];

int main()
{
    cin>>n>>k;
    memset(f,-0x3f,sizeof f);//一定要初始化
    f[0][0]=0;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        for(int j=0;j<k;j++)
        {//选i+不选i
            f[i][j]=max(f[i-1][j],f[i-1][(j+k-x%k)%k]+x);//保证为负数
        }
    }
    cout<<f[n][0]<<endl;
    
    
    return 0;
}

头文件和头文件编译起来比较慢

三、密码脱落（区间dp）

任意门
最少添加几个字母得到回文串。（答案也等于最少删除几个变成回文串）

其长度也就是：总长度-最长回文子串的长度
有一个做法就是把这个字符串反过来，来找到一个最长公共子序列

#include <cstdio>
#include <string.h>

const int N = 1010;

char s[N];
int f[N][N];

int main()
{
    scanf("%s", s);
    int n = strlen(s);

    for (int len = 1; len <= n; len ++ )
        for (int l = 0; l + len - 1 < n; l ++ )
        {
            int r = l + len - 1;
            if (len == 1) f[l][r] = 1;
            else
            {
                if (s[l] == s[r]) f[l][r] = f[l + 1][r - 1] + 2;
                if (f[l][r - 1] > f[l][r]) f[l][r] = f[l][r - 1];
                if (f[l + 1][r] > f[l][r]) f[l][r] = f[l + 1][r];
            }
        }

    printf("%d\n", n - f[0][n - 1]);

    return 0;
}

四、生命之树（树形dp）

任意门

给我们一个树，然后我们再来求最大连通块。
树形dp一般都是用递归来做
f[u]是以u为根节点的子树，包含u的所有连通块的权值最大值。
i！=-1等价于~i

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010, M = N * 2;

int n;
int w[N];
int h[N], e[M], ne[M], idx;
LL f[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u, int father)
{
    f[u] = w[u];
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j != father)
        {
            dfs(j, u);
            f[u] += max(0ll, f[j]);
        }
    }
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }

    dfs(1, -1);

    LL res = f[1];
    for (int i = 2; i <= n; i ++ ) res = max(res, f[i]);

    printf("%lld\n", res);

    return 0;
}

---

五、 斐波那契前 n 项和（矩阵乘法，快速幂）

任意门

复杂度是$O（logn）$

#include<bits/stdc++.h>

using namespace std;
const int N=3;
int n,m;

void mul(int c[],int a[],int b[][N])
{
    int temp[N]={0};//临时数组，防止冲突
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
            temp[i]=(temp[i]+(long long)a[j]*b[j][i])%m;
            memcpy(c,temp,sizeof temp);//不能用传进来的数
            //只能用全局变量或者是局部变量
}

void mul(int c[][N],int a[][N],int b[][N])
{
    int temp[N][N]={0};
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
        for(int k=0;k<N;k++)
        temp[i][j]=(temp[i][j]+(long long)a[i][k]*b[k][j])%m;
    memcpy(c,temp,sizeof temp);
}
int main()
{
    cin>>n>>m;
    int f1[N]={1,1,1};//起始状态
    int a[N][N]={//A矩阵
    {0,1,0},
    {1,1,1},
    {0,0,1}
    };
    n--;
    while(n)
    {
        if(n&1)mul(f1,f1,a);//res=res*a
        mul(a,a,a);//a=a*a
        n>>=1;//n除以2
    }
    cout<<f1[2]<<endl;
    return 0;
}

六、包子凑数（完全背包问题）

任意门
我们可以根据前面所学到的一个数论知识来推导。
（a,b）=x，然后如果(a,b,c,d,e,f…)==1，那么他就可以表达任意数。

（a,b）=d(d是他们的最小公约数）
ax+by=d

大佬！
枚举1~10000之间就可以了。
完全背包：
f[i][j],前i个，总和为j
属性：集合是否非空

这就是式子的推导如果最后推出来的f的第一个数是i，那他就是完全背包，否则就是01背包。这是他们唯一的区别。

二维朴素写法

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int a[110];
bool f[110][N];

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    int n;
    scanf("%d", &n);
    int d = 0;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &a[i]);
        d = gcd(d, a[i]);
    }

    if (d != 1) puts("INF");
    else
    {
        f[0][0] = true;
        for (int i = 1; i <= n; i ++ )
            for (int j = 0; j < N; j ++ )
            {
                f[i][j] = f[i - 1][j];
                if (j >= a[i]) f[i][j] |= f[i][j - a[i]];
            }

        int res = 0;
        for (int i = 0; i < N; i ++ )
            if (!f[n][i])
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

优化完空间之后的写法

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int a[110];
bool f[N];

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    int n;
    scanf("%d", &n);
    int d = 0;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &a[i]);
        d = gcd(d, a[i]);
    }

    if (d != 1) puts("INF");
    else
    {
        f[0] = true;
        for (int i = 1; i <= n; i ++ )
            for (int j = a[i]; j < N; j ++ )//如果是01背包，我们就从后面开始
                f[j] |= f[j - a[i]];

        int res = 0;
        for (int i = 0; i < N; i ++ )
            if (!f[i])
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

七、括号配对（区间dp）

任意门

大佬！
我是看这个大佬写的我才弄懂！
f[l][r]表示从l~r凑成一个合法字符串，至少应该加多少个

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 110, inf = 0x3f3f3f3f;

char s[N];
int f[N][N]; // f[i][j]代表将i~j个字符变成GBE的所有方案的集合的最小值

bool check(int a, int b)
{
    if (s[a] == '[' && s[b] == ']' || s[a] == '(' && s[b] ==')') return true;
    return false;
}

int main()
{
    scanf("%s", s + 1);
    int n = strlen(s + 1);

    for (int len = 1; len <= n; len++)//区间dp循环第一层
        for (int l = 1; l + len - 1 <= n; l++)
        {
            int r = l + len - 1;
            if (len == 1) f[l][r] = 1;
            else
            {
                f[l][r] = inf;
                if (check(l, r)) f[l][r] = min(f[l][r], f[l + 1][r - 1]);
                for (int k = l; k <= r; k++)
                    f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
            }
        }

    cout << f[1][n] << endl;

    return 0;
}

八、旅游规划

任意门
我们想要求最大的点的话，那我们只需要对每一点求一个最大值和次大值即可。
大佬！！
1、先通过树形dp求出每个点往下走的最大长度和次大长度，并且更新整棵树的最大路径ans

2、枚举每一个结点i，设该点的最大长度是d1[i]，次大长度是d2[i]，若d1[i] + d2[i] == ans，表示最大路径是从该点得出的，通过dfs2找到最大长度的路径，dfs3找到次大长度的路径，并对路径的点进行标记

时间复杂度$O（n）$

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 200010, M = N * 2;

int n;
int h[N], e[M], ne[M], idx;
int d1[N], d2[N], p1[N], up[N];//p1存下u节点往下最大路走的子节点，up存下u节点往上走的最长路径
int maxd;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs_d(int u, int father)//dfs一下往下走的路径的次大值和最大值
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != father)
        {
            dfs_d(j, u);
            int distance = d1[j] + 1;
            if (distance > d1[u])//更新最大值和次大值
            {
                d2[u] = d1[u], d1[u] = distance;
                p1[u] = j;
            }
            else if (distance > d2[u]) d2[u] = distance;
        }
    }

    maxd = max(maxd, d1[u] + d2[u]);
}

void dfs_u(int u, int father)//我们要保留一下往上走的最小路
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != father)
        {
            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()
{
    scanf("%d", &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);
    }

    return 0;
}

九、垒骰子（线性dp，矩阵乘法）

任意门

大佬！

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 6, P = 1e9 + 7;

int n, m;
int op[] = {3, 4, 5, 0, 1, 2};
bool st[N][N];

void mul(int c[], int a[], int b[][N])
{
    int temp[N] = {0};
    for (int i = 0; i < N; i ++ )
    {
        for (int j = 0; j < N; j ++ )
        {
            temp[i] = (temp[i] + (LL)a[j] * b[j][i]) % P;
        }
    }
    memcpy(c, temp, sizeof(temp));
}

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N] = {0};
    for (int i = 0; i < N; i ++ )
    {
        for (int j = 0; j < N; j ++ )
        {
            for (int k = 0; k < N; k ++ )
            {
                temp[i][j] = (temp[i][j] + (LL)a[i][k] * b[k][j]) % P;
            }
        }
    }

    memcpy(c, temp, sizeof(temp));
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < m; i ++ )
    {
        int a, b;
        cin >> a >> b;
        st[a - 1][b - 1] = st[b - 1][a - 1] = true;
    }

    int f1[N] = {4, 4, 4, 4, 4, 4};
    int a[N][N];
    for (int i = 0; i < N; i ++ )
    {
        for (int j = 0; j < N; j ++ )
        {
            if (st[j][op[i]]) a[j][i] = 0;
            else a[j][i] = 4;
        }
    }

    n -- ;
    while(n)
    {
        if (n & 1) mul(f1, f1, a);
        mul(a, a, a);
        n >>= 1;
    }

    int res = 0;
    for (int i = 0; i < N; i ++ )
    {
        res = (res + f1[i]) % P;
    }
    cout << res;

    return 0;
}