动态规划

最新推荐文章于 2024-08-26 14:50:03 发布
最新推荐文章于 2024-08-26 14:50:03 发布
阅读量233 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frfdogejuruo/article/details/73526480
版权
数据结构 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
树形dp
5 篇文章 0 订阅
订阅专栏
贪心
3 篇文章 0 订阅
订阅专栏

思维量的表达
bzoj1207
类似最长上升子序列
巧妙的想法

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define ll long long 
#define maxn 10005
using namespace std;
inline int read()
{
    int number=0,f=1;
    char ch=0;
    ch=getchar();
    while(ch<'0'||ch>'9' ) {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch<='9'&&ch>='0'){
        number*=10;
        number+=ch-'0';
        ch=getchar();
    }
    return number*f;
}
int n,m;
int x[maxn],y[maxn],t[maxn],f[maxn];
int main()
{
    n=read();
    m=read();
    F(i,1,m){
        f[i]=1;
        t[i]=read();x[i]=read();y[i]=read();
        F(j,1,i-1){
            if(abs(x[i]-x[j])+abs(y[i]-y[j])<=t[i]-t[j])
                f[i]=max(f[i],f[j]+1);
        }

    }
    int maxm=0;
    F(i,1,m) maxm=max(maxm,f[i]);
    printf("%d\n",maxm);
    return 0;
}

bzoj1831
递推
观察到k只有100
不妨把每一个需要填的位置 的所有数字的情况枚举出来
发现其实下一个空可以用上一个空递推
发现其实有个更强的性质
据说填入的数字单调不下降
据说还能处理出前缀最小值
g【i】【j】=min g【i】【1,2,3，……】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define maxn   10005
#define inf   (~0U>>1);
using namespace std; 
inline int read()
{
    int num=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')  {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        num*=10;
        num+=ch-'0';
        ch=getchar();
    }
    return num*f;
 }
 int n,k,cnt,ans=inf;
 int a[maxn],b[maxn],s[maxn][105],f[maxn][105],t[maxn][105],g[maxn][105];
 int main()
 {

    n=read();
    k=read();
    F(i,1,n){
        a[i]=read();
        if(a[i]==-1) b[++cnt]=i;
     }
    F(i,1,n) F(j,1,k) s[i][j]=s[i-1][j]+(a[i]>j);
    D(i,n,1) F(j,1,k) t[i][j]=t[i+1][j]+(a[i]<j&&a[i]!=-1);
    F(i,1,cnt){
        f[i][1]=f[i-1][1]+s[b[i]][1]+t[b[i]][1];
        g[i][1]=f[i][1];
        F(j,2,k){
            f[i][j]=g[i-1][j]+s[b[i]][j]+t[b[i]][j];
            g[i][j]=min(g[i][j-1],f[i][j]);
        }
    }
    F(i,1,k) ans=min(ans,f[cnt][i]);
    F(i,1,n) if(a[i]!=-1)ans+=s[i][a[i]];
    printf("%d\n",ans);
    return 0;
 }

bzoj1084
最大子段和加区间dp
据说枚举上下右端点和数
怀疑

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define maxn   10005
#define inf   (~0U>>1)
#define mod  12345678
using namespace std; 
inline int read()
{
    int num=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')  {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        num*=10;
        num+=ch-'0';
        ch=getchar();
    }
    return num*f;
 }
 int s[101][3],f[101][11],g[101][101][11];
 int n,m,k,ans;
 int main()
 {
    n=read();
    m=read();
    k=read();
    F(i,1,n) F(j,1,m) s[i][j]=s[i-1][j]+read(); 
    if(m==1)
     {
        F(i,1,n) F(j,1,k)
        {
            f[i][j]=f[i-1][j];
            F(l,0,i-1) f[i][j]=max(f[i][j],f[l][j-1]+s[i][1]-s[l][1]);
        }
        printf("%d",f[n][k]);
        return 0;
    } 
    F(i,1,n) F(j,1,n) F(x,1,k){
        g[i][j][x]=max(g[i-1][j][x],g[i][j-1][x]);
        F(y,0,i-1) g[i][j][x]=max(g[y][j][x-1]-s[y][1]+s[i][1],g[i][j][x]);
        F(y,0,j-1) g[i][j][x]=max(g[i][y][x-1]-s[y][2]+s[j][2],g[i][j][x]);
        if(i==j)
        F(l,0,i-1) g[i][j][x]=max(g[l][l][x-1]+s[i][1]+s[j][2]-s[l][1]-s[l][2],g[i][j][x]);
    }
    printf("%d",g[n][n][k]);

 }

