【动态规划1】动态规划的引入

最新推荐文章于 2024-07-19 15:45:46 发布
最新推荐文章于 2024-07-19 15:45:46 发布
阅读量189 收藏
点赞数
文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43154149/article/details/105330194
版权

文章目录

前言

动态规划是一种重要的思维方法，通过利用已有的子问题信息高效求出当前问题的最优解。

题单地址：https://www.luogu.com.cn/training/211#problems

P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles（入门题）

思路：动态规划 a + b 题，分别有从上到下DP(需要遍历最大值)和从下到上DP（唯一），不说了，直接上代码。
状态转移：在这里插入图片描述

// 从上到下DP
#include <iostream>

using namespace std;

const int N = 510, INF = 1e9;

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

int main()
{
    cin>>n;
    
    for (int i = 1; i <= n;i ++ ) 
        for(int j = 1; j <= i;j ++ )
            cin >> a[i][j];
            
    for (int i = 1;i <= n;i ++ )
        for(int j = 0;j <= i + 1; j ++ )   // 多初始化边界
            f[i][j] = -INF;
    
    f[1][1] = a[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] + a[i][j], f[i - 1][j] + a[i][j]);
    
    int res = -INF;
    for (int i = 1; i <= n; i ++ ) res = max(res, f[n][i]);
    
    cout << res << endl;
        
    return 0;
}

// 从下到上DP
#include <iostream>

using namespace std;

const int N = 510, INF = 1e9;

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

