码迷，mamicode.com
首页 > 其他好文 > 详细

动态规划题目

时间：2014-05-17 23:19:03      阅读：367      评论：0      收藏：0      [点我收藏+]

标签：blog   class   c   tar   ext   http   

动态规划算法，在T大某位老师的书中说就是递推+重复子问题。

动态规划算法的效率主要与重复子问题的处理有关。

 

典型的题目有 陪审团，最大公共子串问题

 

1，最大公共子串问题

 

这个是动态规划的基础题目。动态规划就是递推和重复子结构。

确定了递推关系后。找到一个能极大地减少重复运算的子结构至关重要。选的好了，时间效率会很好。

这个问题，不妨设第一个串为a，长度为n，第二个串为b，长度m。那么最长的子序列长度为f（n,m）

当a[n]=a[m]时

f(n,m)=1+f(n-1,m-1)

否则f(n,m)=max(f(n-1),f(m-1))

同时建立一个存储计算过的f（x,y)的矩阵，如果计算过了就直接使用

程序如下所示

 

 

[cpp] view plaincopy
 
  1. #include <iostream>  
  2. #define MAXLen 1000  
  3. char seq1[MAXLen];  
  4. char seq2[MAXLen];  
  5. int maxLen[MAXLen][MAXLen];  
  6. int MaxCommonMain()  
  7. {  
  8.     while(scanf("%s%s",seq1+1,seq2+1)>0)  
  9.     {  
  10.       
  11.     int length1=strlen(seq1+1);  
  12.     int length2=strlen(seq2+1);  
  13.       
  14.       
  15.     for(int i=0;i<=length1;i++)  
  16.       maxLen[i][0]=0;  
  17.     for(int j=0;j<=length2;j++)  
  18.       maxLen[0][j]=0;  
  19.         
  20.       
  21.         
  22.         
  23.     for(int i=1;i<=length1;i++)  
  24.     {  
  25.       for(int j=1;j<=length2;j++)  
  26.       {  
  27.        if(seq1[i]==seq2[j])  
  28.          maxLen[i][j]=maxLen[i-1][j-1]+1;  
  29.        else  
  30.          maxLen[i][j]=maxLen[i-1][j]>maxLen[i][j-1]?maxLen[i-1][j]:maxLen[i][j-1];  
  31.       }  
  32.     }  
  33.       
  34.     printf("%d/n",maxLen[length1][length2]);  
  35.       
  36.     // printf("%d",maxLen[length2-1][length1-1]);  
  37.       
  38. }  
  39.     return 0;  
  40. }  

 

 

 

2，陪审团问题

问题描述：

问题描述
在遥远的国家佛罗布尼亚，嫌犯是否有罪，须由陪审团决定。陪审团是由法官从公众中
挑选的。先随机挑选n 个人作为陪审团的候选人，然后再从这n 个人中选m 人组成陪审团。
选m 人的办法是：
控方和辩方会根据对候选人的喜欢程度，给所有候选人打分，分值从0 到20。为了公
平起见，法官选出陪审团的原则是：选出的m 个人，必须满足辩方总分和控方总分的差的
绝对值最小。如果有多种选择方案的辩方总分和控方总分的之差的绝对值相同，那么选辩控
双方总分之和最大的方案即可。最终选出的方案称为陪审团方案。
输入数据
输入包含多组数据。每组数据的第一行是两个整数n 和m，n 是候选人数目，m 是陪审
团人数。注意，1<=n<=200, 1<=m<=20 而且 m<=n。接下来的n 行，每行表示一个候选人
的信息，它包含2 个整数，先后是控方和辩方对该候选人的打分。候选人按出现的先后从1
开始编号。两组有效数据之间以空行分隔。最后一组数据n=m=0
输出要求
对每组数据，先输出一行，表示答案所属的组号, 如 ‘Jury #1‘, ‘Jury #2‘, 等。接下来的
一行要象例子那样输出陪审团的控方总分和辩方总分。再下来一行要以升序输出陪审团里每
个成员的编号，两个成员编号之间用空格分隔。每组输出数据须以一个空行结束。
输入样例
4 2
1 2
2 3
4 1
6 2
0 0
输出样例
Jury #1
Best jury has value 6 for prosecution and value 4 for defence:
2 3

 

用动态规划来解

动态规划可以看成是重复子问题+递归

设p为控方向量，d为辩方向量

评分从-400到400
f（j，k）为选取第j个人，评分差为k的辩控总分
对于任意的i，i大于0小于n，则有
f(j,k)=f(j-1+1,x+p[i]-d[i])
则就有
f(j,k)=f(j-1,x)+p[i]+d[i];

如果新的f（j,k)大于旧的，则替换旧的，否则不替换

