动态规划学习系列

最新推荐文章于 2022-10-21 20:17:10 发布
最新推荐文章于 2022-10-21 20:17:10 发布
阅读量213 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daizhou168/article/details/9067409
版权

一：题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2955

这道题是，错误的认为题目所给的浮点型的数据都是精确到小数点后两位，然后把概率放大100倍，转换成为熟悉的01背包。。faint。。经测试题目的数据可能达到0.00001，甚至比0.00001还小，，所以必须转换思路，，
于是转成以所有银行的总资产为背包容量V。。求最大的逃跑概率。。
注意：题目给我们的是被抓的概率，，而我们要求最大的逃跑率，需要去被抓的概率pi的补 ，即1-pi
只有逃跑率才会等于各个逃跑率之积，被抓的概率不会等于各个被抓的概率之积，，概率的知识，不多说。。
状态转移方程：dp[j] = max ( dp[j], dp[j-cost[i]] * weight[i])..

代码：

#include<iostream>
 #include<cstdio>
 #include<cmath>
 #define MAXN 101
 #define MAXV 10001

 using namespace std;

 int cost[MAXN];
 double weight[MAXV],dp[MAXV];

 int main()
 {
     //freopen("in.txt","r",stdin);
     int test,sumv,n,i,j;
     double P;
     cin>>test;
     while(test--)
     {
         scanf("%lf %d",&P,&n);
         P=1-P;
         sumv=0;
         for(i=0;i<n;i++)
         {
             scanf("%d %lf",&cost[i],&weight[i]);
             weight[i]=1-weight[i];
             sumv+=cost[i];
         }
        for(int i=0;i<=sumv;++i)
        dp[i]=0;
        dp[0]=1;
        for(int i=0;i<n;++i){
            for(int v=sumv;v>=1;--v){
                if(v<cost[i]) continue;
                dp[v]=max(dp[v],dp[v-cost[i]]*weight[i]);
            }
        }
        for(int v=sumv;v>=0;--v){
            if(dp[v]>P){
                cout<<v<<endl;break;
            }
        }
     }
     return 0;
 }


 

二：最大报销额，题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1864

代码：

#include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<vector>
#include<algorithm>
#include<numeric>
#include<iomanip>
using namespace std;
double total;
int N;
vector<vector<double> > dvec;
void proc(){
    vector<double> sums;
    sums.resize(dvec.size());
    for(size_t i=0;i<dvec.size();++i){
        sums[i]=accumulate(dvec[i].begin(),dvec[i].end(),0.0);
    }
    vector<double> dp;
    size_t len=sums.size();
    dp.resize(len+1);
    for(int i=0;i<dp.size();++i)
    dp[i]=0;

    //dp[0]=sums[0];
    for(int i=1;i<=len;++i){
        for(int v=len;v>0;--v){
            dp[v]=max(dp[v],dp[v-1]+sums[i-1]);
        }
    }
    for(int v=len;v>=0;--v){
        if(dp[v]<=total+0.0000001){
           cout<<setiosflags(ios::fixed)<<setprecision(2)<<dp[v]<<endl;
            return;
        }
    }
}
 int main()
 {
    // freopen("in.txt","r",stdin);
   int n;
   char ct,ct2;
   double dt;
     while(cin>>total>>N){
         dvec.clear();
        if(0==N) break;
        while(N--){
            cin>>n;
            vector<double> tvec;
            int flag=true;
            double sum=0;
            double suma=0,sumb=0,sumc=0;
            for(int i=0;i<n;++i){
                cin>>ct>>ct2>>dt;
                sum+=dt;
                if(ct=='A')
                suma+=dt;
                if(ct=='B')
                sumb+=dt;
                if(ct=='C')
                sumc+=dt;
                if(suma>600||sumb>600||sumc>600)
                flag=false;
                if((ct!='A'&&ct!='B'&&ct!='C')||dt>600||sum>1000)
                flag=false;
                tvec.push_back(dt);
            }
            if(flag)
            dvec.push_back(tvec);
        }
        proc();
        }
     return 0;
 }


三：最大子序列的和：http://acm.hdu.edu.cn/showproblem.php?pid=1231

代码：

#include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<vector>
#include<algorithm>
#include<numeric>
#include<iomanip>
using namespace std;
int N;