int main()
{
    cin >> n;
    for(int i =1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin >> a[i][j];
            
    for(int i =1;i<=n;i++)
        for(int j=1;j<=i;j++)
            if(i==n) f[i][j] = a[i][j];   // 初始化
            else f[i][j]=-INF;
            
    for(int i=n-1;i>=1;i--)
        for(int j=1;j<=i;j++)
            f[i][j]=max(f[i+1][j],f[i+1][j+1]) + a[i][j];
            
    cout<<f[1][1]<<endl;
    
    return 0;
    
    
}
P1434 [SHOI2002]滑雪（记忆化搜索）

思路：状态转移条件：w[x][y] > w[a][b]

#include <iostream>

using namespace std;

const int N = 110;

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

int dx[4]={-1,0,1,0}, dy[4] = {0,1,0,-1};

int dfs(int x,int y)
{
    if(f[x][y]) return f[x][y];
    f[x][y]=1;
    for(int i=0;i<4;i++)
    {
        int a=x +dx[i],b=y + dy[i];
        
        if(a>=1 && a<=n && b>=1 && b<=m)
        {
            if(w[x][y] > w[a][b])
            {
                dfs(a,b);
                f[x][y] = max(f[x][y],f[a][b] + 1);
            }
        }
    }
    return f[x][y];
}

int main()
{
    cin >> n >> m;
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            cin >> w[i][j];
    
    
    int res=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            res=max(res,dfs(i,j));
    
    
    cout<<res<<endl;
    
    return 0;
}
P2196 挖地雷(DP,记忆化搜索)

思路：本题需要额外记录路径，记录路径的常用方法：开一个pre[]前缀数组，记录当前状态是由哪个状态转移过来的，下面给出正推，逆推，记忆化搜索的代码
状态转移条件：g[i][j] == 1 ,表示i与j直接存在边

代码1（正推，需要缓存数组）

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

using namespace std;

const int N = 25;

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

int main()
{
    cin >> n;
    
    for(int i=1;i<=n;i++) cin >> a[i],f[i] = a[i];
    
    for(int i=1;i<=n-1;i++)
        for(int j=i+1;j<=n;j++)
            cin >> g[i][j];
    
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
        {
            if(g[i][j]) // 当g[i][j] == 1时，状态转移 f[j] = f[i] + a[j];
            {
                if(f[j] < f[i] + a[j])
                {
                    f[j] = f[i] + a[j];
                    pre[j] = i; // 记录前缀
                }
                //f[j] = max(f[j],f[i] + a[j]);
            }
        }
        
    // 以下是输出*************************************************
    int t =0; // 记录最大值的下标
    for(int i=1;i<=n;i++) 
        if(f[t] < f[i])
        {
            t=i;
        }
    int ans = f[t];

    // 正着推需要缓存，倒着推会比较好
    vector<int> res;
    while(pre[t] != 0)
    {
        res.push_back(t);
        t = pre[t];
    }
    res.push_back(t);
    reverse(res.begin(),res.end());
    
    for(int i=0;i<res.size();i++) cout<<res[i]<<" ";
    cout<<endl;
    cout<<ans;
   
    
    return 0;
}

代码2（逆推）

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

using namespace std;

const int N = 25;

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

int main()
{
    cin >> n;
    
    for(int i=1;i<=n;i++) cin >> a[i],f[i] = a[i];
    
    for(int i=1;i<=n-1;i++)
        for(int j=i+1;j<=n;j++)
            cin >> g[i][j],g[j][i] = g[i][j];// 无向边，倒着搜需要用到
    
    // 倒着搜比较好回溯路径
    for(int i=n;i>=1;i--)
        for(int j=i-1;j>=1;j--)
        {
            if(g[i][j]) // 当g[i][j] == 1时，状态转移 f[j] = f[i] + a[j];
            {
                if(f[j] < f[i] + a[j])
                {
                    f[j] = f[i] + a[j];
                    pre[j] = i; // 记录前缀
                }
                //f[j] = max(f[j],f[i] + a[j]);
            }
        }
        
    // 以下是输出*************************************************
    int t =0; // 记录最大值的下标
    for(int i=1;i<=n;i++) 
        if(f[t] < f[i])
        {
            t=i;
        }
    int ans = f[t];

    // 正着推需要缓存，倒着推会比较好,以下是倒着搜就不用缓存
    vector<int> res;
    while(pre[t] != 0)
    {
        cout<<t<<" ";
        t=pre[t];
    }
    cout<<t<<endl; 
    
    cout<<ans;
   
    
    return 0;
}

代码3（记忆化搜索）

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

using namespace std;

const int N = 25;

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

int dfs(int u) // 返回这个点能挖到地雷的数量
{
    if(f[u]) return f[u]; // 记忆化搜索
    f[u] = a[u];
    
    int maxv = 0;
    for(int i = u + 1;i <= n; i ++ )
        if(g[u][i]) 
        {
            if(dfs(i) > maxv)
            {
                maxv = dfs(i);
                ne[u] = i;
            }
            //maxv = max(maxv,dfs(i)); // 取最大
        }

    f[u] += maxv;
    
    return f[u];
}

int main()
{
    cin >> n;
    
    for(int i=1;i<=n;i++) cin >> a[i];
    
    for(int i=1;i<=n-1;i++)
        for(int j=i+1;j<=n;j++)
            cin >> g[i][j];
    
    int res=0,t=-1;
    for(int i=1;i<=n;i++)
    {
        if(res < dfs(i))
        {
            res = dfs(i);
            t = i;
        }
    }
    while(ne[t] != t)
    {
        cout<<t<<" ";
        t = ne[t];
    }
    cout<<endl;
    cout<<res<<endl;
   
    return 0;
}
P4017 最大食物链计数(DP,拓扑排序)

思路：状态转移：对于t的所有出边j ，f[j] = (f[t] + f[j]) % mod
不说了，拓扑排序模板学一手好吧

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>

using namespace std;

const int N = 500010, mod = 80112002;

int n,m;
int h[N],e[N],ne[N],idx;
int d[N],out[N]; // 记录每个点的入度,出度
int f[N]; // 到这个点的食物链条数

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

void topsort()
{
    queue<int> q;
    
    // 寻找入度为0的点，生产者
    for(int i=1;i<=n;i++)
        if(d[i] == 0)
        {
            q.push(i);
            f[i] = 1;
        }
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        
        for(int i=h[t];i!=-1;i=ne[i]) // 遍历所有出边
        {
            int j = e[i];
            d[j] --;
            f[j] = (f[t] + f[j]) % mod; // 状态转移
            if(d[j] == 0) q.push(j);
        }
    }
}

int main()
{
    
    memset(h,-1,sizeof h); // 记得初始化头结点
    scanf("%d%d",&n,&m);
    
    int a,b;
    while(m--)
    {
        scanf("%d%d",&a,&b);
        add(a,b);
        d[b] ++ ;
        out[a] ++ ;
    }
    
    topsort(); // 忘记调用了~~
    
    int res=0;
    for(int i=1;i<=n;i++)
        if(out[i] == 0) res = (res + f[i]) % mod;  // 出度为0的点为消费者
    
    printf("%d\n",res);
    return 0;
}
P1048 采药(01背包)

思路：01背包裸题，时间看成体积。
这里提供一个优化空间后的写法，注意体积从大到小循环，与下文完全背包区别。

#include <iostream>

using namespace std;

const int N = 100010;

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

