算法导论15（动态规划）

最新推荐文章于 2018-11-01 16:31:55 发布
最新推荐文章于 2018-11-01 16:31:55 发布
阅读量553 收藏
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论第15章课后习题答案
01-14
算法导论第15章-动态规划的课后习题参考答案，对于算法爱好者而言，是不错的参考资料。
vijos1476 旅游规划-动态规划
Mys_C_K的博客
05-26 662
传送门 题解： 我是这么做的，首先第一遍求出每个点向下的不相交的最长链和次长链， 这样两条链拼起来就是就是过这个点（不包含他的父亲的情况下）的最长链。 在这些最长链中取max就可以得到直径。 然后一个点在直径上，要么他本身就在已经求出的最长链上（就是从这个点出发的最长+次长链=直径长度）， 要么如果这个点在某一条直径的某条链上（即这个点向父亲方向延伸的最长+这个点向下的最长=直径长度）
算法导论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
算法导论 练习题 11.1-2
苦海无涯闯进来
04-30 444
1
算法导论 第三版 动态规划之库存规划
永不停息的狮子的专栏
03-13 5485
15-11 题目：某公司的额定产能是每月生产m台设备，而如果每月生产超过m台，则需要额外雇佣劳动力，每多生产一台设备所需的雇佣成本为c。已知未来n个月每个月的需求为d[i]，不同的月份需求不一样，但是具体到某个月需求是确定的。另外，如果每个月末有设备剩余，则需要付出h(j)的库存成本，j是当月的库存，h(j)是单调非递减函数。安排每个月的生产计划，使得在满足需求的前提下成本最小。 解答
算法导论中文第三版习题答案
04-07
本书覆盖了从排序和搜索到图算法，再到动态规划和贪心算法等一系列广泛的主题，旨在帮助学生和从业者提升算法思维能力，解决实际问题。 本书的习题解答部分是学习过程中不可或缺的辅助资料。每一道习题都是对理论...
算法导论答案
04-08
3. **动态规划**：第5章通常介绍动态规划的概念，通过求解背包问题、最长公共子序列等例子，展示如何使用动态规划解决复杂问题。 4. **贪心算法**：第6章可能涵盖贪心算法，如霍夫曼编码、Prim最小生成树算法或...
中科大算法导论期末考试试卷
01-12
4. **动态规划**：动态规划用于解决最优化问题，如背包问题、最长公共子序列、最小编辑距离等，通过构造状态转移方程来求解。 5. **图论算法**：包括Dijkstra最短路径算法、Floyd-Warshall所有对最短路径、Kruskal...
算法导论课后答案
08-21
### 第15章：动态规划 #### 15.1 复杂度分析 - **15.1-1**至**15.1-5**：通过具体的例子展示了如何分析动态规划算法的时间复杂度。 #### 15.2 最优二叉搜索树 - **15.2-1**至**15.2-5**：详细介绍了如何利用动态...
动态规划——钢管问题（算法导论经典问题）
LCB576的专栏
12-02 2642
绪论 关于动态规划，博主尚在学习中，但总的来说动态规划和分治算法有一定的相似性，分而治之，复杂问题到简单问题的分解，而动态规划较之更为优化，在本问题当中对于动态规划的设计有两种： 1、带备忘的自顶向下法 在分治法的基础上，将每个分解到的小问题的解存储到一个数组里，等到下次调用时就可以直接利用，而不需要再算一次，从而节省了时间。 2、自底向上法 将子问题按照从小到大的顺
算法导论15章动态规划
crazychen的专栏
05-01 1503
钢条切割问题 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
算法导论 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; ...
《算法导论》第十五章——动态规划
T的博客
11-01 3372
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ 动态规划(dynamic programming)与分治方法相似共同点：通过组合子问题的解来求解原问题的解。 不同点：分治方法求解互不相交的子问题，动态规划应用于子问题重叠的情况...
hdu 1158 Employment Planning （动态规划）
起航
08-12 94
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=1158    解题报告：自我感觉这道题目的状态方程不太容易。 刚开始用一维的搞，这么也得不到正确答案，后来想有月份、人数，应该用二维的。  首先雇主要在第n月花钱最少，一定是在第n-1月花钱也是最少，一定具有最有子结构，可以想到动态规划； 如果第n个月的需要的人数比第n-1个月的多，则需...
算法导论26（最大流）
Jiajun Zhu
11-07 3183
26.1流网络 26.2Ford-Fulkerson方法
算法导论20（van Emde Boas 树）
Jiajun Zhu
05-19 2549
#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 2072
25.1最短路径和矩阵乘法
算法导论29（线性规划）
Jiajun Zhu
06-30 1956
29.1 标准型和松弛型标准型： maximize:∑j=1ncjxjsubjectto:∑j=1naijxj≤bi,i=1,2,⋯,mxj≥0,j=1,2,⋯,n\begin{array}{l} {\rm{maximize:}}\quad \sum\limits_{j = 1}^n {{c_j}{x_j}} \\ {\rm{subject}}\;{\rm{to:}}\quad \sum\limi
算法导论复习重点：分治、动态规划与搜索策略
"这是一份关于《算法导论》期末复习的习题集，主要涵盖了算法、期末复习和黑皮书第三版中的习题。题目涉及了多种算法思想和方法，包括分治策略、动态规划、贪心法、回溯法等。" 1. 分治策略：二分搜索算法是分治...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值