感觉动态规划非常模糊，怎么办呢？？？

狂刷题吧！！

！！

！

！！！

！

！！！

！！

！

！

！

。！！

。。！。！

PKU  PPt

动规解题的一般思路



1. 将原问题分解为子问题



                把原问题分解为若干个子问题，子问题和原问题形式同样或类似。仅仅只是规模变小了。

子问题都解决，原问题即解

决(数字三角形例）。

            子问题的解一旦求出就会被保存，所以每一个子问题仅仅需求解一次。

2. 确定状态



           在用动态规划解题时，我们往往将和子问题相关的各个变量的一组取值，称之为一个“状态”。

一个“状态”相应于一个或多个子问题，所谓某个“状态”下的“值”，就是这个“状态”所相应的子问题的解。

全部“状态”的集合。构成问题的“状态空间”。

“状态空间”的大小，与用动态规划解决这个问题的时间复杂度直接相关。

在数字三角形的样例里，一共同拥有N×(N+1)/2个数字。所以这个问题的状态空间里一共就有N×(N+1)/2个状态。

整个问题的时间复杂度是状态数目乘以计算每一个状态所需时间。

           在数字三角形里每一个“状态”仅仅须要经过一次。且在每一个状态上作计算所花的时间都是和N无关的常数。

           用动态规划解题，常常碰到的情况是，K个整型变量能构成一个状态（如数字三角形中的行号和列号这两个变量

构成“状态”）。

假设这K个整型变量的取值范围各自是N1, N2, ……Nk，那么。我们就能够用一个K维的数组array[N1] [N2]……[Nk]

来存储各个状态的“值”。

这个“值”未必就是一个整数或浮点数，可能是须要一个结构才干表示的。那么array就能够是一个结构数组。

一个“状态”下的“值”一般会是一个或多个子问题的解。

3. 确定一些初始状态（边界状态）的值

以“数字三角形”为例。初始状态就是底边数字，值就是底边数字值。

4. 确定状态转移方程



           定义出什么是“状态”，以及在该 “状态”下的“值”后，就要找出不同的状态之间怎样迁移――即怎样从一个或多个“值”

已知的“状态”，求出还有一个“状态”的“值”(“人人为我”递推型)。

状态的迁移能够用递推公式表示，此递推公式也可被称作“状态转移方程”。

数字三角形的状态转移方程:

能用动规解决的问题的特点



1) 问题具有最优子结构性质。

假设问题的最优解所包括的子问题的解也是最优的。我们就称该问题具有最优子结

构性质。

2) 无后效性。

当前的若干个状态值一旦确定。则此后过程的演变就仅仅和这若干个状态的值有关，和之前是採取哪

种手段或经过哪条路径演变到当前的这若干个状态，没有关系。

1、POJ 2479 Maximum sum

首刷水题！

！

！！

双向统计最大和。

AC代码例如以下：

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  4. #define inf -1000000000
  5. using namespace std;
  6. int main()
  7. {
  8.     int t;
  9.     scanf("%d",&t);
  10.     while(t--)
  11.     {
  12.         int n;
  13.         int i;
  14.         scanf("%d",&n);
  15.         int a[50005],dp[50005];
  16.         memset(dp,0,sizeof dp);
  17.         for(i=1;i<=n;i++)
  18.             scanf("%d",&a[i]);
  19.         int sum=0;
  20.         int maxx=inf;//须要取到负最小
  21.         for(i=1;i<n;i++)
  22.         {
  23.             sum+=a[i];
  24.             if(sum>maxx)
  25.                 maxx=sum;
  26.             dp[i]=maxx;
  27.             if(sum<0)
  28.                 sum=0;
  29.         }
  30.         int ans=inf;maxx=inf;sum=0;
  31.         for(i=n;i>1;i--)
  32.         {
  33.             sum+=a[i];
  34.             if(sum>maxx)
  35.                 maxx=sum;
  36.             ans=max(ans,maxx+dp[i-1]);
  37.             if(sum<0)
  38.                 sum=0;
  39.         }
  40.         cout<<ans<<endl;
  41.     }
  42.     return 0;
  43. }

