算法导论 动态规划

装配线调度:

 1 #include <iostream>
 2 #include <cstdio>
 3
 4 using namespace std;
 5
 6 int main()
 7 {
 8     int e1,e2,x1,x2,a1[7],a2[7];
 9     int f[2][7],fe,le,l[2][7],t1[7],t2[7];
10     scanf("%d%d",&e1,&e2);
11     scanf("%d%d",&x1,&x2);
12     for(int i=1;i<=6;i++)
13         scanf("%d",&a1[i]);
14     for(int i=1;i<=6;i++)
15         scanf("%d",&a2[i]);
16     for(int i=1;i<=5;i++)
17         scanf("%d",&t1[i]);
18     for(int i=1;i<=5;i++)
19         scanf("%d",&t2[i]);
20     f[1][1]=e1+a1[1];
21     f[2][1]=e2+a2[1];
22
23     for(int j=2;j<=6;j++)
24     {
25         if(f[1][j-1]+a1[j]<=f[2][j-1]+t2[j-1]+a1[j])
26         {
27             f[1][j]=f[1][j-1]+a1[j];
28             l[1][j]=1;
29         }
30         else
31         {
32             f[1][j]=f[2][j-1]+t2[j-1]+a1[j];
33             l[1][j]=2;
34         }
35
36         if(f[2][j-1]+a2[j]<=f[1][j-1]+t1[j-1]+a2[j])
37         {
38             f[2][j]=f[2][j-1]+a2[j];
39             l[2][j]=2;
40         }
41         else
42         {
43             f[2][j]=f[1][j-1]+t1[j-1]+a2[j];
44             l[2][j]=1;
45         }
46     }
47     if(f[1][6]+x1<=f[2][6]+x2)
48     {
49         fe=f[1][6]+x1;
50         le=1;
51     }
52     else
53     {
54         fe=f[2][6]+x2;
55         le=2;
56     }
57
58     printf("%d\n",fe);
59
60     int i=le;
61     printf("print line %d,station %d\n",i,6);
62     for(int j=6;j>=2;j--)
63     {
64         i=l[i][j];
65         printf("print line %d,station %d\n",i,j-1);
66     }
67     return 0;
68 }

源码实现

矩阵链乘法

 1 #include <iostream>
 2 #include <cstdio>
 3 #define inf 1e9
 4 using namespace std;
 5 int s[7][7];
 6 void print_optimal_parens(int i,int j)
 7 {
 8     if(i==j)
 9         printf("A%d",i);
10     else
11     {
12         printf("(");
13         print_optimal_parens(i,s[i][j]);
14         print_optimal_parens(s[i][j]+1,j);
15         printf(")");
16     }
17
18 }
19
20 int main()
21 {
22     int p[7];
23     for(int i=0;i<=6;i++)
24         scanf("%d",&p[i]);
25
26     int m[7][7];
27     for(int i=1;i<=6;i++)
28         m[i][i]=0;
29     for(int l=2;l<=6;l++)
30     {
31         for(int i=1;i<=6-l+1;i++)
32         {
33             int j=i+l-1;
34             m[i][j]=inf;
35             for(int k=i;k<=j-1;k++)
36             {
37                 int q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
38                 if(q<m[i][j])
39                 {
40                     m[i][j]=q;
41                     s[i][j]=k;
42                 }
43             }
44         }
45     }
46     printf("%d\n",m[1][6]);
47
48     print_optimal_parens(1,6);
49     return 0;
50 }

时间: 2024-10-24 06:59:55

算法导论 动态规划的相关文章

算法导论--动态规划(装配线调度)

装配线问题: 某个工厂生产一种产品,有两种装配线选择,每条装配线都有n个装配站.可以单独用,装配线1或2加工生产,也可以使用装配线i的第j个装配站后,进入另一个装配线的第j+1个装配站继续生产.现想找出通过工厂装配线的最快方法. 装配线i的第j个装配站表示为Si,j,在该站的装配时间是ai,j 如果从 Si,j装配站生产后,转移到另一个生产线继续生产所耗费的时间为ti,j 进入装配线花费时间ei,完成生产后离开装配线所耗费时间为xi 令f*表示通过生产所有路线中的最快的时间 令fi[j]表示从入

算法导论--动态规划(钢条切割)

钢条切割问题 现有一段长度为n英寸的钢条和一个价格表pi,求切割方案使销售利益最大rn最大 长度为n英寸的钢条共有2n?1种不同的切割方案,因为可以每个整英寸的位置都可以决定切割或者不切割. 为了得到rn最大,可以把这个问题分成子问题求解,先切一刀,再考虑余下的部分的最大收益即求 rn=max{pk+rn?k}(k=1,2,3-n-1), pk部分不进行继续切割,直接作为一个整体售出 ; rn?k部分继续切割,考虑所有的情况,分成子问题. 求出所有k值对应的收益最大者作为rn 也有可能不进行任何

算法导论--动态规划(矩阵链乘法)