初始值为k=0，在程序中或许是某个值，以免避免序号k出现负值。
那么初始的f（0,0）=0；
在第一轮的时候只有辩控差为0的合理
对所有的候选人做
f（1，p[i]-d[i])=max(f(1,p[i]-d[i]),f(0,0)+p[i]+d[i]);
这样就可以完成选一个人的操作。
做完之后离k=0最近的非负的就是我们要的最大的辩控和。下标就是辩控差。
同理，如果选两个的话，第二轮
k=-400~400
如果f（1，k）合理（此时，只有在第一轮中算出来的合理）
f(2，k+p[i]-d[i])=max(f(2,k+p[i]-d[i]),f(1,k)+p[i]+d[i]);

如果要保存搜索得到的路径
设路径path保存路径向量
path（j,k）保存推荐第j个陪审员时候，辩控差为k的候选人。
对应上面的f函数，初始值都设为0。
如果只找一个候选人
则本身path中没有任何的值，即没有推荐任何的人。也就是说，推荐第一个人的时候，谁都可以（若推荐第二个人，则以前推荐过的不能再次推荐）
在推荐第一个候选人的时候，只管保存path[0][p[i]-d[i]]=i ;

当选取多个候选人的时候，在更新f(j,k)的同时更新path，因为更新f（j,k）的同时，意味着选了新的候选人，所以需要更新路径


当以上都做完之后，
定义一个数组result来取路径
对i:1~m
 result[i]=path[m-i+1][k];
 k=k-p[result[i]]+d[result[i]];
这样就都解决了。

 

[cpp] view plaincopy
 
  1. #include<stdlib.h>  
  2. #include<iostream>  
  3. #include<memory.h>  
  4. int p[300];  
  5. int d[300];  
  6. int path[30][1000];  
  7. int f[30][1000];  
  8. int result[30];  
  9. int compareInt(const void *el, const void *e2)  
  10. {  
  11.     return *((int *)el)-*((int *)e2);  
  12. }  
  13. int jurymain()  
  14. {  
  15.     int n,m;  
  16.     scanf("%d%d",&n,&m);  
  17.        int no=0;  
  18.        int i=0;  
  19.     while(n+m)//n=0,m=0结束条件   
  20.     {  
  21.     no++;  
  22.       for(i=1;i<=n;i++)  
  23.         scanf("%d%d",&p[i],&d[i]);  
  24.       memset(f,-1,sizeof(f));   
  25.       memset(path,0,sizeof(path));  
  26.       int minD=20*m;  
  27.       f[0][minD]=0;  
  28.       for(int j=0;j<m;j++)  
  29.       {        
  30.        for(int k=0;k<=minD*2;k++)  
  31.        {  
  32.                  if(f[j][k]>=0)  
  33.                 {  
  34.                               i=1;  
  35.                               int temp1;  
  36.                               int temp2;  
  37.                               for(;i<=n;i++)  
  38.                               {  
  39.                                if(f[j][k]+p[i]+d[i]>f[j+1][k+p[i]-d[i]])  
  40.                                {  
  41.                                   temp1=j;  
  42.                                   temp2=k;  
  43.                                   while(temp1>0&&path[temp1][temp2]!=i)  
  44.                                   {   
  45.                                                                          
  46.                                     temp2=temp2-p[path[temp1][temp2]]+d[path[temp1][temp2]];  
  47.                                     temp1--;  
  48.                                      
  49.                                   }   
  50.                               if(temp1==0)  
  51.                               {  
  52.                                f[j+1][k+p[i]-d[i]]=f[j][k]+p[i]+d[i];  
  53.                                path[j+1][k+p[i]-d[i]]=i;  
  54.                               }  
  55.                            }   
  56.                                 
  57.                               
  58.                  }  
  59.                }  
  60.        }  
  61.       }  
  62.      i=minD;  
  63.      int j=0;  
  64.      int k=0;  
  65.       while(f[m][i+j]<0&&f[m][i-j]<0)  
  66.        j++;  
  67.        if(f[m][i+j]>f[m][i-j])  
  68.        k=i+j;  
  69.        else  
  70.        k=i-j;  
  71.          
  72.        printf("Jury #%d/n",no);  
  73.       printf("Best jury has value %d for prosecution and value %d for defence:/n",(k-minD+f[m][k])/2,(minD-k+f[m][k])/2);  
  74.       
  75.         
  76.       for(i=1;i<=m;i++)  
  77.       {  
  78.               result[i]=path[m-i+1][k];  
  79.               k-=p[result[i]]-d[result[i]];  
  80.             //  std::cout<<"result "<<i<<" "<<result[i]<<std::endl;  
  81.       }  
  82.       qsort(result+1,m,sizeof(int),compareInt);  
  83.       for(i=1;i<=m;i++)  
  84.       printf("%d ",result[i]);  
  85.       printf("/n/n");  
  86.       scanf("%d%d",&n,&m);  
  87.         
  88.     }  
  89.     //system("pause");  
  90.     return 0;  
  91. }  

 

 

3，小花店问题