2、HDU  2059  龟兔赛跑

  1. #include<iostream>
  2. using namespace std;
  3. #define M 10005
  4. #define MAX 0xfffff;
  5.  
  6. double min(double a,double b)
  7. {
  8.     return a<b?
  9.  
  10. a:b;
  11. }
  12.  
  13. int main()
  14. {
  15.     double l,L;
  16.     int n,c;
  17.     double t,t1,t2,ti;
  18.     double vr,v1,v2;
  19.     double p[M],dp[M];
  20.     int i,j;
  21.     while(cin>>l)
  22.     {
  23.         cin>>n>>c>>t>>vr>>v1>>v2;
  24.         for(i=1,p[0]=0,p[n+1]=l;i<=n;i++)
  25.             cin>>p[i];
  26.         dp[0]=0;
  27.         t1=l/vr;t2=c/v1;
  28.         for(i=1;i<=n+1;i++)
  29.         {
  30.             dp[i]=MAX;
  31.             for(j=0;j<i;j++)
  32.             {
  33.                 L=p[i]-p[j];
  34.                 if(L>c)
  35.                     ti=t2+(L-c)/v2;
  36.                 else
  37.                     ti=L/v1;
  38.                 if(j)
  39.                     ti+=t;
  40.                 dp[i]=min(dp[i],dp[j]+ti);
  41.             }
  42.         }
  43.         if(dp[n+1]>t1)
  44.             cout<<"Good job,rabbit!"<<endl;
  45.         else
  46.             cout<<"What a pity rabbit!"<<endl;
  47.  
  48.     }
  49.     return 0;
  50. }

3、POJ   1458  Common Subsequence

区间动规，最长公共子序列

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  4. using namespace std;
  5.  
  6. int dp[1005][1005];
  7.  
  8. int main()
  9. {
  10.     int i,j;
  11.     int la,lb;
  12.     char a[1005],b[1005];
  13.     while (~scanf("%s%s",a,b))
  14.     {
  15.         la=strlen(a);
  16.         lb=strlen(b);
  17.         memset(dp,0,sizeof dp);
  18.         for(i=1;i<=la;i++)
  19.         for(j=1;j<=lb;j++)
  20.         {
  21.             if(a[i-1]==b[j-1])
  22.             {
  23.                 dp[i][j]=dp[i-1][j-1]+1;
  24.             }
  25.             else {
  26.                 dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
  27.             }
  28.         }
  29.  
  30.         cout<<dp[la][lb]<<endl;
  31.     }
  32.     return 0;
  33. }

4、POJ 3624 Charm Bracelet

背包水题。！

  1. <pre name="code" class="cpp">#include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  4. #define ll long long
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     int i,j;
  10.     int n,m;
  11.     int a[5000],b[5000];
  12.     int dp[20000];
  13.     while(~scanf("%d%d",&n,&m))
  14.     {
  15.         for(i=1;i<=n;i++)
  16.         scanf("%d%d",&a[i],&b[i]);
  17.         memset(dp,0,sizeof dp);
  18.         for(i=1;i<=n;i++)
  19.             for(j=m;j>=a[i];j--)
  20.             dp[j]=max(dp[j],dp[j-a[i]]+b[i]);
  21.         cout<<dp[m]<<endl;
  22.     }
  23.  
  24.     return 0;
  25. }
  1.  

5、POJ 2486  Apple Tree

