算法导论15（动态规划）

最新推荐文章于 2021-03-07 20:53:39 发布
最新推荐文章于 2021-03-07 20:53:39 发布
阅读量554 收藏
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz5034/article/details/46342027
版权

15.1 钢条切割

//自顶向下递归实现
int cutRod(int *p,int n)
{
    if(n==0)return 0;
    int q=INT_MIN;
    for(int i=1;i<=n;++i)q=max(q,p[i]+cutRod(p,n-i));
    return q;
}

//带备忘的自顶向下法
int memoizedCutRodAux(int *p,int n,int *r)
{
    if(r[n]>=0)return r[n];
    int q;
    if(n==0)q=0;
    else
    {
        q=INT_MIN;
        for(int i=1;i<=n;++i)q=max(q,p[i]+memoizedCutRodAux(p,n-i,r));  
    }
    r[n]=q;
    return q;
}

int memoizedCutRod(int *p,int n)
{
    int *r=new int[n+1];
    for(int i=0;i<=n;++i)r[i]=INT_MIN;
    return memoizedCutRodAux(p,n,r);
}

//自底向上法
int bottomUpCutRod(int *p,int n)
{
    int *r=new int[n+1];
    r[0]=0;
    for(int j=1;j<=n;++j)
    {
        int q=INT_MIN;
        for(int i=1;i<=j;++j)q=max(q,p[i]+r[j-i]);
        r[j]=q;
    }
    return r[n];
}

//重构解
void extendedBottomUpCutRod(int *p,int n,int *r,int *s)
{
    r[0]=0;
    for(int j=1;j<=n;++j)
    {
        int q=INT_MIN;
        for(int i=1;i<=j;++j)
        {
            if(q<p[i]+r[j-i])
            {
                q=p[i]+r[j-i];
                s[j]=i;
            }
        }
        r[j]=q;
    }
}

void printCutRodSolution(int *p,int n)
{
    int *r=new int[n+1];
    int *s=new int[n+1];
    extendedBottomUpCutRod(p,n,r,s);
    while(n>0)
    {
        cout<<s[n]<<' ';
        n-=s[n];
    }
}

15.2 矩阵链乘法

//矩阵乘法
void matrixMultiply(vector<vector<int> > A,vector<vector<int> > B,vector<vector<int> > &C)
{
    if(A[0].size()!=B.size())return;
    for(int i=0;i<A.size();++i)
    {
        for(int j=0;j<B[0].size();++j)
        {
            C[i][j]=0;
            for(int k=0;k<A[0].size();++k)C[i][j]+=A[i][k]*B[k][j];
        }
    }
}

//矩阵链乘法
void matrixChainOrder(vector<int> p,vector<vector<int> > &m,vector<vector<int> > &s)
{
    int n=p.size()-1;
    for(int i=1;i<=n;++i)m[i][i]=0;
    for(int l=2;l<=n;++l)
    {
        for(int i=1;i<=n-l+1;++i)
        {
            int j=i+l-1;
            m[i][j]=INT_MAX;
            for(int k=i;k<=j-1;++k)
            {
                int q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                if(q<m[i][j])
                {
                    m[i][j]=q;
                    s[i][j]=k;
                }
            }
        }
    }
}

void printOptimalParens(vector<vector<int> > s,int i,int j)
{
    if(i==j)cout<<"A"<<i;
    else
    {
        cout<<'(';
        printOptimalParens(s,i,s[i][j]);
        printOptimalParens(s,s[i][j]+1,j);
        cout<<')';
    }
}

15.3 动态规划原理

//递归
int recursiveMatrixChain(vector<int> p,int i,int j,vector<vector<int> > &m)
{
    if(i==j)return 0;
    m[i][j]=INT_MAX;
    for(int k=i;k<=j-1;++k)
    {
        int q=recursiveMatrixChain(p,i,k,m)+recursiveMatrixChain(p,k+1,j,m)+p[i-1]*p[k]*p[j];
        if(q<m[i][j])m[i][j]=q;
    }
    return m[i][j];
}

