动态规划.

背包

01背包acwing2

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

using namespace std;

const int N = 1010;

int v[N], w[N], f[N][N];


int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d%d", &v[i], &w[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = 0; j <= m; j ++ ){
            f[i][j] = f[i - 1][j];
            if(j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }
    printf("%d", f[n][m]);
}

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

using namespace std;

const int N = 1010;

int v[N], w[N], f[N];


int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d%d", &v[i], &w[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = m; j >= 0; j -- ){
            if(j >= v[i]) f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    printf("%d", f[m]);
}

acwing3完全背包问题

未优化版，超时

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

using namespace std;

const int N = 1010;
int v[N], w[N], f[N][N];



int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; i ++ ) scanf("%d%d", &v[i], &w[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = 0; j <= m; j ++ ){
            for (int k = 0; k * v[i] <= j; k ++ ){
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    printf("%d", f[n][m]);
}

优化版

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

using namespace std;

const int N = 1010;
int v[N], w[N], f[N][N];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; i ++ ) scanf("%d%d", &v[i], &w[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = 0; j <= m; j ++ ){
            f[i][j] = f[i - 1][j];
            if(j >= v[i])f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
        }
    }
    printf("%d", f[n][m]);
    
}

再度优化

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

using namespace std;

const int N = 1010;
int v[N], w[N], f[N];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; i ++ ) scanf("%d%d", &v[i], &w[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = v[i]; j <= m; j ++ ){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    printf("%d", f[m]);
}

acwing4多重背包1

跟完全背包问题一样，不过多了数量限制

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

using namespace std;

const int N = 110;
int v[N], w[N], s[N], f[N][N];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d%d%d", &v[i], &w[i], &s[i]);
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循环体积
        for (int j = 0; j <= m; j ++ ){
            f[i][j] = f[i - 1][j];
            //循环决策
            for (int k = 0; k <= s[i] && k * v[i] <= j; k ++ ){
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    printf("%d", f[n][m]);
}

acwing5多重背包2

如果仍然不是很能理解的话，取这样一个例子:要求在一堆苹果选出n个苹果。我们传统的思维是一个一个地去选，选够n个苹果就停止。这样选择的次数就是n次
二进制优化思维就是：现在给出一堆苹果和10个箱子，选出n个苹果。将这一堆苹果分别按照1,2,4,8,16,…512分到10个箱子里，那么由于任何一个数字x ∈[1,1024]
都可以从这10个箱子里的苹果数量表示出来，但是这样选择的次数就是 ≤10次 。

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

using namespace std;

const int N = 12010, M = 2010;
int v[N], w[N];
int f[M];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    int cnt = 0;
    for (int i = 1; i <= n; i ++ ){
        int a, b, s;
        scanf("%d%d%d", &a, &b, &s);
        int k = 1;
        while (k <= s){
            cnt ++;
            v[cnt] = a * k;
            w[cnt] = b * k;
            s -= k;
            k *= 2;
        }
        if(s > 0){
            cnt ++;
            v[cnt] = a * s;
            w[cnt] = b * s;
        }
    }
    n = cnt;
    for (int i = 1; i <= n; i ++ ){
        for (int j = m; j >= v[i]; j -- ){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    printf("%d", f[m]);
    
}

awing9分组背包

跟完全背包很像
循环物品组，循环体积， 循环物品

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

using namespace std;

const int N = 110;
int v[N][N], w[N][N], s[N];
int f[N][N];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; i ++ ){
        scanf("%d", &s[i]);
        for (int j = 1; j <= s[i]; j ++ ){
            scanf("%d%d", &v[i][j], &w[i][j]);
        }
    }
    
    //循环物品组
    for (int i = 1; i <= n; i ++ ){
        //循坏体积
        for (int j = 0; j <= m; j ++ ){
            f[i][j] = f[i - 1][j];
            //循环组内的物品
            for (int k = 0; k <= s[i]; k ++ ){
                if(j >= v[i][k]) f[i][j] = max(f[i][j], f[i - 1][j - v[i][k]] + w[i][k]);
            }
        }
    }
    printf("%d", f[n][m]);
}

线性dp

acwing898数字三角形

状态表示：f[i][j]表示从顶层走到第i行第j列的最大值
状态转移：
右上：f[i][j] = max(f[i][j], f[i-1][j]+w[i][j])
左上：f[i][j]= max(f[i][j], f[i-1][j -1] + w[i][j])

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

using namespace std;

const int N = 510;

int w[N][N], f[N][N];

int main(){
    int n;
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++ ){
        for (int j = 1; j <= i; j ++ ){
            scanf("%d", &w[i][j]);   
        }
    }
    
    //处理负数
    memset(f, -0x3f, sizeof f);
    f[1][1] = w[1][1];
    for (int i = 2; i <= n; i ++ ){
        for (int j = 1; j <= i; j ++ ){
            f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + w[i][j];
        }
    }
    
    int res = -0x3f3f3f3f;
    for (int i = 1; i <= n; i ++ ){
        res = max(res, f[n][i]);
    }
    
    printf("%d", res);
}