bzoj3688
f【上升/下降】【i】【j】
转移用树状数组或线段树
树状数组就好，毕竟单点修改
据说是二十个
纵坐标要离散化
据说是bit优化
奇怪的东西
bit优化原来就是lowbit的树状数组（呵呵）
z注意转移的时候考虑上升和下降的y坐标


f[i][j][0]=∑(f[k][j][0]+f[k][j-1][1])  (k<i且a[k].y>a[i].y)

无耻的粘一下


f[i][j][1]=∑(f[k][j][1]+f[k][j-1][0]) (k<i且a[k].y<a[i].y)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define maxn   100005
#define inf   (~0U>>1)
#define mod  100007

using namespace std; 
inline int read()
{
    int num=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')  {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        num*=10;
        num+=ch-'0';
        ch=getchar();
    }
    return num*f;
 }
struct point{
    int x,y;
}p[maxn];
int n,m,b[maxn];
bool cmp1(point x,point y){
    return x.x<y.x;
}
bool cmp2(int x,int y)
{
    return p[x].y<p[y].y;
}
struct bit{
    int s[maxn];
    inline void add(int x,int y){
        y=(y%mod+mod)%mod;//·ÀÖ¹³öÏÖ¸ºÊý
        for(int i=x;i<=n;i+=(-i)&i) (s[i]+=y)%=mod;
    }
    int query(int x)
    {
        int ans=0;
        for(int i=x;i;i-=i&(-i)) (ans+=s[i])%=mod;
        return ans;
    }
}t[11][2];

int main()
{
    n=read();
    m=read();
    F(i,1,n) p[i].x=read(),p[i].y=read();
    sort(p+1,p+n+1,cmp1);
    F(i,1,n) b[i]=i;
    sort(b+1,b+n+1,cmp2);
    F(i,1,n) p[b[i]].y=i;
    F(i,1,n){
        t[0][0].add(p[i].y,1);
        t[0][1].add(p[i].y,1);
        F(j,1,m){
            t[j][0].add(p[i].y,t[j][0].query(n)-t[j][0].query(p[i].y)+t[j-1][1].query(n)-t[j-1][1].query(p[i].y));
            t[j][1].add(p[i].y,t[j][1].query(p[i].y-1)+t[j-1][0].query(p[i].y-1));
        }
    }
    printf("%d\n",(t[m][0].query(n)+t[m][1].query(n))%mod);
    return 0;
}

bzoj1037
奇怪的状态
f【前i个人】【j个男】【x男》女】【nv》男】
放男生，女生
末状态求和
思路好题
代码超级简单

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define maxn   10005
#define inf   (~0U>>1)
#define mod  12345678
using namespace std; 
inline int read()
{
    int num=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')  {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        num*=10;
        num+=ch-'0';
        ch=getchar();
    }
    return num*f;
 }
 int f[301][151][21][21];
 int n,m,k,ans;
 int main()
 {
    n=read();
    m=read();
    k=read();
    f[0][0][0][0]=1;
    F(i,0,n+m-1) F(j,0,n) F(x,0,k) F(y,0,k) if(f[i][j][x][y]){
        if(j+1<=n&&x+1<=k) (f[i+1][j+1][x+1][max(y-1,0)]+=f[i][j][x][y])%=mod;
        if(i+1-j<=m&&y+1<=k) (f[i+1][j][max(x-1,0)][y+1]+=f[i][j][x][y])%=mod;
     }
     F(i,0,k) F(j,0,k) (ans+=f[n+m][n][i][j])%=mod;
     printf("%d\n",ans);
     return 0;
 }