//备忘
int lookupChain(vector<vector<int> > m,vector<int> p,int i,int j)
{
    if(m[i][j]<INT_MAX)return m[i][j];
    if(i==j)m[i][j]=0;
    else
    {
        for(int k=i;k<=j-1;++k)
        {
            int q=lookupChain(m,p,i,k)+lookupChain(m,p,k+1,j)+p[i-1]*p[k]*p[j];
            if(q<m[i][j])m[i][j]=q;
        }
    }
    return m[i][j];
}

int memoizedMatrixChain(vector<int> p)
{
    int n=p.size()-1;
    vector<vector<int> > m(n+1,vector<int>(n+1,INT_MAX));
    return lookupChain(m,p,1,n);
}

15.4 最长公共子序列

void LCSLength(vector<char> X,vector<char> Y,vector<vector<int> > &b,vector<vector<int> > &c)
{
    int m=X.size();
    int n=Y.size();
    for(int i=1;i<=m;++i)c[i][0]=0;
    for(int j=0;j<=n;++j)c[0][j]=0;
    for(int i=1;i<=m;++i)
    {
        for(int j=1;j<=n;++j)
        {
            if(X[i]==Y[j])
            {
                c[i][j]=c[i-1][j-1]+1;
                b[i][j]=1;
            }
            else if(c[i-1][j]>=c[i][j-1])
            {
                c[i][j]=c[i-1][j];
                b[i][j]=2;
            }
            else
            {
                c[i][j]=c[i][j-1];
                b[i][j]=3;
            }
        }
    }
}

void printLCS(vector<vector<int> > b,vector<char> X,int i,int j)
{
    if(i==0||j==0)return;
    if(b[i][j]==1)
    {
        printLCS(b,X,i-1,j-1);
        cout<<X[i]<<' ';
    }
    else if(b[i][j]==2)printLCS(b,X,i-1,j);
    else printLCS(b,X,i,j-1);
}

15.5 最优二叉搜索树

//p[1..n]
//q[0..n]
//e[1..n+1,0..n]
//w[1..n+1,0..n]
//root[1..n,1..n]
//时间复杂度为O(n^3)
void optimalBST(vector<int> p,vector<int> q,int n,vector<vector<int> > &e,vector<vector<int> > &w,vector<vector<int> > &root)
{
    for(int i=1;i<=n+1;++i)e[i][i-1]=w[i][i-1]=q[i-1];
    for(int l=1;l<=n;++l)
    {
        for(int i=1;i<=n-l+1;++i)
        {
            int j=i+l-1;
            e[i][j]=INT_MAX;
            w[i][j]=w[i][j-1]+p[j]+q[j];
            for(int r=i;r<=j;++r)
            {
                int t=e[i][r-1]+e[r+1][j]+w[i][j];
                if(t<e[i][j])
                {
                    e[i][j]=t;
                    root[i][j]=r;
                }
            }
        }

    }
}

//改进，时间复杂度为O(n^2)。
void optimalBST(vector<int> p,vector<int> q,int n,vector<vector<int> > &e,vector<vector<int> > &w,vector<vector<int> > &root)
{
    for(int i=1;i<=n+1;++i)e[i][i-1]=w[i][i-1]=q[i-1];
    for(int l=1;l<=n;++l)
    {
        for(int i=1;i<=n-l+1;++i)
        {
            int j=i+l-1;
            e[i][j]=INT_MAX;
            w[i][j]=w[i][j-1]+p[j]+q[j];    
            //root[i][j-1]<=root[i][j]<=root[i+1][j]
            if(i==j)
            {
                int t=e[i][r-1]+e[r+1][j]+w[i][j];
                if(t<e[i][j])
                {
                    e[i][j]=t;
                    root[i][j]=i;
                }
            }
            else
            {
                for(int r=root[i][j-1];r<=root[i+1][j];++r)
                {
                    int t=e[i][r-1]+e[r+1][j]+w[i][j];
                    if(t<e[i][j])
                    {
                        e[i][j]=t;
                        root[i][j]=r;
                    }
                }
            }
        }
    }
}

思考题
15-1

const int N=100;

struct ENode
{
    int val,w;
    ENode *next;
};

struct VNode
{
    ENode *next;
};