经典树形dp！

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  4. #include<algorithm>
  5. using namespace std;
  6.  
  7. int n,k;
  8. int ap[205],cont[205];
  9. int trees[205][205];
  10. int dp[2][205][205];
  11. int vis[205];
  12.  
  13. void dp_trees(int a)
  14. {
  15.     int i,j,l;
  16.     int b;
  17.     for(i=0;i<=k;i++)
  18.         dp[0][a][i]=dp[1][a][i]=ap[a];
  19.     vis[a]=1;
  20.     for(i=1;i<=cont[a];i++)
  21.     {
  22.         b=trees[a][i];
  23.         if(!vis[b])
  24.         {
  25.             dp_trees(b);
  26.             for(j=k;j>=0;j--)
  27.                 for(l=0;l<=j;l++)
  28.             {
  29.                 dp[0][a][j+2]=max(dp[0][a][j+2],dp[0][b][l]+dp[0][a][j-l]);
  30.                 dp[1][a][j+2]=max(dp[1][a][j+2],dp[0][b][l]+dp[1][a][j-l]);
  31.                 dp[1][a][j+1]=max(dp[1][a][j+1],dp[1][b][l]+dp[0][a][j-l]);
  32.             }
  33.         }
  34.     }
  35. }
  36.  
  37. int main()
  38. {
  39.     int i,j;
  40.     int a,b;
  41.     while(cin>>n>>k)
  42.     {
  43.         memset(ap,0,sizeof ap);
  44.         memset(cont,0,sizeof cont);
  45.         memset(trees,0,sizeof trees);
  46.         memset(vis,0,sizeof vis);
  47.         for(i=1;i<=n;i++)
  48.             cin>>ap[i];
  49.         for(i=1;i<n;i++)
  50.         {
  51.             cin>>a>>b;
  52.             trees[a][++cont[a]]=b;
  53.             trees[b][++cont[b]]=a;
  54.         }
  55.         memset(dp,0,sizeof dp);
  56.         dp_trees(1);
  57.         cout<<dp[1][1][k]<<endl;
  58.     }
  59.     return 0;
  60. }

6、POJ  2533  Longest Ordered Subsequence

最长递增子序列。O(n*n)算法。。

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8.     int i,j;
  9.     int t;
  10.     int n;
  11.     int dp[40005];
  12.     int a[40005];
  13.     while(cin>>n)
  14.     {
  15.         for(i=1;i<=n;i++)
  16.             {
  17.                 cin>>a[i];
  18.                 dp[i]=1;
  19.             }
  20.         for(i=2;i<=n;i++)
  21.         {
  22.             for(j=i-1;j>=1;j--)
  23.             {
  24.                 if(a[i]>a[j])
  25.                     dp[i]=max(dp[i],dp[j]+1);
  26.             }
  27.         }
  28.         int maxx=0;
  29.         for(i=1;i<=n;i++)
  30.             if(dp[i]>maxx)
  31.                 maxx=dp[i];
  32.         cout<<maxx<<endl;
  33.     }
  34.     return 0;
  35. }

7、POJ 1631  Bridging signals

最长递增子序列！

O(nlogn)算法！。

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5.  
  6. int dp[40005];
  7. int a[40005];
  8.  
  9. int dich(int l,int r,int i)
  10. {
  11.     int mid;
  12.     while(r>l)
  13.     {
  14.         mid = (l+r)/2;
  15.         if(a[i]<=dp[mid]) r=mid;
  16.         else l=mid+1;
  17.     }
  18.     return l;
  19. }
  20.  
  21. int main()
  22. {
  23.     int i,j;
  24.     int t;
  25.     int n;
  26.     cin>>t;
  27.     while(t--)
  28.     {
  29.         cin>>n;
  30.         for(i=1;i<=n;i++)
  31.             {
  32.                 cin>>a[i];
  33.             }
  34.             dp[1]=a[1];
  35.             int top=1;
  36.         for(i=2;i<=n;i++)
  37.         {
  38.             if(a[i]>dp[top])
  39.             {
  40.                 dp[++top]=a[i];
  41.             }
  42.             else
  43.             {
  44.                 int ans=dich(1,top,i);
  45.                 dp[ans]=a[i];
  46.             }
  47.         }
  48.         cout<<top<<endl;
  49.     }
  50.     return 0;
  51. }

8、POJ  1836  Alignment

双向找最长递增子序列就可以！

！

！