struct Node{
    int sum;
    int start;
    int end;
}data[10001];
 int main()
 {
     //freopen("in.txt","r",stdin);
    while(cin>>N,N){
        vector<int> ivec;
        ivec.resize(N+1);
        for(int i=1;i<=N;++i){
            cin>>data[i].sum;
            ivec[i]=data[i].sum;
        }
        data[1].start=1;
        data[1].end=1;
        for(int i=2;i<=N;++i){
            if(data[i-1].sum>=0){
                data[i].sum=data[i-1].sum+data[i].sum;
                data[i].start=data[i-1].start;
                data[i].end=i;
            }else{
                data[i].start=i;
                data[i].end=i;
            }
        }
        int idx=1;
        int max=data[1].sum;
        for(int i=2;i<=N;++i){
            if(data[i].sum>max){
                idx=i;
                max=data[i].sum;
            }
        }
        if(max<0){
            cout<<0<<" "<<data[1].sum<<" "<<data[N].sum<<endl;
        }else{
            cout<<max<<" "<<ivec[data[idx].start]<<" "<<ivec[data[idx].end]<<endl;
        }
    }
     return 0;
 }

四：HDU 1505 City Game 矩阵的最大面积

#define MX(a,b)  (a>b?a:b)
#define N 1005
int f[N][N],l[N],r[N];
int n,m;
char s[5];
int max;

int main()
{
   int t;
   scanf("%d",&t);
   while(t--)
   {
     memset(f,0,sizeof(f));
  scanf("%d%d",&n,&m);
  for(int i=1;i<=n;i++)
  {
     for(int j=1;j<=m;j++)
  {
       scanf("%s",s);
    if(s[0]=='F')
    f[i][j]=f[i-1][j]+1;    
     }    
     }    
      max=0;
     int temp;
     for(int k=1;k<=n;k++)

   {    
     for(int i=1;i<=m;i++)
     l[i]=r[i]=i;
  for(int i=2;i<=m;i++)
  {
     temp=l[i];
     while(f[k][temp-1]>=f[k][i]&&temp>1)
     temp=l[temp-1];
     l[i]=temp;   
     } 
  for(int i=m-1;i>=1;i--)
  {
    temp=r[i];
    while(f[k][temp+1]>=f[k][i]&&temp<n)
    temp=r[temp+1];
    r[i]=temp;   
     } 
  for(int i=1;i<=m;i++)
  max=MX(max,(r[i]-l[i]+1)*f[k][i]);  
     }
     printf("%d\n",max*3);
   }  
   return 0;
}



 五：

Bone Collector http://acm.hdu.edu.cn/showproblem.php?pid=2602 
    简单0-1背包,状态方程:f[j]=max(f[j],f[j-v[i]]+w[i])

#define N 1005
using namespace std;
int n,V;
int w[N],c[N],f[N];
void pack(){
    memset(f,0,sizeof(f));
    for(int i=1;i<=n;++i){
        for(int v=V;v>=0;--v){
            if(v-c[i]<0) continue;
            f[v]=max(f[v],f[v-c[i]]+w[i]);
        }
    }
    cout<<f[V]<<endl;
}
int main() {
  // freopen("in.txt","r",stdin);

    int T;
    cin>>T;
    while(T--){
        cin>>n>>V;
        for(int i=1;i<=n;++i)
        cin>>w[i];
        for(int i=1;i<=n;++i)
        cin>>c[i];
        pack();
    }
    return 0;
}


六：求最大递增数组的和，要求不一定连续hdu1087

开辟一个新的数组B,B中存放的是以当前数字结尾的最大和,状态转移方程：最大递增子段和,状态方程:sum[j]=max{sum[i]}+a[j]; 其中,0<=i<=j,a[i]<a[j]    

 int n,a[1005],b[1005];
    int max,i,j,maxnum;
    while(scanf("%d",&n),n) {
        maxnum=0;
        memset(b,0,sizeof(b));
        for(i=0; i<n; i++) {
            scanf("%d",&a[i]);
        }
        for(i=0; i<n; i++) {
            b[i]=a[i];
            max=0;//找到前面所有小于a[i]的最大值
            for(j=0; j<i; j++) {
                if(a[i]>a[j]) {
                    if(b[j]>max) {
                        max=b[j];
                    }
                }
            }
            b[i]+=max;
            //寻找一个最大的和
            if(b[i]>maxnum) {
                maxnum=b[i];
            }
        }
        printf("%d\n",maxnum);
    }