acwing895最长上升子序列

状态表示：
f[i]表示以a[i]结尾的最长上升子序列
状态转移：
$f[i]=max(f[i],f[j]+1)(a[j]<a[i],j\in [1,i-1])$

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

using namespace std;

const int N = 1e3 + 10;
int a[N], f[N];

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) {
        scanf("%d", &a[i]);
        f[i] = 1;
    }
    int res = 0;
    for (int i = 1; i <= n; i ++ ){
        for (int j = 1; j < i; j ++ ){
            if(a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
        }
        res = max(res, f[i]);
    }
    printf("%d", res);
}

acwing896最长上升子序列2

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

using namespace std;

const int N = 1e5 + 10;
int a[N], q[N];


int main(){
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    
    int len = 0;
    q[0] = -2e9;
    for (int i = 1; i <= n; i ++ ){
        //找a[i]的前驱
        int l = 0, r = len;
        while (l < r){
            int mid = l + r  + 1 >> 1;
            if(q[mid] < a[i]) l = mid; else r = mid - 1;
        }
        q[l + 1] = a[i];
        len = max(len, l + 1);
    }
    printf("%d", len);
}

最长公共子序列

状态表示：
f[i][j]表示字符串以a中前i个字母字符串b中以前j个字母组成的最长公共子序列的长度
状态转移：
可分为2种情况：

• a[i]==b[i]
  如a:zxc,b:zxc,f[i][j]=f[i-1][j-1]+1
• a[i]!=b[i]
  如a:zxvc b:zxc,f[i][j]=f[i-1][j]或f[i][j-1]

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

using namespace std;
const int N = 1010;

int f[N][N];
char a[N], b[N];

int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    scanf("%s%s", a + 1, b + 1);
    
    for (int i = 1; i <= n; i ++ ){
        for (int j = 1; j <= m; j ++ ){
            if(a[i] == b[j]) f[i][j] = f[i - 1][j - 1] + 1;
            else f[i][j] = max(f[i - 1][j], f[i][j - 1]);
        }
    }
    printf("%d", f[n][m]);
}

acwing902

状态表示：
f[i][j]：把a中的前i个字母变为b中的前j个字母的最少操作数
状态转移：
对当前的a[i]，有4种操作

• 添加，如a：g b：gh，则f[i][j]=f[i][j-1]+1，因为a的前i个已经和b的前j-1个相同
• 删除，如a：hkl b：hk，则f[i][j]=f[i-1][j] + 1，说明没有删除前a中前i-1已经和b的前j个相同
• 替换，如a:hj b：hk，则f[i][j]=f[i-1][j-1]+1，a中前i-1已经和b的前j-1个相同
• 什么都不做（摆烂），如a：ukl b：ukl，f[i][j]=f[i-1][j-1],a中第i个字母和b中第j个字母相同且前i-1，j-1也相同

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

using namespace std;

const int N = 1010;

char a[N], b[N];
int f[N][N];

int main(){
    int n, m;
    scanf("%d", &n);
    scanf("%s", a + 1);
    scanf("%d", &m);
    scanf("%s", b + 1);
    
    int f[N][N];
    
    //若a长度为i，b长度为0，则需要进行i次删除操作
    for (int i = 0; i <= n; i ++ ) f[i][0] = i;
    //若a长度为0，b长度为i，则需要进行i次添加操作
    for (int i = 0; i <= m; i ++ ) f[0][i] = i;
    
    for (int i = 1; i <= n; i ++ ){
        for (int j = 1; j <= m; j ++ ){
            f[i][j] = min(f[i-1][j] + 1, f[i][j-1] + 1);
            if(a[i] == b[j]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }
    }
    printf("%d", f[n][m]);
}

区间dp

acwing282

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

using namespace std;

const int N = 310;

int f[N][N], s[N];

int main(){
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    
    //区间dp模板，枚举长度，枚举左右端点，枚举决策
    //只有1堆时不用合并，代价为0
    for (int len = 2; len <= n; len ++ ){
        //i是左端点,j是右端点，注意len是石头堆数，所以j=i+len-1
        for (int i = 1; i + len - 1 <= n; i ++ ){
            int j = i + len - 1;
            f[i][j] = 1e9;
            //以第k堆石头为分界线，要把石头分成两堆，所以k最大为j-1
            for (int k = i; k < j; k ++ ){
                 f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);       
            }
        }
    }
    //根据f[i][j]的定义，从第1堆合并到第n堆石头的代价的最小值
    cout << f[1][n];
}