。

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5. int main()
  6. {
  7.     int n;
  8.     int i,j;
  9.     double a[1005];
  10.     int l[1005],r[1005];
  11.     while(cin>>n)
  12.     {
  13.         for(i=1;i<=n;i++)
  14.             cin>>a[i];
  15.         memset(l,0,sizeof l);
  16.         memset(r,0,sizeof r);
  17.         for(i=1;i<=n;i++)
  18.         {
  19.             l[i]=1;
  20.             r[i]=1;
  21.         }
  22.         for(i=2;i<=n;i++)
  23.         {
  24.             for(j=i-1;j>=1;j--)
  25.             {
  26.                 if(a[j]<a[i])
  27.                     l[i]=max(l[i],l[j]+1);
  28.             }
  29.         }
  30.         for(i=1;i<=n;i++)
  31.             if(l[i]<l[i-1])
  32.             l[i]=l[i-1];
  33.         for(i=n-1;i>=1;i--)
  34.         {
  35.             for(j=i+1;j<=n;j++)
  36.                 if(a[j]<a[i])
  37.                 r[i]=max(r[i],r[j]+1);
  38.         }
  39.         for(i=n;i>=1;i--)
  40.             if(r[i]<r[i+1])
  41.             r[i]=r[i+1];
  42.         int ans=0;
  43.         for(i=0;i<=n+1;i++)
  44.             ans=max(ans,l[i]+r[i+1]);
  45.  
  46.         cout<<n-ans<<endl;
  47.     }
  48.     return 0;
  49. }

9、POJ  1080   Human Gene Functions

  1. #include<iostream>
  2. #include<cstring>
  3. using namespace std;
  4.  
  5. int map[10][10]={{0,-3,-4,-2,-1},
  6.                  {-3,5,-1,-2,-1},
  7.                  {-4,-1,5,-3,-2},
  8.                  {-2,-2,-3,5,-2},
  9.                  {-1,-1,-2,-2,5}};
  10. int main()
  11. {
  12.     int t;
  13.     cin>>t;
  14.     while (t--)
  15.     {
  16.         int i,j;
  17.         char a[105],b[105];
  18.         int aa[105],bb[105];
  19.         int la,lb;
  20.         cin>>la>>a>>lb>>b;
  21.         for(i=0;i<la;i++)
  22.         {
  23.             if(a[i]=='A')
  24.             aa[i]=1;
  25.             if(a[i]=='C')
  26.             aa[i]=2;
  27.             if(a[i]=='G')
  28.             aa[i]=3;
  29.             if(a[i]=='T')
  30.             aa[i]=4;
  31.         }
  32.         for(i=0;i<lb;i++)
  33.         {
  34.             if(b[i]=='A')
  35.             bb[i]=1;
  36.             if(b[i]=='C')
  37.             bb[i]=2;
  38.             if(b[i]=='G')
  39.             bb[i]=3;
  40.             if(b[i]=='T')
  41.             bb[i]=4;
  42.         }
  43.         int dp[105][105];
  44.         memset(dp,0,sizeof dp);
  45.         for(i=1;i<=la;i++)
  46.             dp[i][0]=dp[i-1][0]+map[aa[i-1]][0];
  47.         for(i=1;i<=lb;i++)
  48.             dp[0][i]=dp[0][i-1]+map[0][bb[i-1]];
  49.         for(i=1;i<=la;i++)
  50.         {
  51.             for(j=1;j<=lb;j++)
  52.             {
  53.                 dp[i][j]=max(dp[i-1][j]+map[aa[i-1]][0],dp[i][j-1]+map[0][bb[j-1]]);
  54.                 dp[i][j]=max(dp[i][j],dp[i-1][j-1]+map[aa[i-1]][bb[j-1]]);
  55.             }
  56.         }
  57.         cout<<dp[la][lb]<<endl;
  58.     }
  59.     return 0;
  60. }

