動態規划算法。在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)的矩陣，假設計算過了就直接使用
程序例如以下所看到的
- #include <iostream>
- #define MAXLen 1000
- char seq1[MAXLen];
- char seq2[MAXLen];
- int maxLen[MAXLen][MAXLen];
- int MaxCommonMain()
- {
- while(scanf("%s%s",seq1+1,seq2+1)>0)
- {
- int length1=strlen(seq1+1);
- int length2=strlen(seq2+1);
- for(int i=0;i<=length1;i++)
- maxLen[i][0]=0;
- for(int j=0;j<=length2;j++)
- maxLen[0][j]=0;
- for(int i=1;i<=length1;i++)
- {
- for(int j=1;j<=length2;j++)
- {
- if(seq1[i]==seq2[j])
- maxLen[i][j]=maxLen[i-1][j-1]+1;
- else
- maxLen[i][j]=maxLen[i-1][j]>maxLen[i][j-1]?maxLen[i-1][j]:maxLen[i][j-1];
- }
- }
- printf("%d/n",maxLen[length1][length2]);
- // printf("%d",maxLen[length2-1][length1-1]);
- }
- return 0;
- }
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]];
這樣就都攻克了。
- #include<stdlib.h>
- #include<iostream>
- #include<memory.h>
- int p[300];
- int d[300];
- int path[30][1000];
- int f[30][1000];
- int result[30];
- int compareInt(const void *el, const void *e2)
- {
- return *((int *)el)-*((int *)e2);
- }
- int jurymain()
- {
- int n,m;
- scanf("%d%d",&n,&m);
- int no=0;
- int i=0;
- while(n+m)//n=0,m=0結束條件
- {
- no++;
- for(i=1;i<=n;i++)
- scanf("%d%d",&p[i],&d[i]);
- memset(f,-1,sizeof(f));
- memset(path,0,sizeof(path));
- int minD=20*m;
- f[0][minD]=0;
- for(int j=0;j<m;j++)
- {
- for(int k=0;k<=minD*2;k++)
- {
- if(f[j][k]>=0)
- {
- i=1;
- int temp1;
- int temp2;
- for(;i<=n;i++)
- {
- if(f[j][k]+p[i]+d[i]>f[j+1][k+p[i]-d[i]])
- {
- temp1=j;
- temp2=k;
- while(temp1>0&&path[temp1][temp2]!=i)
- {
- temp2=temp2-p[path[temp1][temp2]]+d[path[temp1][temp2]];
- temp1--;
- }
- if(temp1==0)
- {
- f[j+1][k+p[i]-d[i]]=f[j][k]+p[i]+d[i];
- path[j+1][k+p[i]-d[i]]=i;
- }
- }
- }
- }
- }
- }
- i=minD;
- int j=0;
- int k=0;
- while(f[m][i+j]<0&&f[m][i-j]<0)
- j++;
- if(f[m][i+j]>f[m][i-j])
- k=i+j;
- else
- k=i-j;
- printf("Jury #%d/n",no);
- 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);
- for(i=1;i<=m;i++)
- {
- result[i]=path[m-i+1][k];
- k-=p[result[i]]-d[result[i]];
- // std::cout<<"result "<<i<<" "<<result[i]<<std::endl;
- }
- qsort(result+1,m,sizeof(int),compareInt);
- for(i=1;i<=m;i++)
- printf("%d ",result[i]);
- printf("/n/n");
- scanf("%d%d",&n,&m);
- }
- //system("pause");
- return 0;
- }
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.
- #include <stdlib.h>
- #include <stdio.h>
- void getMaxValue(int **f,int **v,int m,int n)
- {
- for(int j=1;j<=m;j++)
- {
- for(int i=1;i<=j-1;i++)
- {
- if(f[i-1][j-1]+v[i][j]>f[i][j-1])
- f[i][j]=f[i-1][j-1]+v[i][j];
- else
- f[i][j]=f[i][j-1];
- }
- }
- }
- int main()
- {
- int n,m;
- scanf("%d%d",&n,&m);
- int **v=new int[n+1][m+1];
- int **f=new int[n+1][m+1];
- v[0][0]=0;
- for(int i=1;i<=n;i++)
- for(int j=1;j<=m;j++)
- scanf("$d",v[i][j]);
- for(int j=0;j<=m;j++)
- v[0][j]=0;
- int tempSum=0;
- for(int i=0;i<=n;i++)
- {
- sum+=v[i][i];
- f[i][i]=sum;
- }
- getMaxValue(f,v,m,n);
- delete(v);
- return 0;
- }
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大的這本書中的就錯了。可是他並沒有在代碼中說明。算是對讀者的一個誤導。
- #ifndef TICKETAWARD_H
- #define TICKETAWARD_H
- class TicketAward
- {
- int *b;//度數
- int **g;//g(i,j)表示第i個點的第j個孩子
- int **f;//函數f
- int n;//總共同擁有n個節點
- public:
- TicketAward();
- int max(int x,int y);
- };
- #endif
- #include "stdafx.h"
- #include <iostream>
- #include "TicketAward.h"
- TicketAward::TicketAward()
- {
- std::cin>>n;
- g=new int *[n+1];
- b=new int[n+1];
- f=new int*[n+1];
- for(int i=1;i<=n;i++)
- {
- g[i]=new int[n+1];
- f[i]=new int[n+1];
- b[i]=0;
- for(int j=1;j<=n;j++)
- {
- }
- }
- int temp=0;
- for(int i=1;i<=n;i++)
- {
- std::cin>>temp;//輸入i的第一個孩子。假設不為0，即就是存在孩子節點，則繼續
- while(temp!=0)
- {
- b[i]++;
- g[i][b[i]]=temp;
- std::cin>>temp;
- }
- }
- f[1][1]=0;
- for(int i=1;i<=n;i++)
- {
- for(int j=1;j<=b[i];j++)
- {
- if(i==j==1)
- continue;
- if(i<j)
- for(int k=1;k<=b[i];k++)
- {
- f[i][j]=max(f[i][j],(f[g[i][k]][j]+1));
- }
- if(i>j)
- for(int k=1;k<=b[j];k++)
- {
- f[i][j]=max(f[i][j],(f[g[j][k]][j]+1));
- }
- }
- }
- std::cout<<(f[n][n]-2);
- }
- int TicketAward::max(int x, int y)
- {
- return x>y?
x:y;
- }
5, 最長詞鏈問題
給定一個只包括小寫字母的英文單詞表。當中每一個單詞至少包括一個字母，最多包括75個字母。且依照字典序排列。
全部單詞包括的單詞個數之和不超過200w
假設在一張由一個單詞或者多個單詞組成的表中。每一個單詞都被其后的一個單詞所包括。則成此表為一個鏈。
如今要求從單詞表中找到一個包括單詞書最多的最長詞鏈。
該問題能夠由動態規划解。
這讓我想起了一個題：在一個連續的長字符串中。找出匹配次數最多的一個詞組，不能有重疊。同樣的方法。
令F（k）表示第k個單詞的時候的最長的鏈。
則F（k）=maxF（i）+1。i從1，到k-1，而且第i個單詞是第k個的前綴。這兒問題就解了。
可是，對於這道題還有其它的解法。
由於字典序並不是亂序。每一個單詞的前一個單詞所包括的前綴非常可能就是這個單詞的前綴，而且前一個單詞也可能就是該單詞的前綴。由於前綴的特殊性。所以僅僅用檢查前一個單詞的前綴（包括該單詞本身）就能找出該前綴鏈
代碼為非動態規划算法
- #include "stdafx.h"
- #ifndef MOSTLENGTHLETTER_H
- #define MOSTLENGTHLETTER_H
- #include <iostream>
- #include <string>
- struct Pnode
- {
- int len;
- Pnode *next[26];
- };
- struct MostLengthLetters
- {
- public:
- MostLengthLetters()
- {
- for(int i=0;i<=25;i++)
- {
- root.next[i]=NULL;
- }
- ans=0;
- std::cout<<"please input the num of words"<<std::endl;
- std::cin>>wordsNum;
- this->getWords();
- }
- void getWords();
- void update(std::string temp);
- int wordsNum;
- Pnode root;
- int ans;
- };
- void MostLengthLetters::getWords()
- {
- std::string temp;
- for(int i=0;i<this->wordsNum;i++)
- {
- std::cin>>temp;
- this->update(temp);
- }
- }
- void MostLengthLetters::update(std::string temp)
- {
- int len=temp.length();
- Pnode p=root;
- int max=0;
- int i=1;
- int tempInt=0;
- while(i<len)
- {
- tempInt=temp[i]-'a';
- if(p.next[i]==NULL)
- {
- Pnode *node=new Pnode;
- node->len=0;
- for(int j=0;j<=25;j++)
- {
- node->next[j]=NULL;
- }
- }
- if(max<p.len)
- max=p.len;
- i++;
- p=*p.next[tempInt];
- }
- p.len=max+1;
- this->ans=p.len;
- return;
- }
- #endif
6, 整數划分問題
給定一個自然數。分成k部分，A1，A2..的數的和，要求A1<=A2...求有多少種？
- #include "stdafx.h"
- #ifndef SPLITTOKNUM_H
- #define SPLITTOKNUM_H
- #include<iostream>
- #include <memory.h>
- #define MaxN 100
- class SplitToKNum
- {
- public:
- SplitToKNum()
- {
- std::cin>>n;
- std::cin>>k;
- memset(f,0,sizeof(f));
- for(int i=1;i<=k;i++)
- {
- f[MaxN][i]=1;
- }
- for(int j=1;j<=k;j++)
- for(int i=MaxN+1;i<=MaxN+n;i++)
- f[i][j]=f[i][j-1]+f[i-j][j];
- std::cout<<f[n+MaxN][k]-f[n+MaxN][k-1]<<std::endl;
- }
- int n;
- int k;
- int f[2*MaxN+1][MaxN];
- };
- #endif
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)}
- #include <stdlib.h>
- #include <stdio.h>
- #include <iostream>
- #define MAXN 1000
- double x[MAXN];// x radix
- double y[MAXN];
- double dis[MAXN][MAXN];
- int n;// the num of
- double f[MAXN][2][2];
- double min(double a,double b)
- {
- return a<b?
a:b;
- }
- int main()
- {
- std::cout<<"please input the num of the points"<<std::endl;
- std::cin>>n;
- for(int i=0;i<n;i++)
- {
- std::cin>>x[i]>>y[i];
- }
- for(int i=0;i<n-1;i++)
- {
- for(int j=i+1;j<n;j++)
- {
- dis[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
- dis[j][i]=dis[i][j];
- }
- }
- int sign=0;
- double ans=1000000;
- for(int j=1;j<=n;j++)
- {
- sign=1-sign;
- for(int i=n-1;i>=0;i--)
- {
- if(j==1)
- {
- f[i][sign][0]=0;
- f[i][sign][1]=0;
- }
- else
- {
- 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]);
- 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]);
- }
- if(j==n)
- ans=min(ans,f[i][sign][1]);
- }
- }
- //std::cout<<f[1][sign][1]<<"/t"<<f[1][sign][0]<<std::endl;
- std::cout<<ans<<std::endl;
- return 0;
- }
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
不確定則為上述兩個之和
代碼例如以下
- #include <stdlib.h>
- #include <iostream>
- #include <memory.h>
- class RankProgram
- {
- public:
- RankProgram()
- {
- std::cout<<"please input the testing data"<<std::endl;
- std::cin>>n>>p;
- s=new int[n+2];
- g=new int* [n+2];
- for(int i=0;i<=n+1;i++)
- {
- g[i]=new int[n+2];
- memset(g[i],0,sizeof(int)*(n+2));
- g[i][1]=1;
- }
- memset(s,0,sizeof(int)*(n+2));
- int tempData;
- int tempP;
- for(int i=1;i<=p;i++)
- {
- std::cin>>tempP>>tempData;
- s[n-tempP+1]=tempData;
- }
- for(int i=n;i>=1;i--)
- {
- for(int j=2;j<=n-i+1;j++)
- {
- if(s[j]==i)
- g[i][j]=g[i+1][j-1];
- else if(s[j]==(i+j-1))
- g[i][j]=g[i][j-1];
- else
- g[i][j]=g[i+1][j-1]+g[i][j-1];
- }
- }
- std::cout<<g[1][n]<<std::endl;
- }
- ~RankProgram()
- {
- delete [] s;
- for(int i=0;i<=n+1;i++)
- delete [] g[i];
- delete [] g;
- }
- private:
- int *s;
- int **g;
- int p;
- int n;
- };
- int main()
- {
- RankProgram rp;
- }
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))表示移動到的區域的哪一塊。假設是左上直接忽略
- #ifndef MATRIXMOVE_H
- #define MATRIXMOVE_H
- #include <iostream>
- #include <memory.h>
- #define MAXN 101
- class MatrixMove
- {
- public:
- MatrixMove()
- {
- std::cin>>n;
- memset(f,0,sizeof(f));
- f[n+1][0][0]=1;
- f[n+1][0][1]=f[n+1][1][0]=f[n+1][1][1]=0;
- std::cin>>x>>y;
- for(int i=1;i<=n;i++)
- {
- p[n-i+1]=x%2;
- q[n-i+1]=y%2;
- x=x/2;
- y=y/2;
- }
- for(int i=n+1;i>=2;i--)
- {
- for(int k1=0;k1<=1;k1++)
- for(int k2=0;k2<=1;k2++)
- for(int a=0;a<=1;a++)
- for(int b=0;b<=1;b++)
- {
- if(!(a==0&&b==1))
- {
- int kk1=(a+p[i-1]+k1)/2;
- int kk2=(b+q[i-1]+k2)/2;
- if(!((a+p[i-1]+k1)%2==0&&(b+q[i-1]+k2)%2==1))
- {
- f[i-1][kk1][kk2]+=f[i][k1][k2];
- }
- }
- }
- }
- std::cout<<f[1][0][0]<<std::endl;
- }
- private:
- int n;
- int x;
- int y;
- int f[MAXN][2][2];
- int p[MAXN];
- int q[MAXN];
- };
- #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
- #ifndef ACIENTSOLDIER_H
- #define ACIENTSOLDIER_H
- #include <iostream>
- #include <memory.h>
- class AcientSoldier
- {
- public:
- AcientSoldier()
- {
- std::cin>>n;
- a=new int*[n+1];
- meet=new bool*[2*n+1];
- for(int i=1;i<=n;i++)
- {
- a[i]=new int[n+1];
- meet[i]=new bool[2*n+1];
- meet[i+n]=new bool[2*n+1];
- memset(meet[i],0,sizeof(bool)*(2*n+1));
- memset(meet[i+n],0,sizeof(bool)*(2*n+1));
- meet[i][i+1]=true;
- meet[i+1][i]=true;
- meet[i+n][(i+n)%2+1]=true;
- meet[(i+n)%2+1][i+n]=true;
- for(int j=1;j<=n;j++)
- std::cin>>a[i][j];
- }
- for(int k=1;k<=2*n;k++)
- for(int i=1;i<=2*n;i++)
- for(int j=1;j<=2*n;j++)
- {
- 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])
- {
- meet[i][j]=true;
- meet[j][i]=true;
- }
- }
- ans=0;
- for(int i=1;i<=n;i++)
- {
- if(meet[i][i+n])
- ans++;
- }
- std::cout<<ans<<std::endl;;
- }
- private:
- int n;
- int **a;
- bool **meet;
- int ans;
- };
- #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)
- #include "stdafx.h"
- #include <iostream>
- #include <math.h>
- using namespace std;
- class RMQProblem
- {
- int N;
- int M;
- int *data;
- int **b;
- public:
- RMQProblem()
- {
- cin>>N>>M;
- data=new int[N+1];
- b=new int*[N+1];
- int tempRankNum=int(floor(log2(double(N))))+1;
- for(int i=1;i<=N;i++)
- {
- cin>>data[i];
- b[i]=new int[tempRankNum];
- b[i][0]=data[i];
- }
- for(int j=1;j<=tempRankNum;j++)
- {
- int k=1<<j;
- int kk=1<<(j-1);
- for(int i=1;i<=N-k+1;i++)
- {
- b[i][j]=min(b[i][j-1],b[i+kk][j-1]);
- }
- }
- int tempX,tempY,tempZ;
- for(int i=1;i<=M;i++)
- {
- cin>>tempX>>tempY;
- tempZ=int(floor(log2(tempY-tempX)));
- cout<<min(b[tempX][tempZ],b[tempY-int(1<<tempZ)][tempZ]);
- }
- }
- double log2(double x)
- {
- return log(double(x))/log(2.0);
- }
- int min(int x,int y)
- {
- return x<y?x:y;
- }
- };
有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 )