【蓝桥杯算法笔记】简单DP

F.简单DP

基本思想

闫式DP分析法思维导图（动态规划）_说c语言的小岳岳的博客-CSDN博客

（1）状态表示：所有方案的集合的一个属性(最大值/最小值/个数)

集合：一般题目问的要求的是什么，集合的含义就是什么

属性：(最大值/最小值/个数)看求哪一个

如何判断用几维表示？

用数据范围推测状态表示的维度，有的不优化可能会卡空间

（2）状态计算：对称思想（地位等同）在状态计算中很重要。

集合的划分：通过找最后一个不同点（看看最后一个元素）

划分元素子集要满足不重复、不遗漏

（3）初值：初始化初值按照实际含义赋值即可

例题

一、01背包问题

背包模型实际上是一种组合模型，不同选法的最大值一般都可以用背包问题来做。

//二维做法：

#include <iostream>
using namespace std;
const int N=1010;
int main()
{
	int n,m;
	cin>>n>>m;
	int v[N],w[N];
	int f[N][N];
	for(int i=1;i<=n;i++)
	cin>>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]);
			
		}
	}
	cout<<f[n][m]<<endl;
	return 0;
	 
}

//一维优化：
#include <iostream>

using namespace std;

const int N = 1010;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++ )
    {
        int v, w;
        cin >> v >> w;
        for (int j = m; j >= v; j -- )
            f[j] = max(f[j], f[j - v] + w);
    }

    cout << f[m] << endl;

    return 0;
}

二、摘花生

路线模型，按照一定规则走，找这个路线的属性。

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

using namespace std;

const int N = 110;

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

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        cin >> n >> m;
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
                cin >> w[i][j];

        memset(f, 0, sizeof f); //初始化
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
                f[i][j] = max(f[i - 1][j], f[i][j - 1]) + w[i][j];

        cout << f[n][m] << endl;
    }

    return 0;
}

三、最长上升子序列

线性模型。

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int a[N];
int f[N];

int main()
{
    cin >> n ;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];

    int res = 0;
    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1; //相当于初始化
        for (int j = 1; j < i; j ++ )
            if (a[i] > a[j])  //注意可能为空集，所以要加一个这个限制条件
                f[i] = max(f[i], f[j] + 1);

        res = max(res, f[i]);
    }

    cout << res << endl;

    return 0;
}

四、地宫取宝

摘花生和最长上升子序列的结合

通过数据范围我们可以推出，这个题目的状态大约是4重循环，4个状态量4维，然后状态计算再加一重循环，用于状态转移计算。所以时间复杂度大概是个五重循环。前四重是状态，最后一重是转移。

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

using namespace std;

const int N = 55, MOD = 1000000007;

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 ++ )
        {
            if (i == 1 && j == 1) continue;
            for (int u = 0; u <= k; u ++ )
                for (int v = 0; v <= 13; v ++ )
                {
                    int &val = f[i][j][u][v];
                    val = (val + f[i - 1][j][u][v]) % MOD;
                    val = (val + f[i][j - 1][u][v]) % MOD;
                    if (u > 0 && v == w[i][j])
                    {
                        for (int c = 0; c < v; c ++ )
                        {
                            val = (val + f[i - 1][j][u - 1][c]) % MOD;
                            val = (val + 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 << endl;

    return 0;
}

五、波动数列

背包问题：通过分析可以发现这个题背景是组合模型，所以可以用类似背包模型来做，背包模型的大背景就是组合问题。

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

using namespace std;

const int N = 1010, MOD = 100000007;

int f[N][N];

int get_mod(int a, int b)   // 求a除以b的正余数
{
    return (a % b + b) % b;
}

int main()
{
    int n, s, a, b;
    cin >> n >> s >> a >> b;

    f[0][0] = 1;
    for (int i = 1; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            f[i][j] = (f[i - 1][get_mod(j - a * (n - i), n)] + f[i - 1][get_mod(j + b * (n - i), n)]) % MOD;

    cout << f[n - 1][get_mod(s, n)] << endl;

    return 0;
}