七：命运http://acm.hdu.edu.cn/showproblem.php?pid=2571
    状态方程:sum[i][j]=max{sum[i-1][j],sum[i][k]}+v[i][j];其中1<=k<=j-1,且k是j的因子    注意第一行和第一列不能转移由前面的0行或0列转移

代码：

int data[25][1005];
int dp[25][1005];
int n,m;
void proc(){
    for(int i=0;i<=m;i++)
            dp[0][i]=0;
        for(int i=0;i<=n;i++)
            dp[i][0]=0;
    dp[1][1]=data[1][1];
    for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j){

        if(i==1&&j==1) continue;
        if(i!=1)
        dp[i][j]=max(dp[i][j],data[i][j]+dp[i-1][j]);
        if(j!=1)
        dp[i][j]=max(dp[i][j],data[i][j]+dp[i][j-1]);
        for(int k=1;k<j-1;++k){
            if(j%k==0)
            dp[i][j]=max(dp[i][j],dp[i][k]+data[i][j]);
        }

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

}
int main() {
  //freopen("in.txt","r",stdin);
   int T;
   cin>>T;
   while(T--){
        cin>>n>>m;
        for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j){
            cin>>data[i][j];
            dp[i][j]=INT_MIN;
        }
        proc();
   }
    return 0;
}


八：Monkey And Banana     http://acm.hdu.edu.cn/showproblem.php?pid=1069
    状态方程:f[j]=max{f[i]}+v[j];其中,0<=i<=j,w[i]<w[j],h[i]<h[j]    

struct Cube{
    int x,y,z;
    Cube(){}
    Cube(int _x,int _y,int _z):x(_x),y(_y),z(_z){}
}dp[200];
bool cmp(const Cube& a,const Cube& b){
    if(a.x!=b.x) return a.x>b.x;
    return a.y>b.y;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif

    int n;
    int a,b,c;
    int k=1;
    while(cin>>n,n!=0){
        int cnt=0;

        while(n--){
            cin>>a>>b>>c;
            dp[cnt++]=Cube(a,b,c);
            dp[cnt++]=Cube(a,c,b);
            dp[cnt++]=Cube(b,a,c);
            dp[cnt++]=Cube(b,c,a);
            dp[cnt++]=Cube(c,a,b);
            dp[cnt++]=Cube(c,b,a);
        }
        sort(dp,dp+cnt,cmp);

        for(int i=1;i<cnt;++i){
            int tmp=0;
            for(int j=0;j<i;++j){
                if(dp[j].x>dp[i].x&&dp[j].y>dp[i].y&&dp[j].z>tmp){
                    tmp=dp[j].z;
                }
            }
            dp[i].z+=tmp;
        }
         int height=0;
        for(int i=0;i<cnt;++i){
            if(dp[i].z>height)
            height=dp[i].z;
        }
        printf("Case %d: maximum height = %d\n",k++,height);
    }
    return 0;

}


 

九：

方法一：Big Event in HDU http://acm.hdu.edu.cn/showproblem.php?pid=1171 
    一维背包,逐个考虑每个物品带来的影响,对于第i个物品:if(f[j-v[i]]==0) f[j]=0;
    其中,j为逆序循环,且j>=v[i]    

const int N=5001;
int val[N];
int num[N];
bool dp[N*N];
int n;
int sumv;
void proc(){
   memset(dp,false,sizeof(dp));
    dp[0]=true;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=num[i];++j){
            for(int v=sumv/2;v>=val[i];--v){
                if(dp[v-val[i]])
                dp[v]=true;
            }
        }
    }
    for(int i=sumv/2;i>=0;--i)
    {
        if(dp[i]){
            cout<<sumv-i<<" "<<i<<endl;
            break;
        }
    }
}
int main() {
  //freopen("in.txt","r",stdin);
    while(cin>>n,n>=0){
        sumv=0;
        for(int i=1;i<=n;++i){
            cin>>val[i]>>num[i];
            sumv+=val[i]*num[i];
        }
        proc();
    }
    return 0;
}

方法二：

组合数学中的母函数方法：

#include<iostream>
#include<sstream>
#include<string>
#include<vector>
using namespace std;
const int N=5001;
int c1[N*N],c2[N*N];
struct Node{
    int v;
    int n;
}nodes[55];
int n;
int sumv;