10、HDU 1024  Max Sum  Plus Plus

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  4. #include<algorithm>
  5. #define inf -1000000000
  6. using namespace std;
  7.  
  8. int dp[1000005],pr[1000005];
  9. int a[1000005];
  10.  
  11. int main ()
  12. {
  13.     int n,m;
  14.     int i,j;
  15.     int maxx;
  16.     while(~scanf("%d%d",&m,&n))
  17.     {
  18.         for(i=1;i<=n;i++)
  19.         {
  20.             scanf("%d",&a[i]);
  21.         }
  22.         memset(dp,0,sizeof dp );
  23.         memset(pr,0,sizeof pr);
  24.         for(i=1;i<=m;i++)
  25.         {
  26.             maxx=inf;
  27.             for(j=i;j<=n;j++)
  28.             {
  29.                 dp[j]=max(dp[j-1]+a[j],pr[j-1]+a[j]);
  30.                 pr[j-1]=maxx;
  31.                 maxx=max(maxx,dp[j]);
  32.             }
  33.         }
  34.         printf("%d\n",maxx);
  35.     }
  36.     return 0;
  37. }

11、HDU 1231  最大连续子序列

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #define inf -1000000000
  6. using namespace std;
  7. int main()
  8. {
  9.     int n;
  10.     int i,j;
  11.     int a[10005];
  12.     while(~scanf("%d",&n)&&n)
  13.     {
  14.         for(i=1;i<=n;i++)
  15.         {
  16.             scanf("%d",&a[i]);
  17.         }
  18.         int l,r,bj=1;
  19.         l=1;r=1;bj=1;
  20.         int sum=0;
  21.         int maxx=inf;
  22.         int cont=0;
  23.         for(i=1;i<=n;i++)
  24.         {
  25.             sum+=a[i];
  26.  
  27.             if(sum>maxx)
  28.             {
  29.                 maxx=sum;
  30.                 l=bj;
  31.                 r=i;
  32.             }
  33.             if(sum<0)
  34.             {
  35.                 cont++;
  36.                 sum=0;
  37.                 bj=i+1;
  38.             }
  39.         }
  40.         if(sum>maxx)
  41.             {
  42.                 maxx=sum;
  43.                 l=bj;
  44.                 r=i;
  45.             }
  46.         if(cont==n)
  47.             printf("0 %d %d\n",a[1],a[n]);
  48.         else
  49.         printf("%d %d %d\n",maxx,a[l],a[r]);
  50.  
  51.     }
  52.     return 0;
  53. }

12、HDU 1503  Advanced Fruits

最长公共序列的路径记忆！！！

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<cstdio>
  5. using namespace std;
  6.  
  7. char a[105],b[105];
  8. int bj[105][105];
  9. int dp[105][105];
  10.  
  11. void pri(int l,int r)
  12. {
  13.     if(l==0&&r==0) return ;
  14.     if(bj[l][r]==1) {pri(l,r-1);cout<<b[r];}
  15.     else if(bj[l][r]==3) {pri(l-1,r);cout<<a[l];}
  16.     else {pri(l-1,r-1);cout<<a[l];}
  17. }
  18.  
  19. int main()
  20. {
  21.     int i,j;
  22.     while(~scanf("%s%s",a+1,b+1))
  23.     {
  24.         int la=strlen(a+1);
  25.         int lb=strlen(b+1);
  26.         memset(dp,0,sizeof dp);
  27.         memset(bj,0,sizeof bj);
  28.         for(i=0;i<=la;i++)
  29.             bj[i][0]=3;
  30.         for(i=0;i<=lb;i++)
  31.             bj[0][i]=1;
  32.         for(i=1;i<=la;i++)
  33.         {
  34.             for(j=1;j<=lb;j++)
  35.             {
  36.  
  37.                 if(a[i]==b[j])
  38.                    {
  39.                        dp[i][j]=dp[i-1][j-1]+1;
  40.                        bj[i][j]=2;
  41.                    }
  42.                 else
  43.                 {
  44.                     if(dp[i][j-1]>dp[i-1][j])
  45.                     {
  46.                         dp[i][j]=dp[i][j-1];
  47.                         bj[i][j]=1;
  48.                     }
  49.                     else {
  50.                         dp[i][j]=dp[i-1][j];
  51.                         bj[i][j]=3;
  52.                     }
  53.                 }
  54.             }
  55.         }
  56.         pri(la,lb);
  57.         cout<<endl;
  58.  
  59.     }
  60.     return 0;
  61. }