F束花从左到右放在V个花瓶里面（1<=F<=V<=100)，花要按照花的标志数从小到大排列。不同的花在不同的花瓶能够产生不同的美学价值。v[i,j]来表示第i朵花在第j个花瓶产生的美学价值。求把n朵花放在m个花瓶能够产生的最大的美学价值。

这个题和最大公共子串的思考角度相似。由于花必须要小于等于瓶子。而且花的编号由小到大，不能乱序。例如就不能把出现【2，4】 【1，5】这种现象。也就是说插在花瓶中的花按照花瓶的顺序，序号升序排列。

  不妨用f(i,j)来表示把前i朵花插入前个瓶子中。当i=j时，f(i,j)=v[1,1]+v[2,2]+...+v[i,i];

当i=0时，f(0,j)=0; 当i!=j, 且i!=0时f(i,j)=max(f(i,j-1),f(i-1,j-1)+v[i,j]) ,i<=j-1.

 

[cpp] view plaincopy
 
  1. #include <stdlib.h>  
  2. #include <stdio.h>  
  3. void getMaxValue(int **f,int **v,int m,int n)  
  4. {  
  5.        
  6.        
  7.        
  8.        
  9.     for(int j=1;j<=m;j++)  
  10.     {  
  11.             for(int i=1;i<=j-1;i++)  
  12.             {  
  13.               if(f[i-1][j-1]+v[i][j]>f[i][j-1])  
  14.                  f[i][j]=f[i-1][j-1]+v[i][j];  
  15.               else  
  16.                  f[i][j]=f[i][j-1];  
  17.             }  
  18.     }  
  19.       
  20.       
  21. }  
  22. int main()  
  23. {  
  24.     int n,m;  
  25.     scanf("%d%d",&n,&m);  
  26.     int **v=new int[n+1][m+1];  
  27.     int **f=new int[n+1][m+1];  
  28.     v[0][0]=0;  
  29.     for(int i=1;i<=n;i++)  
  30.      for(int j=1;j<=m;j++)  
  31.     scanf("$d",v[i][j]);  
  32.       
  33.     for(int j=0;j<=m;j++)  
  34.     v[0][j]=0;  
  35.       
  36.     int tempSum=0;  
  37.     for(int i=0;i<=n;i++)  
  38.     {  
  39.             sum+=v[i][i];  
  40.             f[i][i]=sum;  
  41.     }  
  42.     getMaxValue(f,v,m,n);  
  43.        
  44.     delete(v);  
  45.     return 0;  
  46.       
  47. }  

 

 

 4,最佳旅行线问题

简单描述：某航空公司给的奖品，一张免费的机票。可以从最西边的一个城市出发，必须到达最东边的一个城市，然后返回起点城市。每个城市职能经过一次，起点被访问2次。问最多能够访问多少个城市。

这个题可以使用动态规划的方法。这个题目也使我想起了《算法导论》中装配线的问题，其实基本是一致的。

在很多的书或者是解法中，都用了这样的方法：从起点开始，两条路一起走f[i,j]表示两条不相交的路线分别到达i和j时，所需乘坐航线的最大值

f(1,1)=0;

f(i,j)= max{f(k,j)}+1,i>j ;k是i的前驱节点。

         max{f(i,k)}+1,i<j

f(i,i)无意义

该算法是没有错的。很多地方也用这个算法做了一些程序版本。但是这个算法有一个限制，就是前驱节点。在t大某位老师的书中，他枚举所有的点对，然后对f矩阵进行更新（传统的动态规划方法）。但是他这个有一个前提，那就是所有节点的序号符合拓扑序列。但是题目中并没有说城市符合拓扑序列。假如说序号比较随意，t大的这本书中的就错了。但是他并没有在代码中说明，算是对读者的一个误导。

 

[cpp] view plaincopy
 
  1. #ifndef TICKETAWARD_H  
  2. #define TICKETAWARD_H  
  3. class TicketAward  
  4. {  
  5. int *b;//度数  
  6. int **g;//g(i,j)表示第i个点的第j个孩子  
  7. int **f;//函数f  
  8. int n;//总共有n个节点  
  9. public:  
  10.     TicketAward();  
  11.     int max(int x,int y);  
  12. };  
  13. #endif  

 

 

 