bzoj1218
最大子矩阵
bzoj1087
状压的裸题
bzoj2734
奇怪的题
似乎就是一个递推
状压dp好题
1 3 9 ……
2 6 12……
4 12 36……
发现最多12行
发现变成一个上面的状压裸题
把不是二和三的倍数的情况都翻倍
bzoj1072
f【i】【j】【k】
前i个位置余数为k的方案数
注意去重
bzoj1296
先针对每个木板
前i个刷了j次
n^4
然后做个分组背包
大水题

#include<cstdio>
#include<cstring>
#include<utility>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdlib>
#include<ext/pb_ds/priority_queue.hpp>
#include<ctime>
using namespace std;
//using namespace __gnu_pbds;

inline int read()
{
    char ch='*';
    while(!isdigit(ch=getchar()));
    int num=ch-'0';
    while(isdigit(ch))
    {
        num=num*10+ch-'0';
        ch=getchar();
    }
    return num;
}
int n,m,k,dp[55][2555];
int f[55][55];
int sum[55];
char s[60];
int t;
int main()
{
    cin>>n>>m>>t;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s+1);
    //  cout<<"!!!";
        for(int j=1;j<=m;j++){
            sum[j]=sum[j-1]+(s[j]=='1');
            //cout<<"sum"<<j<<"---"<<sum[j]<<endl;
        }


        for(int j=1;j<=m;j++)
            for(int x=1;x<=m;x++)
            {
                f[x][j]=0;
                for(int y=0;y<x;y++)
                {
                    int temp=sum[x]-sum[y];
                    f[x][j]=max(f[x][j],f[y][j-1]+max(temp,x-y-temp));

                }

            }
    //  cout<<"-----"<<endl;
    //  for(int j=1;j<=m;j++) cout<<f[m][j]<<" ";

        for(int j=1;j<=t;j++){
            int tmp=min(m,j);
            for(int k=1;k<=tmp;k++)
            {
                dp[i][j]=max(dp[i][j],dp[i-1][j-k]+f[m][k]);
            }

            }


        }

            int ans=0;
    for(int i=1;i<=t;i++){
        ans=max(ans,dp[n][i]);
    }
    cout<<ans<<endl;
    return 0;
    }

bzoj4027
树形dp加贪心
有单独写的题解

#include<cstdio>
#include<cstring>
#include<utility>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdlib>
#include<ctime>
using namespace std;
inline int read()
{
    char ch='*';
    int f=1;
    while(!isdigit(ch=getchar())) if(ch=='-') f=-1;
    int num=ch-'0';
    while(isdigit(ch=getchar())) num=num*10+ch-'0';
    return num*f;
}
const int maxn = 2000005;
vector<int> son[maxn];
int a[maxn];
int n,m;
int ans;
bool cmp(int x,int y)
{
    return a[x]<a[y];
}
void dp(int x)
{
    for(register int i=0;i<son[x].size();i++)dp(son[x][i]);
    sort(son[x].begin(),son[x].end(),cmp);
    a[x]+=son[x].size();
    for(register int i=0;i<son[x].size();i++)
    {
        if(a[x]+a[son[x][i]]-1<=m)
            a[x]+=a[son[x][i]]-1,
            ans++;
        else break;
    }
}



int main()
{
    n=read();m=read();
    int j,x;
    for(register int i=1;i<=n;i++) a[i]=read();
    for(int i=1;i<=n;i++)
    {
        j=read();
        while(j--)  {
            x=read();
            son[i].push_back(x+1);
        }
    }
    dp(1);
    cout<<ans<<endl;
}