矩阵链乘法问题 给定一个n个矩阵的序列?A1,A2,A3...An?,我们要计算他们的乘积:A1A2A3...An.因为矩阵乘法满足结合律,加括号不会影响结果.可是不同的加括号方法.算法复杂度有非常大的区别: 考虑矩阵链:?A1,A2,A3?.三个矩阵规模分别为10×100.100×5.5×50 假设按((A1A2)A3)方式,须要做10?100?5=5000次,再与A3相乘,又须要10?5?50=2500,共须要7500次运算: 假设按(A1(A2A3))方式计算.共须要100?5?50+10

算法导论--动态规划(最长公共子序列)

最长公共子序列问题(LCS) 给定两个序列X=?x1,x2,x3...xm?和Y=?y1,y2,y3...xn?,求X和Y的最长公共子序列. 例如:X=?A,B,C,B,D,A,B?,和Y=?B,D,C,A,B,A?,的最长公共子序列为?B,C,B,A?,长度为4: 对于此问题,可以采用暴力求解的方式来比对,即穷举出X的所有子序列,用每个子序列与y做一 一比较.假如X序列共有m个元素,对每个元素可以决定选或不选,则X的子序列个数共有2m个,可见与长度m呈指数阶,这种方法效率会很低. 动态规划 前

算法导论—动态规划

华电北风吹 天津大学认知计算与应用重点实验室 日期:2015/8/27 首先区分动态规划和分治策略. 这两者有很相似的地方,都是通过组合子问题的解来求解原问题.不同的是,分治策略将原问题划分为互不相交的子问题,递归的求解子问题,再将它们的解组合起来,求出原问题的解.与之相反,动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题(子问题的求解是递归进行的,将其划分为更小的子问题).在这种情况下,分治法会做许多不必要的工作,他会反复求解那些公共的子子问题.而动态规划算法对每个子子问题只求

算法导论动态规划 15.1-3 钢条切割问题

算法导论的第一个动态规划问题--钢条切割 我们知道钢条的长度和价格为: 长度i 1 2 3 4 5 6 7 8 9 10 价格pi 1 5 8 9 10 17 17 20 24 30 书上的两种方法已经很清楚,这里主要说一下课后练习里面15-3钢条成本加上切割成本,即要切割的次数最少.15-4返回切割方案 #include<fstream> #include<iostream> using namespace std; int main() { int const N = 11;

算法导论——动态规划

动态规划指的是一个问题可以拆分成多个小的最优子问题,并且这些子问题具有重叠,典型的如斐波那契数列:f(2)=f(1)+f(0),f(3)=f(2)+f(1),f(4)=f(3)+f(2),若使用简单的递归算法求f(4),则f(2)会被计算两次,当计算f(n)时需要计算f(n-1)和f(n-2)而f(n-1)又要计算记一次f(n-2),如此往复时间复杂度为n的指数级别,导致算法效率低下.若能够记录f(2)至f(n-1)的结果,可以保证每一级计算都是O(1)复杂度,整个算法的时间复杂度就能下降至O(

算法导论------------------动态规划之矩阵链问题

[问题描述] 给定有n个连乘矩阵的维数,要求计算其采用最优计算次序时所用的乘法次数,即所要求计算的乘法次数最少.例如,给定三个连乘矩阵{A1,A2,A3}的维数分别是10*100,100*5和5*50,采用(A1A2)A3,乘法次数为10*100*5+10*5*50=7500次,而采用A1(A2A3),乘法次数为100*5*50+10*100*50=75000次乘法,显然,最好的次序是(A1A2)A3,乘法次数为7500次. 分析: 矩阵链乘法问题描述: 给定由n个矩阵构成的序列[A1,A2,.

算法导论-动态规划-钢条切割

动态规划通常用于解决最优化问题,在这类问题中,通过做出一组选择来达到最优解.在做出每个选择的同时,通常会生成与原问题形式相同的子问题.当多于一个选择子集都生成相同的子问题时,动态规划技术通常就会很有效,其关键技术就是对每个这样的子问题都保存其解,当其重复出现时即可避免重复求解. 钢条切割问题 Serling公司购买长钢条,将其切割为短钢条出售.切割工序本身没有成本支出.公司管理层希望知道最佳的切割方案.假定我们知道Serling公司出售一段长为i英寸的钢条的价格为pi(i=1,2,…,单位为美元

算法导论-动态规划-装配线调度

动态规划(dynamic programming)是通过组合子问题的解而解决整个问题的.分治算法是指将问题划分为一些独立的子问题,递归地求解各子问题,然后合并子问题的解而得到原问题的解.动态规划适用于子问题不是独立的情况,也就是各子问题包含公共的子子问题.在这种情况下,若用分治法则会做许多不必要的工作,即重复地求解公共的子子问题.动态规划对每个子子问题只求解一次,将结果保存在一张表中,从而避免每次遇到各个子问题时重新计算答案. 动态规划通常应用于最优化问题.此类问题可能有很多种可行解,每个解有一