[cpp] view plaincopy
 
  1. #include "stdafx.h"  
  2. #include <iostream>  
  3. #include "TicketAward.h"  
  4. TicketAward::TicketAward()  
  5. {  
  6.     std::cin>>n;  
  7.     g=new int *[n+1];  
  8.     b=new int[n+1];  
  9.     f=new int*[n+1];  
  10.     for(int i=1;i<=n;i++)  
  11.     {  
  12.         g[i]=new int[n+1];  
  13.         f[i]=new int[n+1];  
  14.         b[i]=0;  
  15.         for(int j=1;j<=n;j++)  
  16.         {  
  17.               
  18.         }  
  19.     }  
  20.     int temp=0;  
  21.     for(int i=1;i<=n;i++)  
  22.     {  
  23.         std::cin>>temp;//输入i的第一个孩子，如果不为0，即就是存在孩子节点，则继续  
  24.         while(temp!=0)  
  25.         {  
  26.             b[i]++;  
  27.             g[i][b[i]]=temp;  
  28.             std::cin>>temp;  
  29.         }  
  30.     }  
  31.     f[1][1]=0;  
  32.     for(int i=1;i<=n;i++)  
  33.     {  
  34.       
  35.         for(int j=1;j<=b[i];j++)  
  36.         {  
  37.             if(i==j==1)  
  38.                 continue;  
  39.             if(i<j)  
  40.             for(int k=1;k<=b[i];k++)  
  41.             {  
  42.                 f[i][j]=max(f[i][j],(f[g[i][k]][j]+1));  
  43.             }  
  44.             if(i>j)  
  45.             for(int k=1;k<=b[j];k++)  
  46.             {  
  47.                 f[i][j]=max(f[i][j],(f[g[j][k]][j]+1));  
  48.             }  
  49.         }  
  50.     }  
  51.         std::cout<<(f[n][n]-2);  
  52. }  
  53. int TicketAward::max(int x, int y)  
  54. {  
  55.     return x>y?x:y;  
  56. }  

 

 

 

 

5, 最长词链问题

给定一个仅仅包含小写字母的英文单词表，其中每个单词至少包含一个字母，最多包含75个字母，且按照字典序排列。所有单词包含的单词个数之和不超过200w

     如果在一张由一个单词或者多个单词组成的表中，每个单词都被其后的一个单词所包含，则成此表为一个链。

     现在要求从单词表中找到一个包含单词书最多的最长词链。

该问题可以由动态规划解。这让我想起了一个题：在一个连续的长字符串中，找出匹配次数最多的一个词组，不能有重叠。相同的方法。

令F（k）表示第k个单词的时候的最长的链。则F（k）=maxF（i）+1，i从1，到k-1，并且第i个单词是第k个的前缀。这儿问题就解了。

但是，对于这道题还有其他的解法。由于字典序并非乱序。每个单词的前一个单词所包含的前缀很可能就是这个单词的前缀，并且前一个单词也可能就是该单词的前缀。因为前缀的特殊性。所以只用检查前一个单词的前缀（包括该单词本身）就能找出该前缀链

代码为非动态规划算法

 

[cpp] view plaincopy
 
  1. #include "stdafx.h"  
  2. #ifndef MOSTLENGTHLETTER_H  
  3. #define MOSTLENGTHLETTER_H  
  4. #include <iostream>  
  5. #include <string>  
  6. struct Pnode  
  7. {  
  8.     int len;  
  9.     Pnode *next[26];  
  10. };  
  11. struct MostLengthLetters  
  12. {  
  13.        public:  
  14.            MostLengthLetters()  
  15.        {  
  16.          for(int i=0;i<=25;i++)  
  17.          {  
  18.              root.next[i]=NULL;  
  19.          }  
  20.          ans=0;  
  21.          std::cout<<"please input the num of words"<<std::endl;  
  22.          std::cin>>wordsNum;  
  23.           
  24.          this->getWords();  
  25.            
  26.        }  
  27.        void getWords();  
  28.        void update(std::string temp);  
  29.        int wordsNum;  
  30.        Pnode root;  
  31.        int ans;  
  32. };  
  33. void MostLengthLetters::getWords()  
  34. {  
  35.     std::string temp;  
  36.     for(int i=0;i<this->wordsNum;i++)  
  37.     {  
  38.         std::cin>>temp;  
  39.         this->update(temp);  
  40.     }  
  41. }  
  42. void MostLengthLetters::update(std::string temp)  
  43. {  
  44.     int len=temp.length();  
  45.     Pnode p=root;  
  46.     int max=0;  
  47.     int i=1;  
  48.     int tempInt=0;  
  49.     while(i<len)  
  50.     {  
  51.         tempInt=temp[i]-‘a‘;  
  52.         if(p.next[i]==NULL)  
  53.         {  
  54.             Pnode *node=new Pnode;  
  55.             node->len=0;  
  56.             for(int j=0;j<=25;j++)  
  57.             {  
  58.                 node->next[j]=NULL;  
  59.             }  
  60.         }  
  61.         if(max<p.len)  
  62.             max=p.len;  
  63.         i++;  
  64.         p=*p.next[tempInt];  
  65.     }  
  66.     p.len=max+1;  
  67.     this->ans=p.len;  
  68.     return;  
  69. }  
  70. #endif  

 

6, 整数划分问题

给定一个自然数，分成k部分，A1，A2..的数的和，要求A1<=A2...求有多少种？

 

 