13、HDU 1058 Humble Numbers

数位水题！

！。

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string>
  4. #include <cstring>
  5. #include <cstdlib>
  6. #include <algorithm>
  7. #define inf 2000000000
  8. #define mod 1000000007
  9. using namespace std;
  10.  
  11. int main()
  12. {
  13.     int a,b,c,d;
  14.     int n,i;
  15.     int s[10005];
  16.     a=b=c=d=1;
  17.     s[1]=1;
  18.     for(i=2;i<=5842;i++)
  19.         {
  20.             s[i]=min(s[a]*2,min(s[b]*3,min(s[c]*5,s[d]*7)));
  21.             if(s[i]==s[a]*2)
  22.                 a++;
  23.             if(s[i]==s[b]*3)
  24.                 b++;
  25.             if(s[i]==s[c]*5)
  26.                 c++;
  27.             if(s[i]==s[d]*7)
  28.                 d++;
  29.         }
  30.     while(~scanf("%d",&n)&&n)
  31.     {
  32.         if(n%10==1&&n%100!=11)
  33.             printf("The %dst humble number is %d.\n",n,s[n]);
  34.         else if(n%10==2&&n%100!=12)
  35.             printf("The %dnd humble number is %d.\n",n,s[n]);
  36.         else if(n%10==3&&n%100!=13)
  37.             printf("The %drd humble number is %d.\n",n,s[n]);
  38.         else
  39.         printf("The %dth humble number is %d.\n",n,s[n]);
  40.     }
  41.     return 0;
  42. }

14、HDU 3466 Proud Merchants

背包好题！

。！

！！值得一做！！！！

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<cstring>
  4. #include<algorithm>
  5. #include<queue>
  6. #define M 10010
  7. using namespace std;
  8.  
  9. struct H
  10. {
  11.     int p,q,v;
  12. }a[505];
  13.  
  14. bool cmp(H a,H b)
  15. {
  16.     return a.q-a.p<b.q-b.p;
  17. }
  18.  
  19. int dp[5005];
  20.  
  21. int main()
  22. {
  23.     int i,j;
  24.     int n,m;
  25.     while(~scanf("%d%d",&n,&m))
  26.     {
  27.         memset(dp,0,sizeof dp);
  28.         for(i=0;i<n;i++)
  29.             scanf("%d%d%d",&a[i].p,&a[i].q,&a[i].v);
  30.         sort(a,a+n,cmp);
  31.         for(i=0;i<n;i++)
  32.             for(j=m;j>=a[i].p&&j>=a[i].q;j--)
  33.             dp[j]=max(dp[j],dp[j-a[i].p]+a[i].v);
  34.         printf("%d\n",dp[m]);
  35.     }
  36.     return 0;
  37. }

14、HDU 3555 Bomb

数位基础训练開始。！

！！！

！！

！

我待水似流年，流年带我似水

15、HDU 2086 不要62

我待水似流年，流年待我似水

16、ACdream  1064  完美数

到这我都用了经典dp和记忆化搜索做，后面的记忆化搜索好理解一些

我待水似流年，流年待我似水

17、HDU  3652   B-number

数位DP！

记忆化搜索，优化非常水，500MS！

！

  1.  

贴自己博客的代码也审核。

。

。

。

。

，无奈了！！发链接吧！！！

我待水似流年，流年待我似水

18、HDU 4389  X mod f(x)

数位dp！。

感觉这个题比較好！

。。。

我待水似流年，流年待我似水

