动态规划题目

动态规划算法，在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

posted on 2014-05-17 20:48  berkeleysong  阅读(242)  评论(0)  编辑  收藏  举报

导航