原理：整数n拆分成最多不超过m个数的和的拆分数，和n 拆分成最大不超过m的拆分数相等。
根据这个原理，原问题就转化成了求最大拆分为k的拆分个数与最大拆分为k-1的拆分个数的差
f(n,k)=f(n,k-1)+f(n-k,k)。
[cpp] view plaincopy
 
  1. #include "stdafx.h"  
  2. #ifndef SPLITTOKNUM_H  
  3. #define SPLITTOKNUM_H  
  4. #include<iostream>  
  5. #include <memory.h>  
  6. #define MaxN 100  
  7. class SplitToKNum  
  8. {  
  9.       
  10. public:  
  11.     SplitToKNum()  
  12.     {  
  13.         std::cin>>n;  
  14.         std::cin>>k;  
  15.         memset(f,0,sizeof(f));  
  16.         for(int i=1;i<=k;i++)  
  17.         {  
  18.             f[MaxN][i]=1;  
  19.         }  
  20.         for(int j=1;j<=k;j++)  
  21.             for(int i=MaxN+1;i<=MaxN+n;i++)  
  22.                 f[i][j]=f[i][j-1]+f[i-j][j];  
  23.         std::cout<<f[n+MaxN][k]-f[n+MaxN][k-1]<<std::endl;  
  24.           
  25.     }  
  26.     int n;  
  27.     int k;  
  28.     int f[2*MaxN+1][MaxN];  
  29. };  
  30. #endif  
 
同时附上ferrer图的几个原理：
a，整数n拆分成k个数的和的拆分数，和数n拆分最大数位k的拆分数相等
b，整数n拆分成最多不超过m个数的和的拆分数，和n拆分成最大不超过m的拆分数相等。
c，整数n拆分成互不相同的若干奇数的和的的拆分数,和n拆分成自共轭的Ferrers图像的拆分数相等.

7,青蛙的烦恼

池塘里面有n片荷花，正好形成一个凸多边形，按照顺时针方向将这n片和也顺次编号为1，2，3，4，5...，n。一只青蛙想要跳过这些荷叶，每个只能跳过一次，希望跳过的距离最短。

输入荷叶数n，每片荷叶的坐标xy，输出最短距离。

分析：凸多边形，首先不能出现交叉路，否则，由两边之和大于第三边可以知道，这样实际上是路程变长了。

其次，直接按照凸多边形也不正确，可以参考平行四边形，其中一个角为30度，请自行画图查明。

 

方法：每次每个顶点只能到与自己相邻的两个中的一个（到其他顶点边会出现交叉），剩下的n-1个顶点也遵从这一规则。则可以使用动态规划的方法。

 

从s到L

则如果从s出发，则f(s,L,0)=min{dis(s，s+1)+f(s+1,L-1,0),f(s+1,L-1,1)+dis(s+L-1,s)}

如果从s+L-1出发则f(s,L,1)=min{dis(s,s+L-1)+f(s+L-1,L-1,0),f(s+L-1,L-1,0)+dis(s+L-1,s)}

 

[cpp] view plaincopy
 
  1. #include <stdlib.h>  
  2. #include <stdio.h>  
  3. #include <iostream>  
  4. #define MAXN 1000  
  5. double x[MAXN];// x radix  
  6. double y[MAXN];  
  7. double dis[MAXN][MAXN];  
  8. int n;// the num of   
  9. double f[MAXN][2][2];  
  10. double min(double a,double b)  
  11. {  
  12.  return a<b?a:b;  
  13. }  
  14. int main()  
  15. {  
  16.     std::cout<<"please input the num of the points"<<std::endl;  
  17.     std::cin>>n;  
  18.     for(int i=0;i<n;i++)  
  19.     {  
  20.         std::cin>>x[i]>>y[i];  
  21.     }  
  22.     for(int i=0;i<n-1;i++)  
  23.     {  
  24.         for(int j=i+1;j<n;j++)  
  25.         {  
  26.           dis[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);  
  27.           dis[j][i]=dis[i][j];  
  28.         }  
  29.     }  
  30.     int sign=0;  
  31.     double ans=1000000;  
  32.     for(int j=1;j<=n;j++)  
  33.     {  
  34.      sign=1-sign;  
  35.      for(int i=n-1;i>=0;i--)  
  36.      {  
  37.         if(j==1)  
  38.         {  
  39.         f[i][sign][0]=0;  
  40.         f[i][sign][1]=0;  
  41.         }  
  42.             else  
  43.         {  
  44.          f[i][sign][1]=min(f[(i+1)%n][1-sign][1]+dis[i][(i+1)%n],f[(i+1)%n][1-sign][0]+dis[i][(i+j-1)%n]);  
  45.          f[i][sign][0]=min(f[i][1-sign][1]+dis[(i+j-1)%n][i],f[i][1-sign][0]+dis[(i+j-1)%n][(i+j-2)%n]);      
  46.         }  
  47.         if(j==n)  
  48.         ans=min(ans,f[i][sign][1]);  
  49.      }  
  50.     }  
  51.     //std::cout<<f[1][sign][1]<<"/t"<<f[1][sign][0]<<std::endl;  
  52.     std::cout<<ans<<std::endl;  
  53.       
  54.     return 0;  
  55. }  

 

 