bzoj1710
添加和删除是等价的
f【i】【j】
表示前l，r的最小
f【i】【j】=min f[i][j-1] ,f[i+1]【j】
if s【i】==s【j】min f【i】【j】，f【i+1】【j-1】

doge233
关注
专栏目录
动态规划动态规划.zip
10-25
动态规划（Dynamic Programming，简称DP）是解决复杂问题的有效算法设计方法，尤其在计算机科学和IT领域中占有重要地位。它通过将一个大问题分解为若干个子问题，并利用子问题的解来构建原问题的解，从而避免了重复...
动态规划解决TSP问题用动态规划算法求解TSP，数据为Solomon数据集的c101文件读取，可视化路径图，用图展示每次迭代的最
10-22
动态规划是一种解决问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它的目标是找到一个城市的最短可能路线，使得...
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 46万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
动态规划详解
Meiko记录
10-27 6万+
什么是动态规划？ 动态规划（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。 dynamic programming is a method for solving a complex problem by breaking it down into a collection of simpler su...
动态规划算法
Allence的博客
04-08 2万+
一、动态规划算法思想 动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，
C++动态规划
闻缺陷则喜何志丹
01-20 2013
动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。
教你彻底学会动态规划——入门篇
常敲代码手不抖
08-11 39万+
动态规划相信大家都知道，动态规划算法也是新手在刚接触算法设计时很苦恼的问题，有时候觉得难以理解，但是真正理解之后，就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章，大多都是叙述概念，讲解原理，让人觉得晦涩难懂，即使一时间看懂了，发现当自己做题的时候又会觉得无所适从。我觉得，理解算法最重要的还是在于练习，只有通过自己练习，才可以更快地提升。话不多说，接下来，下面我就...
C++ 动态规划
meFranky的博客
07-04 4323
简要介绍动态规划解题的思路，并以数字金字塔、0-1背包问题为例，给出动态规划的代码实现
【算法】动态规划
小匠码农
08-26 3015
动态规划、最长公共子序列
【动态规划】01背包问题（通俗易懂，超基础讲解）
Yngz_Miao的博客
08-24 43万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
算法之动态规划
一名在校大三学习JAVA
07-14 9296
目录什么是动态规划 概念动态规划的特点动态规划的写法适用的场景何时使用动态规划核心套路区别 斐波那契理解动态规划 换零钱问题 区别 分治和动态规划 贪心和动态规划
代码 随机动态规划的实例的matlab代码
06-04
代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的...
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
04-08
会议安排（贪心算法和动态规划） 会议安排问题是计算机科学中的一种经典问题，目的是在一系列活动中选择尽可能多的活动，使得每个活动的结束时间不早于下一个活动的开始时间。这个问题可以使用贪心算法和动态规划两...
贪心算法、分治算法和动态规划的区别 贪心算法和动态规划.pdf
04-08
贪心算法、分治算法和动态规划的区别 贪心算法、分治算法和动态规划是三种常用的算法设计策略，每种算法都有其特点和应用场景。下面我们将对这三种算法进行详细的比较和分析。 分治算法 分治算法是一种将原问题...
springboot基于vue 线上买菜系统源码+sql
最新发布
10-03
springboot基于vue 线上买菜系统源码+sql
将BP神经网络的正向传播过程移植到STM32微控制器上，完成完整的图像采集、
10-03
将BP神经网络的正向传播过程移植到STM32微控制器上，完成完整的图像采集、校正和识别过程NumRecognizeOn Chip
最先进的模型_yolov11.zip
10-03
最先进的模型_yolov11
【matlab源码】四旋翼轨迹跟踪控制和轨迹规划matlab仿真（版本4）
10-03
【matlab源码】四旋翼轨迹跟踪控制和轨迹规划matlab仿真（版本4）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值