struct Graph    
{    
    VNode Adj[N];    
    int VNum,ENum;    
};    

void longestPathAux(Graph G,int u,int t,int *dist,int *next)
{
    if(u==t)dist[u]=0;
    else if(next[u]==0)
    {
        for(ENode *p=G.Adj[u].next;p;p=p->next)
        {
            int v=p->val,w=p->w;
            longestPathAux(G,v,t,dist,next);
            if(w+dist[v]>dist[u])
            {
                dist[u]=w+dist[v];
                next[u]=v;
            }
        }
    }
}

void printPath(int s,int t,int *next)
{
    int u=s;
    cout<<u;
    while(u!=t)
    {
        cout<<"->"<<next[u];
        u=next[u];
    }
}

void longestPathMain(Graph G,int s,int t)
{
    int n=G.VNum;
    int *dist=new int[n+1],*next=new int[n+1];
    for(int i=1;i<=n;++i)
    {
        dist[i]=INT_MIN;
        next[i]=-1;
    }
    longestPathAux(G,s,t,dist,next);
    if(dist[s]==INT_MIN)cout<<"No path exits"<<endl;
    else
    {
        cout<<"The weight of the longest path is "<<dist[s]<<endl;
        printPath(s,t,next);
    }
    delete [] dist,next;
}
hz5034
关注
专栏目录
动态规划——钢管问题（算法导论经典问题）
LCB576的专栏
12-02 2644
绪论 关于动态规划，博主尚在学习中，但总的来说动态规划和分治算法有一定的相似性，分而治之，复杂问题到简单问题的分解，而动态规划较之更为优化，在本问题当中对于动态规划的设计有两种： 1、带备忘的自顶向下法 在分治法的基础上，将每个分解到的小问题的解存储到一个数组里，等到下次调用时就可以直接利用，而不需要再算一次，从而节省了时间。 2、自底向上法 将子问题按照从小到大的顺
算法导论第15章动态规划之钢条切割章节答案
GIOVANNO的博客
05-05 1452
15.1-1 由公式(15.3)和初始条件T(0)=1,证明(15.4)成立。 15.1-2 举反例证明下面的“贪心”策略不能保证总是得到最优切割方案。定义长度为i的钢条的价格密度为，即每英寸的价格。贪心策略将长度为n的钢条切割下长度为i(1 ≤ i ≤ n)的一段，其价格密度最高。接下来继续使用相同的策略切割长度为n-i的剩余部分。 答：举个反例。如果按照这来，那么...
算法导论第15章课后习题答案
01-14
算法导论第15章-动态规划的课后习题参考答案，对于算法爱好者而言，是不错的参考资料。
算法导论15
WHJObject的博客
02-08 345
原题： 设计一个O(n^2)时间的算法，求一个n个数的序列的最长单调递增子序列 想法： 记录每个位置元素一定被包含在其中的子序列的最大长度 靠后的元素加入的子序列依赖之前的子序列 两个for循环，O(n^2)显然 #include using namespace std; struct lAndMax { int length, max; }; int main() { in
算法导论 ch15 动态规划 任务调度
gaofen100
05-30 96
1. souce codes #include &lt;iostream&gt; using namespace std; void fastestWay(int a[][6], int t[][5], int e[2], int x[2], int n) { int f[2][6]; int l[2][6]; int fstar = 0; int lstar = 0; ...
算法导论 练习题 11.1-2
苦海无涯闯进来
04-30 445
1
算法导论_第15章_动态规划
qq_48176859的博客
03-07 563
文章目录一、动态规划二、动态规划例题1.最少硬币问题（最小）2.钢条切割问题（最大）3.不同路径问题（计数2）4.青蛙过河（存在性动态规划） 一、动态规划   动态规划与分治方法类似，都是通过子问题的组合来求解原问题的，但是分治法是划分为互不干扰的子问题而动态规划划分的子问题往往都是具有重叠效应的，前一个子问题会影响后一个子问题。   动态规划题目种类： 计数 有多少种方式走到右下角 有多少种方法选出k个数使得和是sum 求最大最小值 从左上角走到右下角路径的最大数字和 最长上升序列长度 求存
编辑距离问题-算法导论.pdf
11-27
编辑距离问题-算法导论 在计算机科学中，编辑距离问题是指将一个字符串转换成另一个字符串所需的最少操作步骤数。这些操作可以是插入、删除、替换和复制字符。编辑距离问题是一种典型的动态规划问题。 动态规划是...
MIT算法导论公开课之课程笔记 15.动态规划、最长公共子序列.rar
07-06
【标题】 MIT算法导论公开课之课程笔记 15.动态规划、最长公共子序列 在计算机科学领域，算法是解决问题的关键。MIT的算法导论课程是全球知名的在线教育资源，旨在深入讲解算法的设计和分析。本节课程重点讨论了...
算法导论中文第三版习题答案
04-07
本书覆盖了从排序和搜索到图算法，再到动态规划和贪心算法等一系列广泛的主题，旨在帮助学生和从业者提升算法思维能力，解决实际问题。 本书的习题解答部分是学习过程中不可或缺的辅助资料。每一道习题都是对理论...
vijos1476 旅游规划-动态规划
Mys_C_K的博客
05-26 665
传送门 题解： 我是这么做的，首先第一遍求出每个点向下的不相交的最长链和次长链， 这样两条链拼起来就是就是过这个点（不包含他的父亲的情况下）的最长链。 在这些最长链中取max就可以得到直径。 然后一个点在直径上，要么他本身就在已经求出的最长链上（就是从这个点出发的最长+次长链=直径长度）， 要么如果这个点在某一条直径的某条链上（即这个点向父亲方向延伸的最长+这个点向下的最长=直径长度）
hdu 1158 Employment Planning （动态规划）
起航
08-12 94
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=1158    解题报告：自我感觉这道题目的状态方程不太容易。 刚开始用一维的搞，这么也得不到正确答案，后来想有月份、人数，应该用二维的。  首先雇主要在第n月花钱最少，一定是在第n-1月花钱也是最少，一定具有最有子结构，可以想到动态规划； 如果第n个月的需要的人数比第n-1个月的多，则需...
算法导论 第三版 动态规划之库存规划
永不停息的狮子的专栏
03-13 5488
15-11 题目：某公司的额定产能是每月生产m台设备，而如果每月生产超过m台，则需要额外雇佣劳动力，每多生产一台设备所需的雇佣成本为c。已知未来n个月每个月的需求为d[i]，不同的月份需求不一样，但是具体到某个月需求是确定的。另外，如果每个月末有设备剩余，则需要付出h(j)的库存成本，j是当月的库存，h(j)是单调非递减函数。安排每个月的生产计划，使得在满足需求的前提下成本最小。 解答
《算法导论》第十五章——动态规划
T的博客
11-01 3383
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ 动态规划(dynamic programming)与分治方法相似共同点：通过组合子问题的解来求解原问题的解。 不同点：分治方法求解互不相交的子问题，动态规划应用于子问题重叠的情况...
算法导论15章动态规划
crazychen的专栏
05-01 1507
钢条切割问题 public class Main { int n = 10; int[] p = new int[]{1,5,8,9,10,17,17,20,24,30}; int[] r = new int[n+1]; int[] s = new int[n+1]; int solve(int n,int[] s,int c){ if(n==0) return 0; if
算法导论26（最大流）
Jiajun Zhu
11-07 3184
26.1流网络 26.2Ford-Fulkerson方法
算法导论20（van Emde Boas 树）
Jiajun Zhu
05-19 2550
#include<iostream> using namespace std;struct node { int u,min,max; node *summary; node **cluster; };void vEBTreeCreate(node *root,int u) { root->u=u; root->min=root->max=-1; if
算法导论25（所有结点对的最短路径问题）
Jiajun Zhu
10-30 2074
25.1最短路径和矩阵乘法
算法导论复习重点：分治、动态规划与搜索策略
"这是一份关于《算法导论》期末复习的习题集，主要涵盖了算法、期末复习和黑皮书第三版中的习题。题目涉及了多种算法思想和方法，包括分治策略、动态规划、贪心法、回溯法等。" 1. 分治策略：二分搜索算法是分治...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值