8排列问题

 

在整数1，2，。。。，n中，有些排列满足下面的性质：该排列中除了最后一个数字以外，每个整数后面都跟有一个同它相差为1的整数。例如：N=4，排列1432满足上述性质。求，如果 任意指定p个位置的值，求最多有几个排列满足如上性质

 

这种排列满足一下两条性质

a，任何一个排列的后k位是若干连续整数的集合

b,如果一个排列的后k位（1<=k<=n)是软干连续整数组成的集合，则这个排列满足题目所述的性质。

 

动态规划的方法即可。设s为起始的数的大小，r为连续的多少数的个数

则

 

g(s,r)=g(s+1,j-1),若第1个位置为s，即倒数第j个位置为s

   g(s,j-1),若第1个位置为s+r-1，即倒数的第j个位置为s+r-1

   不确定则为上述两个之和

 

代码如下

 

[cpp] view plaincopy
 
  1. #include <stdlib.h>  
  2. #include <iostream>  
  3. #include <memory.h>  
  4. class RankProgram  
  5. {  
  6. public:  
  7.         RankProgram()  
  8.         {  
  9.          std::cout<<"please input the testing data"<<std::endl;  
  10.          std::cin>>n>>p;  
  11.          s=new int[n+2];  
  12.          g=new int* [n+2];  
  13.          for(int i=0;i<=n+1;i++)  
  14.          {  
  15.           g[i]=new int[n+2];  
  16.          memset(g[i],0,sizeof(int)*(n+2));  
  17.          g[i][1]=1;  
  18.          }  
  19.          memset(s,0,sizeof(int)*(n+2));  
  20.          int tempData;  
  21.          int tempP;  
  22.         for(int i=1;i<=p;i++)  
  23.         {  
  24.          std::cin>>tempP>>tempData;  
  25.          s[n-tempP+1]=tempData;  
  26.         }  
  27.         for(int i=n;i>=1;i--)  
  28.         {  
  29.          for(int j=2;j<=n-i+1;j++)  
  30.         {  
  31.            if(s[j]==i)  
  32.                 g[i][j]=g[i+1][j-1];  
  33.            else if(s[j]==(i+j-1))  
  34.                 g[i][j]=g[i][j-1];  
  35.            else   
  36.                 g[i][j]=g[i+1][j-1]+g[i][j-1];  
  37.         }  
  38.         }  
  39.          std::cout<<g[1][n]<<std::endl;  
  40.         }  
  41.         ~RankProgram()  
  42.         {  
  43.          delete [] s;  
  44.         for(int i=0;i<=n+1;i++)  
  45.         delete [] g[i];  
  46.         delete [] g;  
  47.         }  
  48. private:  
  49.         int *s;  
  50.         int **g;  
  51.         int p;  
  52.         int n;  
  53. };  
  54. int main()  
  55. {  
  56.  RankProgram rp;  
  57. }  

 

 

9，画室问题

 

实际上该题可以描述为，给定一个尺寸为N的矩阵，行和列宽度为2^N,将该矩阵分为4分，左上角不为零，其他三部分都包含零。递归定义这三部分，直到最小单位，即矩阵只有一个数，为0；

求如果让该矩阵移动一个尺寸(x，y)，两个矩阵重复部分的0的个数。

 

思考：实际上就是判断移动前和移动后对应的位置是否都为0，如果都为0，则总0个数+1。

如果移动到了左上角的位置则不加，其他三部分因为是一样的，该部分递归定义的上层+1

 

在下面的程序中，k1,k2 表示的位置，在当前区域的哪一块

a,b表示三个区域，其中左上的直接被忽略了。

kk1，kk2，表示移动到的了哪一个区域

if(!((a+p[i-1]+k1)%2==0&&(b+q[i-1]+k2)%2==1))表示移动到的区域的哪一块，如果是左上直接忽略

 

 

 