计数类dp

acwing900

思路：把1，2，3，… ，n看做背包问题的物品，这n个物品使用次数无限制，问恰好能装满总体积为n的背包的总方案数
状态表示：f[i][j]表示前i个物品体积恰好是j的方案数

状态转移：f[i][j]= f[i-1][j] + f[i - 1][j - i]

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

using namespace std;
typedef long long LL;

const int N = 1010, mod = 1e9 + 7;

int f[N][N];

int main(){
    int n;
    scanf("%d", &n);
    
    //容量为0时，前 i 个物品全不选也是一种方案
    for (int i = 0; i <= n; i ++) {
        f[i][0] = 1; 
    }
    
    //循环物品
    for (int i = 1; i <= n; i ++ ){
        //循坏体积
        for (int j = 0; j <= n; j ++ ){
            f[i][j] = f[i - 1][j] ;
            if(j >= i) f[i][j] = ((LL)f[i][j] + f[i][j - i]) % mod;
        }
    }
    printf("%d", f[n][n]);
}

状态压缩dp

acwing291

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

using namespace std;

const int N = 12, M = 1 << N;

typedef long long LL;

//f[i][j], 前i-1列已经摆好，且从第i-1列伸到第i列的所有方案
//j是个二进制数，表示哪一行的方块是横着放的
LL f[N][M];
//记录该列连续的0有奇数个还是偶数个
bool st[M];
vector<int> state[M];

int main()
{
    int n, m;
    while (true){
        scanf("%d%d", &n, &m);
        if(n == 0 || m == 0) break;

        //预处理1，每一列不能有奇数个连续的0
        for (int i = 0; i < 1 << n; i ++ ){
            //连续的0的个数
            int cnt = 0;    
            bool isValid = true;
            //遍历i的二进制表示下的每一位,从上到下
            for (int j = 0; j < n; j ++ ){
                //当前位置为1
                if(i >> j & 1 == 1){
                    //当前位置之前连续0的个数如果为奇数，不合法
                    if(cnt & 1 == 1){
                        isValid = false;
                        break;
                    }
                    //1之前有偶数个零,合法，重置计数器
                    cnt = 0;
                } else cnt ++;
            }
            //判断最下面连续0的情况
            if(cnt & 1 == 1) isValid = false;
            st[i] = isValid;
        }

        //预处理2，判断第i-2列和第i-1列伸出的是否冲突
        for (int j = 0; j < 1 << n; j ++ ){
            //清空的是上一个输入的数据的状态
            state[j].clear();
            for (int k = 0; k < 1 << n; k ++ ){
                if((j & k) == 0 && st[j | k]){
                    state[j].push_back(k);
                }
            }
        }

        //dp开始
        //清空的是上一个输入的数据的状态
        memset(f, 0, sizeof f);
        f[0][0] = 1;

        for (int i = 1; i <= m; i ++ ){
            for (int j = 0; j < 1 << n; j ++ ){
                for(auto k : state[j]) f[i][j] += f[i - 1][k];
            }
        }

        printf("%lld\n", f[m][0]);
    }

}

树形dp

acwing285

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

using namespace std;

const int N = 6010;

//高兴度
int w[N];
//st标记有没有父节点
int st[N], f[N][2];
//邻接表存树
int e[N], ne[N], h[N], idx;

// 添加一条边a->b
void add(int a, int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

void dfs(int u){
    //此节点去了，至少有自己的高兴度
    f[u][1] = w[u];
    //此节不去，没有高兴度
    f[u][0] = 0;
    for (int i = h[u]; i != -1; i = ne[i] ){
        int j = e[i];
        //由于要用到子节点的信息，先进行递归
        dfs(j);
        //此节点去了，那么它的子节点都不会去
        f[u][1] += f[j][0];
        //此节点不去，子节点去与不去之间选个总高兴度最大的
        f[u][0] += max(f[j][0], f[j][1]);
    }
}

int main()
{

    //初始化邻接表
    idx = 0;
    memset(h, -1, sizeof h);
    
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    
    for (int i = 1; i < n; i ++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);
        //a有父节点了，标记一下
        st[a] = true;
    }
    
    //找根节点
    int root = 1;
    while (st[root]) root++;
    
    dfs(root);
    
    printf("%d", max(f[root][0], f[root][1]));
}