void proc(){
    memset(c1,0,sizeof(c1));
    memset(c2,0,sizeof(c2));

    for(int i=0,j=0;j<=nodes[1].n;++j,i+=nodes[1].v){
        c1[i]=1;
    }
    int aim=sumv/2;
    for(int i=2;i<=n;++i){
        for(int j=0;j<=aim;++j){
            if(c1[j]==0) continue;
            for(int k=0;(k*nodes[i].v+j<=aim)&&(k<=nodes[i].n);++k){
                c2[k*nodes[i].v+j]+=c1[j];
            }
        }
        for(int j=0;j<=aim;++j){
            c1[j]=c2[j];
            c2[j]=0;
        }
    }

    for(int i=aim;i>=0;--i){
        if(c1[i]!=0) {
            cout<<sumv-i<<" "<<i<<endl;
        return ;
        }
        
    }

}
int main() {
  freopen("in.txt","r",stdin);

    while(cin>>n,n>=0){
        sumv=0;
        for(int i=1;i<=n;++i){
            cin>>nodes[i].v>>nodes[i].n;
            sumv+=nodes[i].v*nodes[i].n;
        }
        proc();
    }
    return 0;
}


十：数塔问题http://acm.hdu.edu.cn/showproblem.php?pid=2084下面给出的解法其实很笨，看了下网上的，自底向上:dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+v[i][j]; 

这种解法要效率高点

int n;
const int N=205;
int data[N][N];
int dp[N][N];
void proc(){
    dp[1][n]=data[1][n];
    for(int i=2;i<=n;++i){
        for(int j=n-i+1;j<=n+i-1;j+=2)
        dp[i][j]=max(dp[i-1][j-1],dp[i-1][j+1])+data[i][j];
    }
    int big=INT_MIN;
    for(int i=1;i<=2*n-1;++i){
        big=max(big,dp[n][i]);
    }
    cout<<big<<endl;
}
int main() {
    //freopen("in.txt","r",stdin);
    int T;
    cin>>T;
    while(T--){
        memset(data,0,sizeof(data));
        for(int i=0;i<N;++i)
        for(int j=0;j<N;++j)
        dp[i][j]=0;
      cin>>n;
      for(int i=1;i<=n;++i){
        int idx=n-i+1;
        for(int j=1;j<=i;++j){
            cin>>data[i][idx];
            idx+=2;
        }
      }
      proc();
    }
    return 0;
}



 

DQZQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划学习
jiqiren1994的博客
09-13 375
一、动态规划学习 动态规划来源于运筹学，是求解决策过程最优化的一种数学方法。在20世纪50年代初美国数学家R. E. Bellman等提出的最优化原理，动态规划的核心思想是利用各阶段之间的关系，逐个求解，最终得到全局最优解。 设计一个动态规划算法的关键点是确认原问题与子问题、动态规划的状态、边界状态值和状态转移方程等。 二、动态规划解题步骤 想清楚原问题与子问题 设计状态 设计状态转移方程 确定边界状态值 三、动态规划示例-爬楼梯 3.1 题目描述 在爬楼梯的时候，每次可以往上爬1阶台阶或2阶台阶，问n
强化学习之动态规划算法MATLAB演示程序
04-06
文件名“RL_DP”很可能包含一系列示例代码，这些代码可能涵盖上述两种动态规划算法的实现，以及如何构建状态转移矩阵和奖励函数。 对于强化学习初学者来说，理解并动手实现这些算法是非常有益的。不仅可以帮助他们...
学习笔记：动态规划算法
ohhjack的博客
10-21 864
学习笔记：动态规划算法
leetcode动态规划入门系列总结
qq_42987967的博客
12-31 428
最近LeetCode的动态规划21天入门系列的学习计划，经历了一个从自闭到自闭的过程，但不管怎么说，还是及时做个笔记总结一下吧，「动态规划」 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台 首先讲讲自己做动态规划题的感悟。感觉动态规划的题就是有点抽象，有一些比较直观的，没接触过也能大致推导出转移方程，不直观的那种基本上只能记住套路，如果你想试图证明其合理性也不是不行，就是非常非常难。而且找状态的时候是需要经验的，有时候需要猜，设置的状态到底合不合理，遍历顺序是否是对的等等，感觉差不多
强化学习-动态规划-DP1
08-03
在强化学习中，动态规划（Dynamic Programming, DP）是一种用于解决马尔科夫决策过程（Markov Decision Process, MDP）的重要方法。DP主要用于找出最优策略以及对应的最优价值函数。本节主要关注两种动态规划算法：...
动态规划动态规划.zip
10-25
1. **线性模型**：这是动态规划的基础形式，通常涉及到一系列有序的操作或决策，其中每个步骤的最优决策依赖于前一步的决策。例如，斐波那契数列就是一个典型的线性模型。 2. **区间模型**：这类模型通常涉及到处理...
Java学习之动态规划-背包问题代码
最新发布
05-16
动态规划是通过将复杂问题分解为一系列子问题，并利用子问题的解来构建原问题的解。这种策略避免了重复计算，提高了效率。在Java中，我们可以使用二维数组来存储这些子问题的解，即状态转移方程。 在背包问题中，有...
强化学习与自适应动态规划-RL and ADP
06-02
自适应动态规划（ADP）则是将动态规划与强化学习相结合的一种方法，试图克服DP的局限性。ADP利用近似算法来处理大规模状态和动作空间，同时允许在未知环境中在线学习。它结合了DP的理论框架和RL的试错学习，通过迭代...
hdu1011 Starship Troopers 树形背包
09-06 398
http://acm.hdu.edu.cn/showproblem.php?pid=1011 是有n个洞组成一棵树，你有m个士兵，你从1号房间开始攻打，每个洞有a个"bugs"和b的价值。你的一个士兵可以打20个"bugs"，为了拿到这个洞的价值b你必须留下k个士兵消灭这个洞的所有"bugs"（k*20>="bugs"的数量，且留下的士兵不可以再去攻打其他的洞，且必须攻打了前面的洞才可以攻打后面
2013 ACM/ICPC Asia Regional Online —— Warmup 三个ACM热身赛题
09-08 365
三个题就做对一个，还是很有差距呀，第一个正确。第二三个没有AC,贴一下代码： #include #include #include #include #include #include using namespace std; inline char next(char t){ t=(t+1); if(t=='z'+1) t='a'; return t; } int main(
hdu1069 Monkey and Banana
05-09 300
题目链接点击打开链接 #include #include #include using namespace std; struct Cube{     int x,y,z;     Cube(){}     Cube(int _x,int _y,int _z):x(_x),y(_y),z(_z){} }dp[200];//总共有30*3*2个状态 bool cmp(const
hdu1043 Eight--分别用A*和IDA*的解法
05-10 260
Problem Description The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15
动态规划学习系列三
06-12 257
一：最少拦截系统http://acm.hdu.edu.cn/showproblem.php?pid=1257     两种做法,一是贪心,从后往前贪;二是DP;     if(v[i]>max{dp[j]}) (0     dp[len++]=v[i];     贪心法： int i,n,count,a[1005],res,max; while (scanf("%d",&n
hdu1071 the area
05-09 253
Problem Description Ignatius bought a land last week, but he didn't know the area of the land because the land is enclosed by a parabola and a straight line. The picture below shows the area. Now giv
hdu3062 Party 2-sat问题之一学习
05-11 248
题目链接：点击打开链接 思路：根据不相容的集合组成有向图，然后在有向图中找极大连通子图，如果夫妻两个在同一个连通中，则无解。代码： #include #include #include using namespace std; const int N=2005; int dfn[N],low[N],ins[N],gin[N]; vector gra[N]; stack sta
hdu3622 Bomb Game--2-sat问题学习二
05-11 242
题目链接：点击打开链接 思路：求出每顶点对之间的距离，然后unique一下，最后二分法解针对每个距离的可行性。 代码： #include #include #include #include #include using namespace std; const int maxn=300; //tarjan 使用注意ini还有图开始的下标 int low[maxn],dfn
hdu1102最小生成树的解--prim算法和kruscal算法
06-29 230
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1102 一；利用kruscal算法： 利用到了并查集的思想。getParent()利用是一种两趟方法(two-path method),一趟是沿查找路径上升，直到找到根，第二趟是沿路径下降，以便更新每个节点使之直接指向根。 另外按rank合并没有体现，其思想是为每个节点添加一个rank，好让合并的
强化学习、自适应动态规划与动态规划的综述
强化学习与自适应动态规划（RL and ADP）是两种解决复杂问题的方法。本文将介绍动态规划（DP）、强化学习（RL）和自适应动态规划（ADP）的原理和应用。 动态规划（DP）是一种通过将大问题分解成小问题来求解最优解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值