[c-sharp] view plaincopy
 
  1. #ifndef MATRIXMOVE_H  
  2. #define MATRIXMOVE_H  
  3. #include <iostream>  
  4. #include <memory.h>  
  5. #define MAXN 101  
  6. class MatrixMove  
  7. {  
  8. public:  
  9.     MatrixMove()  
  10.     {  
  11.         std::cin>>n;  
  12.           
  13.         memset(f,0,sizeof(f));  
  14.         f[n+1][0][0]=1;  
  15.         f[n+1][0][1]=f[n+1][1][0]=f[n+1][1][1]=0;  
  16.         std::cin>>x>>y;  
  17.         for(int i=1;i<=n;i++)  
  18.         {  
  19.             p[n-i+1]=x%2;  
  20.             q[n-i+1]=y%2;  
  21.             x=x/2;  
  22.             y=y/2;  
  23.         }  
  24.         for(int i=n+1;i>=2;i--)  
  25.         {  
  26.             for(int k1=0;k1<=1;k1++)  
  27.                 for(int k2=0;k2<=1;k2++)  
  28.                     for(int a=0;a<=1;a++)  
  29.                         for(int b=0;b<=1;b++)  
  30.                         {  
  31.                             if(!(a==0&&b==1))  
  32.                             {  
  33.                                 int kk1=(a+p[i-1]+k1)/2;  
  34.                                 int kk2=(b+q[i-1]+k2)/2;  
  35.                                 if(!((a+p[i-1]+k1)%2==0&&(b+q[i-1]+k2)%2==1))  
  36.                                 {  
  37.                                     f[i-1][kk1][kk2]+=f[i][k1][k2];  
  38.                                 }  
  39.                             }  
  40.                         }  
  41.         }  
  42.         std::cout<<f[1][0][0]<<std::endl;  
  43.     }  
  44. private:  
  45.     int n;  
  46.     int x;  
  47.     int y;  
  48.     int f[MAXN][2][2];  
  49.     int p[MAXN];  
  50.     int q[MAXN];  
  51. };  
  52. #endif  

 

 

 

10, 中世纪剑士

n个人决斗，两两之间有强弱关系，强弱关系不传递，例如a>b,b>c,c>a。n个剑士围成一个圈，一次抽签，抽中的人和他右边的人决斗，输了的人出圈。现在问是否存在一种决斗方式让第k个人生出，计算可能胜出的的人数和方案。

 

这个题目让我想起了围成一个圈的猴子的题目，那个题目是约瑟夫问题。

 

和这个不一样。

 

这个题目：一个人要胜出，则要胜了所有右边的人，同时也要胜出左边的人。因为是围成一个圈，所以该人胜出的话，最终肯定是自己跟自己相遇。那么，这种情况下，把圈展开成一个链，将该链延长一倍，如果i和i+n可以相遇，则说明i可以胜出。i人向右决斗，i+n向左决斗

 

如果两个人可以相遇，用meet[i,j]来表示

meet[i,j]= true if meet[i,k] and meet[k,j] and (e[i,k] or e[j,k])=true

false

 

[cpp] view plaincopy
 
  1. #ifndef ACIENTSOLDIER_H  
  2. #define ACIENTSOLDIER_H  
  3. #include <iostream>  
  4. #include <memory.h>  
  5. class AcientSoldier  
  6. {  
  7. public:  
  8.     AcientSoldier()  
  9.     {  
  10.         std::cin>>n;  
  11.         a=new int*[n+1];  
  12.         meet=new bool*[2*n+1];  
  13.         for(int i=1;i<=n;i++)  
  14.         {  
  15.             a[i]=new int[n+1];  
  16.             meet[i]=new bool[2*n+1];  
  17.             meet[i+n]=new bool[2*n+1];  
  18.             memset(meet[i],0,sizeof(bool)*(2*n+1));  
  19.             memset(meet[i+n],0,sizeof(bool)*(2*n+1));  
  20.             meet[i][i+1]=true;  
  21.             meet[i+1][i]=true;  
  22.             meet[i+n][(i+n)%2+1]=true;  
  23.             meet[(i+n)%2+1][i+n]=true;  
  24.             for(int j=1;j<=n;j++)  
  25.                 std::cin>>a[i][j];  
  26.         }  
  27.         for(int k=1;k<=2*n;k++)  
  28.             for(int i=1;i<=2*n;i++)  
  29.                 for(int j=1;j<=2*n;j++)  
  30.                 {  
  31.                     if((i<k)&&(j>k)&&meet[i][k]&&meet[k][j]&&a[(i-1)%n+1][(k-1)%n+1]&&a[(j-1)%n+1][(k-1)%n+1])  
  32.                     {  
  33.                         meet[i][j]=true;  
  34.                         meet[j][i]=true;  
  35.                     }  
  36.                 }  
  37.         ans=0;    
  38.         for(int i=1;i<=n;i++)  
  39.         {  
  40.             if(meet[i][i+n])  
  41.                 ans++;  
  42.         }  
  43.         std::cout<<ans<<std::endl;;  
  44.           
  45.           
  46.     }  
  47. private:  
  48.     int n;  
  49.     int **a;  
  50.     bool **meet;  
  51.     int ans;  
  52. };  
  53. #endif  

 

 

11, 科学家实验陨石

 

总共获得了n1块A星的和n2块B星的，每次实验需要各一块，实验完了后不能回收。

总共实验min（n1,n2）；

 

求每次试验的绝对值和的最小值

 

先证明一下两个递增序列，a1<b1,a2<b2,  |a2-a1|+|b2-b1|<=|b2-a1|+|b1-a2|

 

------a1----------------b1-------------

         - -

-

- O -

------a2----------------b2--------------

由上图根据两条边之和大于第三边可以直接证明上面的式子

 

所以就可以放心的使用动态规划了

对两列数据由小到大排序，少的用i表示，多的用j表示