int main()
{
    cin >> m >> n;
    
    for(int i=1;i<=n;i++) cin >> v[i] >> w[i];
    
    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]);
            
    cout<<f[m];
}
P1616 疯狂的采药(完全背包)

思路：完全背包裸题，同样这里提供一种优化空间之后的写法，体积从小到大循环（完全背包比较特别，可特殊记忆，一般来说优化空间都是利用滚动数组优化，体积从大到小。）

#include <iostream>

using namespace std;

const int N = 100010;

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

int main()
{
    cin >> m >> n;
    
    for(int i=1;i<=n;i++) cin >> v[i] >> w[i];
    
    for(int i=1;i<=n;i++)
        for(int j=v[i];j<=m;j++)   // 只有这里与01背包不同
            f[j] = max(f[j],f[j-v[i]] + w[i]);
            
    cout<<f[m];
}
P1802 5倍经验日(01背包变形)

思路：在这里插入图片描述

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 1010;

int n,m;
int lose[N],win[N],use[N];
int f[N];


int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++) cin >> lose[i] >> win[i] >> use[i];
    
    for(int i=1;i<=n;i++)
    {
        // j >= use[i],有两种选择
        for(int j=m;j>=use[i];j--) f[j] = max(f[j-use[i]] + win[i],f[j] + lose[i]);  // 如果够药水，有两种选择
        // j < use[i]，一种选择
        for(int j = use[i]-1;j>=0;j--) f[j] += lose[i];
    }
    //cout<<f[x] * 5 <<endl;
    printf("%lld",5ll * f[m]); // 爆int
   
    return 0;
}
P1002 过河卒(DP,递推)

思路：状态表示f[i][j] : 从起点(0,0)到(i,j)的路径条数；状态计算：f[i][j] = f[i-1][j] + f[i][j-1]

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 25;

int n,m,x,y;
long long f[N][N];
bool use[N][N]; // 马控制的点

int dx[8]={-1,-2,-2,-1,1,2,2,1}, dy[8]={-2,-1,1,2,2,1,-1,-2};

int main()
{
    cin >> n >> m >> x >> y;
    
    use[x][y] = true; 
    for(int i=0;i<8;i++)
    {
        int a=x + dx[i], b = y + dy[i];
        use[a][b] = true;
    }
    
    f[0][0]=1;
    for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++)
        {
            if(i) f[i][j] += f[i-1][j];
            if(j) f[i][j] += f[i][j-1];
            if(use[i][j]) f[i][j] = 0;  // 控制点不能走
        }
    
    printf("%lld",f[n][m]); // 爆int
    
    return 0;
}

优化空间之后的写法（滚动数组优化，直接删去第一维）
在这里插入图片描述

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 25;

int n,m,x,y;
long long f[N];
bool use[N][N]; // 马控制的点

int dx[8]={-1,-2,-2,-1,1,2,2,1}, dy[8]={-2,-1,1,2,2,1,-1,-2};