动态规划 is beginning。。。。。。。。。的更多相关文章

  1. hdu 1159:Common Subsequence（动态规划）

    Common Subsequence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Other ...

  2. 动态规划——区间dp

    在利用动态规划解决的一些实际问题当中,一类是基于区间上进行的,总的来说,这种区间dp是属于线性dp的一种.但是我们为了更好的分类,这里仍将其单独拿出进行分析讨论. 让我们结合一个题目开始对区间dp的探 ...

  3. 动态规划——线性dp

    我们在解决一些线性区间上的最优化问题的时候,往往也能够利用到动态规划的思想,这种问题可以叫做线性dp.在这篇文章中,我们将讨论有关线性dp的一些问题. 在有关线性dp问题中,有着几个比较经典而基础的模 ...

  4. VF(动态规划)

    VF 时间限制:1000 ms  |  内存限制:65535 KB 难度:2 描述 Vasya is the beginning mathematician. He decided to make a ...

  5. HDU 5009 Paint Pearls （动态规划）

    Paint Pearls Problem Description Lee has a string of n pearls. In the beginning, all the pearls have ...

  6. 动态规划 Common Subsequence

    描述 A subsequence of a given sequence is the given sequence with some elements (possible none) left o ...

  7. HDU 4247 Pinball Game 3D(cdq 分治+树状数组+动态规划)

    Pinball Game 3D Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) ...

  8. PAT 甲级 1033 To Fill or Not to Fill (25 分)（贪心,误以为动态规划,忽视了油量问题）*

    1033 To Fill or Not to Fill (25 分)   With highways available, driving a car from Hangzhou to any oth ...

  9. HDU 1159 Common Subsequence （动态规划、最长公共子序列）

    Common Subsequence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Other ...

随机推荐

  1. 【BZOJ2809】【splay启发式合并】dispatching

    Description 在一个忍者的帮派里,一些忍者们被选中派遣给顾客,然后依据自己的工作获取报偿.在这个帮派里,有一名忍者被称之为 Master.除了 Master以外,每名忍者都有且仅有一个上级. ...

  2. phpcms源码跟踪（1）

    本次跟踪解决几个问题: 1.缓存文件从哪里来,过程中被删除了怎么办 2.模板html是如何被引入的 进入首页时,通过最初的调用,进入控制器\phpcms\modules\content\index.p ...

  3. 我用Emacs，后来转向Vim——Vim学习之Vim键盘图(绝对值得珍藏)

    Emacs本来就比较臃肿,麻烦.当我发现Vim键盘图时,我就渐渐转向Vim,追随Unix/Linux哲学去了.. 我用了Emacs三个月,因为它的学习曲线没Vim陡,这点吸引了,我使用Linux才7. ...

  4. request.getContextPath获取绝对路径

    request.getContextPath获取绝对路径 博客分类: 经验+注意 其他 request.getContextPath 项目需求:所有jsp页必须通过Action转发,不能直接在地址栏链 ...

  5. Javascript中的函数(Function)与对象(Object)的关系

    今天我们来尝试理解Function和Object.因为这个里面有些人前期可能会搞糊涂.他们之间到底是什么关系.当然也不除外当初的我. 注意:官方定义: 在Javascript中,每一个函数实际上都是一 ...

  6. SQL Server 连接字符串和身份验证

    SQL Server .NET Data Provider 连接字符串包含一个由一些属性名/值对组成的集合.每一个属性/值对都由分号隔开.         PropertyName1=Value1;P ...

  7. KVO初探

    一,概述 KVO,即:Key-Value Observing,它提供一种机制,当指定的对象的属性被修改后,则对象就会接受到通知.简单的说就是每次指定的被观察的对象的属性被修改后,KVO就会自动通知相应 ...

  8. Solr4.8.0源码分析(25)之SolrCloud的Split流程

    Solr4.8.0源码分析(25)之SolrCloud的Split流程(一) 题记:昨天有位网友问我SolrCloud的split的机制是如何的,这个还真不知道,所以今天抽空去看了Split的原理,大 ...

  9. Yosemite重置Dock的命令

    备忘 defaults write com.apple.dock ResetLaunchPad -bool true killall Dock

  10. 转:PHP超时处理全面总结

    原文来自于:http://wulijun.github.io/2012/08/08/php-timeout-summary.html 概述 在PHP开发工作里非常多使用到超时处理的场合,我说几个场景: ...