F[i,j]=min(F[i,j-1],F[i-1][j-1]+dis(i,j))      j>i

  F[i-1][j-1]+dis(i,j)     j=i

 

编程暂时省略，因为这个题目比较简单

12,理想收入问题

只有一元的本金，知道每天的股价为v[i], 求M天之后的理想收入，能够获得的最大的收入

 

假设第i天的理想收入为F[i]

则有F[i]=max(F[j]/v[k])*v[i]; j<=k<i

令M[i]=max(F[j]/v[k])=max(M[i-1],MF[i-1]/v[i]);M[i]表示在第i天可以得到的最多股票数，MF[i-1]表示前i-1天可以取得的最大收入

MF[i]=Max(MF(i-1),F(i-1))

 

13. 一般的RMQ问题 (Range Minimum/Maximum Query)

 

对于给定的N与N个整数A[1...N]，M与M对下标(x,y)（x<=y)，对于每对下标(x,y)求出A[x...y]中最小数的下标
        解法：
                预处理，对于区间中每一个点A，设计以A为左端点的floor(logN)+1个区间
                [A,A+2^0-1], [A,A+2^1-1],...,[A, A+2^floor(logN)-1]
在求解的过程中，按照区间长度依次求解。[A,A+2^(i+1)-1]，可以通过两个等长的子区间[A,A+2^i-1]和[A+2^i,A+2^(i+1)-1];
       取用方法：
A，当区间的重叠对结果无影响的时候，例如求最大最小值（本题所述，则根据区间[A,A+2^k-1]与[B-2^k+1,B]来计算
B，当区间的重叠对结果有影响的时候，例如统计数字的多少等等，将[A,B]划分为[A,A+2^k-1],
[A+2^K,A+2^k+2^(floor(log(B-(A+2^k)+1)))-1],每次使用对数直接获得划分点。所以至多分成了floor(log(B-A+1))+1个区间。
所以这样处理的时间复杂度为logN
本题中，所述的所有对数，均是以2为底。
  本题中，开一个数组，行下标表示区间开始端A，列坐标表示区间结束端B

 

[cpp] view plaincopy
 
  1. #include "stdafx.h"  
  2. #include <iostream>  
  3. #include <math.h>  
  4. using namespace std;  
  5. class RMQProblem  
  6. {  
  7.     int N;  
  8.     int M;  
  9.     int *data;  
  10.     int **b;  
  11. public:  
  12.     RMQProblem()  
  13.     {  
  14.         cin>>N>>M;  
  15.         data=new int[N+1];  
  16.         b=new int*[N+1];  
  17.         int tempRankNum=int(floor(log2(double(N))))+1;  
  18.         for(int i=1;i<=N;i++)  
  19.         {  
  20.             cin>>data[i];  
  21.             b[i]=new int[tempRankNum];  
  22.             b[i][0]=data[i];  
  23.         }  
  24.         for(int j=1;j<=tempRankNum;j++)  
  25.         {  
  26.             int k=1<<j;  
  27.             int kk=1<<(j-1);  
  28.             for(int i=1;i<=N-k+1;i++)  
  29.             {  
  30.                 b[i][j]=min(b[i][j-1],b[i+kk][j-1]);  
  31.             }  
  32.         }  
  33.           
  34.         int tempX,tempY,tempZ;  
  35.         for(int i=1;i<=M;i++)  
  36.         {  
  37.             cin>>tempX>>tempY;  
  38.             tempZ=int(floor(log2(tempY-tempX)));  
  39.             cout<<min(b[tempX][tempZ],b[tempY-int(1<<tempZ)][tempZ]);  
  40.               
  41.         }  
  42.     }  
  43. double log2(double x)  
  44. {  
  45.       
  46.     return log(double(x))/log(2.0);  
  47. }  
  48. int min(int x,int y)  
  49. {  
  50.     return x<y?x:y;  
  51. }  
  52. };  
14, 关于分石子问题的动态规划解法

有n个石头，k个框子。把n个石头按顺序放入k个框子，比如1~3放入1，4~6放入2，要求最大重量的框子的重量最小的放法。

设石子的重量分别为Q1，Q2，...

g(i,j)=Qi+,...,+Qj;

f(i,j)表示把i个石子放到j个框的最大重量框的重量。

则f(i,j)=minj-1<=p<i (f(i,j),max(f(p,j-1),g(p+1,i)));

g(i,i)=Qi ,f(1,1)=g(1,1),f(i,1)=g(1,i);

1<=i<=n;

1<=j<=k;

如果提前把Si =Q1+,..,+Qi 计算出来，g(j,k)=Sk -Sj-1 则时间复杂度为O(N2 )

http://blog.csdn.net/duxingstar/article/details/6032411

动态规划题目,布布扣,bubuko.com

动态规划题目

标签：blog   class   c   tar   ext   http   

原文地址：http://www.cnblogs.com/berkeleysong/p/3734515.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！