int main()
{
    cin >> n >> m >> x >> y;
    
    use[x][y] = true; 
    for(int i=0;i<8;i++)
    {
        int a=x + dx[i], b = y + dy[i];
        use[a][b] = true;
    }
    
    f[0]=1;
    for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++)
        {
            if(j) f[j] += f[j-1];
            if(use[i][j]) f[j] = 0;  // 控制点不能走
        }
    
    printf("%lld",f[m]); // 爆int
    
    return 0;
}
接深度学习联系丝信
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划考题1
08-08
接下来，引入了状态转移方程和递推关系式，这是动态规划的核心部分。状态转移方程`xk+1 = xk - uk`描述了从当前状态k到下一个状态k+1的转换，即剩余投资金额在投资给项目k后减少。递推关系式`fk(xk) = max{uk∈Dk(xk...
【动态规划1】动态规划的引入 全部AC
mrcrack的博客
12-02 210
【动态规划1】动态规划的引入 P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles
动态规划的引入1
weixin_45218241的博客
01-04 1023
一、动态规划的引入 之前学习过一段时间的动态规划，但掌握的不够牢固，实际做题时还是不能灵活的运用，所以打算在寒假对这部分知识进行学习和巩固，按照洛谷的提单分为五个部分进行学习： 1.动态规划的引入 2.线性状态动态规划 3.区间与环形动态规划 4.树与图上的动态规划 5.状态压缩动态规划 本文题目选自第一部分的练习内容 题目：过河卒 题目内容：棋盘上 AA 点有一个过河卒，需要走到目标 BB 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 CC 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对
洛谷题单：【动态规划1】动态规划的引入
qq_43751506的博客
03-27 346
（1）P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles 很简单的一道动态规划入门题，即一直取上面一行最大值再加上本身，dp方程为dp[i][j]=dp[i-1][j]+dp[i-1][j-1]. import java.io.BufferedReader; import java.io.IOException; import java.io.Input...
洛谷 【动态规划1】动态规划的引入
weixin_43975891的博客
06-06 346
题单 P1216 数字三角形 Number Triangles 代码 #include<iostream> #include<algorithm> using namespace std; int r; int arr[1010][1010],dp[1010][1010]; int main(){ cin>>r; //输入 for(int i=0;i<r;i++){ for(int j=0;j<=i;j++){ cin>>arr[
洛谷题单——动态规划的引入
chineseherofeng的博客
06-25 157
前言：好久没做dp，又变菜了。。。 数字三角形 Number Triangles 思路：由题很容易可以看出状态转移方程：dp[i][j]=cnt[i][j]+max(cnt[i+1][j],cnt[i+1][j+1]). ac代码： #include <iostream> #include <algorithm> #include <cstdio> #include <cstring> #include <cmath> using namespac
动态规划之队列优化1
08-03
在本题“动态规划之队列优化1”中，主要涉及到的问题是求解锯木场选址以最小化运输费用。这个问题可以通过动态规划的方法进行优化。 问题描述：在一条直线上的 n 棵树需要被砍倒并运送到锯木厂，运输只能朝山下。...
强化学习-动态规划-DP1
08-03
在强化学习中，动态规划（Dynamic Programming, DP）是一种用于解决马尔科夫决策过程（Markov Decision Process, MDP）的重要方法。DP主要用于找出最优策略以及对应的最优价值函数。本节主要关注两种动态规划算法：...
动态规划详细介绍.zip
03-25
为了解决这个问题，动态规划引入了“记忆化”或者“备忘录”策略。这个策略的基本思想是在第一次解决某个子问题时，将其结果存储起来，当后续再次遇到相同子问题时，直接查找存储的结果，避免重复计算。这种方法显著...
背包问题动态规划 ).zip
11-20
【背包问题动态规划】是一种经典的计算机算法，常用于解决资源有限条件下的优化问题。在毕业设计中，这个主题是一个很好的选择，因为它不仅涉及到基础的编程技术，还涵盖了算法设计与分析，这对于提升对复杂问题解决...
洛谷题单——【动态规划1】动态规划的引入
weixin_53364209的博客
03-27 1558
嘤，看洛谷的大佬都用的C++刷题，本蒟蒻花了三天时间用Java刷完了洛谷的【动态规划1】动态规划的引入题单，有的题目尚有一两个测试点TLE或者MLE，还待优化。。。 1.[USACO1.5][IOI1994]数字三角形 Number Triangles 2.[SHOI2002]滑雪 3.[NOIP1996 提高组] 挖地雷 4.最大食物链计数 5.[NOIP2005 普及组] 采药 6.疯狂的采药 7.5 倍经验日 8.[NOIP2002 普及组] 过河卒 ...
动态规划的引入--数据结构与算法之美--CH40
CSDN_SUSAN的博客
11-20 287
文章目录1. 什么是动态规划2. 再看0-1背包问题2.1 递归回溯算法2.2 递归回溯+备忘录2.3 动态规划算法3. 升级版 0-1背包问题3.1 递归回溯算法3.2 动态规划求解4. 动态规划空间复杂度再优化4.1 普通 0-1 背包问题优化4.2 升级版 0-1 背包问题优化4.3 哨兵优化 1. 什么是动态规划   在CH39讲回溯算法谈到回溯算法本质是枚举所有可能的路径，然后求取可行解...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1136
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 216
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
最新发布
Atticus的博客
07-19 279
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
排序思想-快排
m0_58257626的博客
07-17 338
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 250
完全二叉树的节点个数-递归
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 279
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
24暑假算法刷题 | Day15 | LeetCode 110. 平衡二叉树，257. 二叉树的所有路径，404. 左叶子之和，222. 完全二叉树的节点个数
weixin_54468359的博客
07-17 1144
day15打卡：二叉树的递归与迭代
状态压缩动态规划详解与优化技术
"第4章 状态压缩类动态规划-2021.08.25(B).pdf" 状态压缩类动态规划，也称为集合动态规划，是一种在处理特定类型问题时优化状态表示的技术。这种技术主要应用于那些状态空间巨大但某一维度或几维度的数据规模较小的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值