gettogetto
gettogetto

动态规划题集

hdu 2084 数塔

由上往下推，由于结果状态多，不好处理

由底往上推，都归于一个起点，只需要算出由底往上得到的最大价值即可

方程：dp[i][j] = max(dp[i+1][j],dp[i+1][j+1])+a[i][j];

 

[cpp]  view plain  copy
  1. #include   
  2. #include   
  3. #include   
  4. using namespace std;  
  5.   
  6. int a[105][105],dp[105][105];  
  7.   
  8. int main()  
  9. {  
  10.     int t,n,i,j;  
  11.     scanf("%d",&t);  
  12.     while(t--)  
  13.     {  
  14.         scanf("%d",&n);  
  15.         memset(dp,0,sizeof(dp));  
  16.         for(i = 1;i<=n;i++)  
  17.         {  
  18.             for(j = 1;j<=i;j++)  
  19.             scanf("%d",&a[i][j]);  
  20.         }  
  21.         for(i = n;i>=1;i--)  
  22.         {  
  23.             for(j = 1;j<=i;j++)  
  24.             {  
  25.                 dp[i][j] = max(dp[i+1][j],dp[i+1][j+1])+a[i][j];  
  26.             }  
  27.         }  
  28.         printf("%d\n",dp[1][1]);  
  29.     }  
  30.   
  31.     return 0;  
  32. }  

hdu 2018 母牛的故事

以n=6为例，fn=9头牛可以分解为6+3，其中6是上一年（第5年）的牛，3是新生的牛（因为第3年有3头牛，这3头在第6年各生一头牛）。
　　我们可以得出这样一个公式：fn=fn-1+fn-3
　　再理解一下，fn-1是前一年的牛，第n年仍然在，fn-3是前三年那一年的牛，但换句话说也就是第n年具有生育能力的牛，也就是第n年能生下的小牛数。
　　编程序，求解这个公式就行了。
　　当然，第1-3年的数目，需要直接给出。
　　很像斐波那契数列，有不一样之处，道理、方法一样。其实，在编程之前，讲究先用这样的方式建模。

　　下面给出参考程序：

[cpp]  view plain  copy
  1. //解法1：迭代解法  
  2. #include   
  3. using namespace std;  
  4. int main()  
  5. {  
  6.     int n,i;  
  7.     int f1, f2, f3, fn;  
  8.     while(cin>>n&&n!=0)  
  9.     {  
  10.         //下面求第n年有几头牛  
  11.         f1=1;  
  12.         f2=2;  
  13.         f3=3;  
  14.         if(n==1)  
  15.             cout<
  16.         else if(n==2)  
  17.             cout<
  18.         else if(n==3)  
  19.             cout<
  20.         else  
  21.         {  
  22.             for(i=4; i<=n; i++)  
  23.             {  
  24.                 fn=f3+f1;  
  25.                 f1=f2;  //f1代表前3年  
  26.                 f2=f3;  //f2代表前2年  
  27.                 f3=fn;  //f3代表前1年  
  28.             }  
  29.             cout<
  30.         }  
  31.     }  
  32.     return 0;  
  33. }  


[cpp]  view plain  copy
  1. //解法2：定义递归函数（效率低，不建议用）  
  2. #include   
  3. using namespace std;  
  4. int f(int n);  
  5. int main()  
  6. {  
  7.     int n;  
  8.     while(cin>>n&&n!=0)  
  9.     {  
  10.         cout<
  11.     }  
  12.     return 0;  
  13. }  
  14.   
  15.   
  16. int f(int n)  
  17. {  
  18.     if(n<4)  
  19.         return n; //第1，2，3年，各为1，2，3头  
  20.     else  
  21.         return f(n-1)+f(n-3);  //第n年为前一年的和前3年的相加  
  22. }  

[cpp]  view plain  copy
  1. //解法3：用数组  
  2. #include   
  3. using namespace std;  
  4. int main()  
  5. {  
  6.     int n,i;  
  7.     int f[56]={0,1,2,3};  
  8.     for(i=4;i<=55;i++)  
  9.         f[i]=f[i-1]+f[i-3];  
  10.     while(cin>>n&&n!=0)  
  11.     {  
  12.         cout<
  13.     }  
  14.     return 0;  
  15. }  
hdu 2044 一只小蜜蜂...  

  1. #include   
  2. //#include   
  3. //#include   
  4. int main()  
  5. {  
  6.     int n, a, b;  
  7.     __int64 c[55];  
  8.     c[2] = 1;  
  9.     c[3] = 2;  
  10.     for(int i=4; i<=50; i++)  
  11.     {  
  12.         c[i] = c[i-1] + c[i-2];  
  13.     }  
  14.     scanf("%d", &n);  
  15.     while(n--)  
  16.     {  
  17.         scanf("%d%d", &a, &b);  
  18.         printf("%I64d\n", c[b-a+1]);  
  19.     }  
  20.     return 0;  
  21. }  

hdu 2041 超级楼梯 Fibonacci

  1. #include   
  2. #include   
  3. int step[50];  
  4. int main()  
  5. {  
  6.     int n,m;  
  7.     scanf("%d",&n);  
  8.     while(n--)  
  9.     {  
  10.         scanf("%d",&m);  
  11.         step[1] = 1;  
  12.         step[2] = 2;  
  13.         for(int i=3; i
  14.         {  
  15.             step[i] = step[i-1] + step[i-2];  
  16.         }  
  17.         printf("%d\n",step[m-1]);  
  18.     }  
  19.     return 0;  
  20. }  

hdu 2050 折线分割平面 找递推公式

１递推递推，先分析下直线分割平面的情况，增加第n条直线的时候，跟之前的直线最多有n-1个交点，此时分出的部分多出了（n-1）+1；

２折线也是同理，f(1)=2,f(2)=7,先画好前面n-1条折线，当增加第n条拆线时，此时与图形新的交点最多有2*2（n-1）个，所以分出的部分多出了２*２（n-1）+1　　　所以推出f(n)=f(n-1)+4*(n-1)+1,n>=3

[cpp]  view plain  copy
 
  1. #include   
  2. int main()  
  3. {  
  4.     int n,i,k,j;  
  5.     __int64 a[10010];  
  6.     scanf("%d",&n);  
  7.     for(i=1;i<=n;i++)  
  8.     {  
  9.         scanf("%d",&k);  
  10.         a[1]=2;  
  11.         for(j=2;j<=k;j++)  
  12.             a[j]=a[j-1]+4*(j-1)+1;  
  13.         printf("%I64d\n",a[k]);  
  14.     }  
  15.     return 0;  
  16. }  

Codeforces 429B B. Working out

给n*m的矩阵，每个格子有个数，A从(1,1)出发只能向下或右走，终点为(n,m)，B从(n,1)出发只能向上或右走，终点为(1,m)。两个人的速度不一样，走到的格子可以获的该格子的数，两人相遇的格子上的数两个人都不能拿。求A和B能拿到的数的总和的最大值。

n,m<=1000

解题思路：

dp.

先预处理出每个格子到四个角落格子的路径最大数值，然后枚举两个人相遇的交点格子，枚举A、B的进来和出去方式，求最大值即可。

注意边界情况。

代码：

[cpp]  view plain  copy
 
  1. //#include  
  2.   
  3. #include  
  4. #include  
  5. #include  
  6. #include  
  7. #include  
  8. #include  
  9. #include  
  10. #include  
  11. #include  
  12. #include  
  13. #include  
  14. #include  
  15. #include  
  16. #include  
  17. #include  
  18. #include  
  19. #include  
  20. #include  
  21. #define eps 1e-6  
  22. #define INF 0x3f3f3f3f  
  23. #define PI acos(-1.0)  
  24. #define ll __int64  
  25. #define LL long long  
  26. #define lson l,m,(rt<<1)  
  27. #define rson m+1,r,(rt<<1)|1  
  28. #define M 1000000007  
  29. //#pragma comment(linker, "/STACK:1024000000,1024000000")  
  30. using namespace std;  
  31.   
  32. #define Maxn 1100  
  33. ll dp[5][Maxn][Maxn];  
  34. int n,m;  
  35.   
  36. ll save[Maxn][Maxn];  
  37.   
  38.   
  39. int main()  
  40. {  
  41.    //freopen("in.txt","r",stdin);  
  42.    //freopen("out.txt","w",stdout);  
  43.    while(~scanf("%d%d",&n,&m))  
  44.    {  
  45.        memset(save,0,sizeof(save));  
  46.   
  47.        for(int i=1;i<=n;i++)  
  48.             for(int j=1;j<=m;j++)  
  49.                 scanf("%d",&save[i][j]);  
  50.   
  51.        memset(dp,0,sizeof(dp));  
  52.        for(int i=1;i<=n;i++)  
  53.        {  
  54.            for(int j=1;j<=m;j++)  
  55.                dp[1][i][j]=max(dp[1][i-1][j],dp[1][i][j-1])+save[i][j];  
  56.                //printf("i:%d j:%d %I64d\n",i,j,dp[1][i][j]);  
  57.            for(int j=m;j>=1;j--)  
  58.                 dp[3][i][j]=max(dp[3][i-1][j],dp[3][i][j+1])+save[i][j];  
  59.        }  
  60.   
  61.        for(int i=n;i>=1;i--)  
  62.        {  
  63.            for(int j=1;j<=m;j++)  
  64.                 dp[2][i][j]=max(dp[2][i+1][j],dp[2][i][j-1])+save[i][j];  
  65.            for(int j=m;j>=1;j--)  
  66.                 dp[4][i][j]=max(dp[4][i+1][j],dp[4][i][j+1])+save[i][j];  
  67.        }  
  68.        ll ans=0;  
  69.        for(int i=0;i<=n+1;i++)  //把四个边界都置为无效情况  
  70.             for(int k=1;k<=4;k++)  
  71.                 dp[k][i][0]=dp[k][i][m+1]=-INF;  
  72.        for(int j=0;j<=m+1;j++)  
  73.             for(int k=1;k<=4;k++)  
  74.                 dp[k][0][j]=dp[k][n+1][j]=-INF;  
  75.   
  76.        for(int i=1;i<=n;i++)  
  77.        {  
  78.            for(int j=1;j<=m;j++)  
  79.            {     //只用考虑两种情况 两个人只能交叉一个格子，多了的话不合算  
  80.                ll temp=dp[1][i][j-1]+dp[4][i][j+1]+dp[2][i+1][j]+dp[3][i-1][j];  
  81.                ans=max(ans,temp);  
  82.                temp=dp[1][i-1][j]+dp[4][i+1][j]+dp[2][i][j-1]+dp[3][i][j+1];  
  83.                ans=max(ans,temp);  
  84.                //printf("i:%d j:%d %I64d\n",i,j,ans);  
  85.            }  
  86.        }  
  87.        printf("%I64d\n",ans);  
  88.    }  
  89.    return 0;  
  90. }  

背包问题//背包九讲http://love-oriented.com/pack/Index.html

[cpp]  view plain  copy
 
  1. #include  
  2. using namespace std;  
  3. #define  V 1500  
  4. unsigned int f[V];//全局变量，自动初始化为0  
  5. unsigned int weight[10];  
  6. unsigned int value[10];  
  7. #define  max(x,y)   (x)>(y)?(x):(y)  
  8. int main()  
  9. {  
  10.       
  11.     int N,M;  
  12.     cin>>N;//物品个数  
  13.     cin>>M;//背包容量  
  14.     for (int i=1;i<=N; i++)  
  15.     {  
  16.         cin>>weight[i]>>value[i];  
  17.     }  
  18.     for (int i=1; i<=N; i++)  
  19.         for (int j=M; j>=1; j--)  
  20.         {  
  21.             if (weight[i]<=j)  
  22.             {  
  23.                 f[j]=max(f[j],f[j-weight[i]]+value[i]);  
  24.             }             
  25.         }  
  26.       
  27.     cout<//输出最优解  
  28.   
  29. }  

在看完01背包问题，再来看完全背包问题： 一个背包总容量为V，现在有N个物品，第i个 物品体积为weight[i]，价值为value[i]，每个物品都有无限多件，现在往背包里面装东西，怎么装能使背包的内物品价值最大？

对比一下，看到的区别是，完全背包问题中，物品有无限多件。往背包里面添加物品时，只要当前背包没装满，可以一直添加。那么状态转移方程为：

f[i+1][j]=max(f[i][j-k*weight[i+1]+k*value[i+1])，其中0<=k<=V/weight[i+1]

使用内存为一维数组，伪代码

for i=1……N

for j=1……M

f[j]=max(f[j],f[j-weight[i]+value[i])

和01背包问题唯一不同的是j是从1到M。01背包问题是在前一个子问题（i-1 种 物品）的基础上来解决当前问题（i 种 物品），向i-1种物品时的背包添加第i种物品；而完全背包问题是在解决当前问题（i种物品），向i种物品时的背包添加第i种物品。

代码如下：

[cpp]  view plain  copy
 
  1. #include  
  2. using namespace std;  
  3. #define  V 1500  
  4. unsigned int f[V];//全局变量，自动初始化为0  
  5. unsigned int weight[10];  
  6. unsigned int value[10];  
  7. #define  max(x,y)   (x)>(y)?(x):(y)  
  8. int main()  
  9. {  
  10.       
  11.     int N,M;  
  12.     cin>>N;//物品个数  
  13.     cin>>M;//背包容量  
  14.     for (int i=1;i<=N; i++)  
  15.     {  
  16.         cin>>weight[i]>>value[i];  
  17.     }  
  18.     for (int i=1; i<=N; i++)  
  19.         for (int j=1; j<=M; j++)  
  20.         {  
  21.             if (weight[i]<=j)  
  22.             {  
  23.                 f[j]=max(f[j],f[j-weight[i]]+value[i]);  
  24.             }             
  25.         }  
  26.       
  27.     cout<//输出最优解  
  28.   
  29. }  


最小纸币数

给定一定钱，币面有1,21,25,2,5几种，求组成该钱数的最少张数并输出方案。

void solve(vector&money,int sum){
    vector dp(sum+1,INT_MAX);//i元需要最少纸币张数。
    vector res(sum+1,0);//存方案
    dp[0]=0;
    for(int i=1;i<=sum;i++){
        for(int k=0;kdp[i-money[k]]+1){
                    dp[i]=dp[i-money[k]]+1;
                    res[i]=money[k];
                }
            }
        }
    }
    int s=sum;
    while(res[s]){
        cout< money={1,21,25,2,5};
    int sum;
    cin>>sum;
    solve(money,sum);
}




多重背包问题

题目：有N种物品和一个容量为V的背包。第i种物品最多有num[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装

入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 

 

分析：状态转移为：

 

题目：http://acm.hdu.edu.cn/showproblem.php?pid=2191

 

[cpp]  view plain  copy
  1. #include   
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6. const int N = 1005;  
  7.   
  8. int dp[N];  
  9. int c[N],w[N],num[N];  
  10. int n,m;  
  11.   
  12. void ZeroOne_Pack(int cost,int weight,int n)  
  13. {  
  14.     for(int i=n; i>=cost; i--)  
  15.         dp[i] = max(dp[i],dp[i-cost] + weight);  
  16. }  
  17.   
  18. void Complete_Pack(int cost,int weight,int n)  
  19. {  
  20.     for(int i=cost; i<=n; i++)  
  21.         dp[i] = max(dp[i],dp[i-cost] + weight);  
  22. }  
  23.   
  24. int Multi_Pack(int c[],int w[],int num[],int n,int m)  
  25. {  
  26.     memset(dp,0,sizeof(dp));  
  27.     for(int i=1; i<=n; i++)  
  28.     {  
  29.         if(num[i]*c[i] > m)  
  30.             Complete_Pack(c[i],w[i],m);  
  31.         else  
  32.         {  
  33.             int k = 1;  
  34.             while(k < num[i])  
  35.             {  
  36.                 ZeroOne_Pack(k*c[i],k*w[i],m);  
  37.                 num[i] -= k;  
  38.                 k <<= 1;  
  39.             }  
  40.             ZeroOne_Pack(num[i]*c[i],num[i]*w[i],m);  
  41.         }  
  42.     }  
  43.     return dp[m];  
  44. }  
  45.   
  46. int main()  
  47. {  
  48.     int t;  
  49.     cin>>t;  
  50.     while(t--)  
  51.     {  
  52.         cin>>m>>n;  
  53.         for(int i=1; i<=n; i++)  
  54.             cin>>c[i]>>w[i]>>num[i];  
  55.         cout<
  56.     }  
  57.     return 0;  
  58. }  

一个强盗要去抢劫银行，对于每个银行来说，都有一个不被抓的概率p，和能抢劫到的钱数money,每个银行最多只可以被抢劫一次。问在不被抓的总概率P下，怎样得到最大价值的钱数。

分析：我第一眼看的时候觉得见到01，然后弄一个dp[100]，把概率*100。。。。。。如果你和我一样这么想。。那么恭喜你上当了！需要把money当做下标。。。保存的是概率。。。状态转移方程：dp[j] = max(dp[j], (1.0-gai[i]) * dp[j-money[i]]);

[cpp]  view plain  copy
  1. #include   
  2. #include   
  3. #include   
  4. using namespace std;  
  5.   
  6. #define max(a,b)    ((a)>(b)?(a):(b))  
  7. const int maxn = 105;  
  8. double dp[10005];  
  9. int main()  
  10. {  
  11.     int t;  
  12.     scanf("%d", &t);  
  13.     while (t--)  
  14.     {  
  15.         double p, gai[maxn];  
  16.         int n, money[maxn];  
  17.         scanf("%lf %d", &p, &n);  
  18.         int i, j;  
  19.         int sum = 0;  
  20.         for (i=0; i
  21.         {  
  22.             scanf("%d %lf", &money[i], &gai[i]);  
  23.             sum += money[i];  
  24.         }  
  25.         memset(dp, 0, (sum+1)*sizeof(dp[0]));  
  26.         dp[0] = 1;  
  27.   
  28.         if (p <= 1-1e-8)  
  29.         {  
  30.             for (i=0; i
  31.                 for (j=sum; j>=money[i]; j--)  
  32.                 {  
  33.                     double tmp = (1.0-gai[i]) * dp[j-money[i]];  
  34.                     dp[j] = max(dp[j], tmp);  
  35.                 }  
  36.   
  37.             for (i=sum; 1 - dp[i] >= p; i--);  
  38.             printf("%d\n", i);  
  39.         }  
  40.         else  
  41.         {  
  42.             printf("%d\n", sum);  
  43.         }  
  44.     }  
  45.     return 0;  
  46. }  



最大连续子数组和

int solve(vector& v){
    int n=v.size();
    vector dp(n,0);//dp[i]:以i为结尾的子数组元素和 
    dp[0]=v[0];
    int res=dp[0];
    for(int i=1;i& v){
    int n=v.size();

    int thissum=v[0];
    int res=thissum;
    for(int i=1;i

最大递增子序列和

#include
#include
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
int solve(vector&v){
    int n=v.size();
    vector dp(n,0);
    dp[0]=v[0];
    int res=-1000000;
    for(int i=1;iv[j]){
               dp[i]=max(dp[i],dp[j]+v[i]);
           }
         }
         res=max(res,dp[i]);
    }
    return res;
}
int main(){
    int n;
     while(cin>>n){
     	if(n==0) continue;
        vector v(n);
        for(int i=0;i>v[i];
        cout<




最长递增子序列

class Solution {
public:
    int lengthOfLIS(vector& nums) {
        int n=nums.size();
        if(n==0) return 0;
        if(n==1) return 1;
        int res=0;
        vectordp(n,1);
        for(int i=1;i=0;j--){
                if(nums[i]>nums[j]){
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
        }
        return *max_element(dp.begin(),dp.end());
    }
};


最长公共子序列

用二维数组c[i][j]记录串 x1x2⋯xi x1x2⋯xi与 y1y2⋯yj y1y2⋯yj的LCS长度，则可得到状态转移方程

c[i,j]=⎧⎩⎨⎪⎪0c[i−1,j−1]+1max(c[i,j−1],c[i−1,j])i=0 or j=0i,j>0 and  xi=yji,j>0 and xi≠yj c[i,j]={0i=0 or j=0c[i−1,j−1]+1i,j>0 and  xi=yjmax(c[i,j−1],c[i−1,j])i,j>0 and xi≠yj

代码实现

public static int lcs(String str1, String str2) {
    int len1 = str1.length();
    int len2 = str2.length();
    int c[][] = new int[len1+1][len2+1];
    for (int i = 0; i <= len1; i++) {
        for( int j = 0; j <= len2; j++) {
            if(i == 0 || j == 0) {
                c[i][j] = 0;
            } else if (str1.charAt(i-1) == str2.charAt(j-1)) {
                c[i][j] = c[i-1][j-1] + 1;
            } else {
                c[i][j] = max(c[i - 1][j], c[i][j - 1]);
            }
        }
    }
    return c[len1][len2];
}

DP求解最长公共子串

前面提到了子串是一种特殊的子序列，因此同样可以用DP来解决。定义数组的存储含义对于后面推导转移方程显得尤为重要，糟糕的数组定义会导致异常繁杂的转移方程。考虑到子串的连续性，将二维数组 c[i,j] c[i,j]用来记录具有这样特点的子串——结尾为母串 x1x2⋯xi x1x2⋯xi与 y1y2⋯yj y1y2⋯yj的结尾——的长度。

得到转移方程：

c[i,j]=⎧⎩⎨⎪⎪0c[i−1,j−1]+10i=0 or j=0xi=yjxi≠yj c[i,j]={0i=0 or j=0c[i−1,j−1]+1xi=yj0xi≠yj

最长公共子串的长度为  max(c[i,j]), i∈{1,⋯,m},j∈{1,⋯,n} max(c[i,j]), i∈{1,⋯,m},j∈{1,⋯,n}。

代码实现

public static int lcs(String str1, String str2) {
    int len1 = str1.length();
    int len2 = str2.length();
    int result = 0;     //记录最长公共子串长度
    int c[][] = new int[len1+1][len2+1];
    for (int i = 0; i <= len1; i++) {
        for( int j = 0; j <= len2; j++) {
            if(i == 0 || j == 0) {
                c[i][j] = 0;
            } else if (str1.charAt(i-1) == str2.charAt(j-1)) {
                c[i][j] = c[i-1][j-1] + 1;
                result = max(c[i][j], result);
            } else {
                c[i][j] = 0;
            }
        }
    }
    return result;
}

给定整数m,n和数组x[n],找出某个i,使得x[i]+x[i+1]+x[i+2]+x[i+3]+x[i+4]…x[i+m]最接近于零。

(0<=i

一．暴力解法

    遍历各个i值，计算子序列的和，然后求出最接近0的

int find(int a[],int n,int m)     //寻找m+1个数字，使得他们的和最小
{
	int i=0;
	int thissum=0;
	int j=0;
	int ans=INT_MAX;
	for(i=0;i

显然，时间复杂度为O(m*n),空间复杂度为O(1)

二．动态规划：

    建立数组dp[],dp[i]存放的是x[i]+x[i+1]+…x[i+m]的值,则递推关系式为：

dp[i+1]=dp[i]-a[i]+a[i+1+m],然后遍历dp[]数组，求出最近于零的。

int find2(int a[],int n,int m)
{
int *dp=(int *)malloc(n*sizeof(int));
int i=0;
int tmp=0;
for(i=0;i<=m;i++)
{
	tmp+=a[i];
}
dp[0]=tmp;
for(i=1;i
    时间复杂度为O(n),空间复杂度为O(n)

    还可以对上面的代码稍作改进，上面的dp[]数组，只要用一个变量即可。

int find3(int a[],int n,int m)   
{
int tmp=0;
int ans=INT_MAX;
int i=0;
for(i=0;i<=m;i++)
	tmp+=a[i];
if(abs((int)tmp)

    时间复杂度为O(n)，空间复杂度为O(1)

完整代码为：

# include 
# include 
# include 
# include 
using namespace std;

int find(int a[],int n,int m)     //寻找m+1个数字，使得他们的和最小
{
	int i=0;
	int thissum=0;
	int j=0;
	int ans=INT_MAX;
	for(i=0;i

一个数组中只有0和1，求0和1个数相等的最大连续子序列？【百度面试题】


这题有空间和时间的解法

首先把数组中的 全部改成

此时题目等价于询问一段最长的区间，使得区间内的数的和是
这个时候可以对新的 数组求前缀和数组
题目又转化为求两个下标 使得 ，且 最大

这个可以用一个长度为 的数组来记录前缀和的下标来进行快速查询

细节见代码 
#include 
#include 
using namespace std;


int main() {
	vector arr = { 1, 1, 1, 0, 1,0,1,1 };
	int counts = arr.size();
	vector sum;
	sum.reserve(counts + 1);
	sum.push_back(0);
	for (const auto& x : arr) {
		sum.push_back(sum.back() + x * 2 - 1);
	}
	vector temp(counts * 2 + 1, -1);//哈希表
	int maxlen = -1;
	int startindex = -1, endindex = -1;
	for (int i = 0; i < sum.size(); i++) {
		int index = sum[i] + counts;//加上偏置，因为sum可能小于零
		if (temp[index] == -1) {
			temp[index] = i;
		}
		else {
			int curlen = i - temp[index];
			if (curlen > maxlen) {
				startindex = temp[index];
				endindex = i - 1;
				maxlen = curlen;
			}
		}
	}
	if (maxlen != -1) {
		cout << "MAXLEN: " << maxlen << " START: " << startindex << " END: " << endindex << endl;
	}
	else {
		cout << "NOT EXIST" << endl;
	}
}



找数组中最长和为0连续子序列


输入：int 型数组由正数、负数、0组成

输出：最长和为0的子序列


例：

输入：[3,0,-1,-2,-3,1,1,1,2,3,1,-2,-1]

输出：9


思路：原数组为A，长度为N

          新建一个数组B[1...N+1]，B[i]=A[i-1]+A[i-2]+A[1]，B[1]=0             时间复杂度为O(n)

          将问题转化为求B数组两个相同数字最远距离                                时间复杂度可能为O(n^2)

	 private static int find(int[] arr) {
  		int[] arr1 = new int[arr.length + 1];
  		//创建求和串，为了考虑整个串和为0，将首项设置为0；
  		arr1[0] = 0;
  		for (int x = 0; x < arr.length; x++) {
   			arr1[x+1] = arr[x]+arr1[x];
  		}
  
  		int arr2[] = new int [arr.length];
  		//寻找两个相同数字最大距离，从后向前，找到就ok
  		for(int i = 0;iarr.length-i){
    				break;
   			}
   			for(int j =arr.length;j>=0;j--){
    				if(arr1[i]==arr1[j]){
     					arr2[i]=j-i;
     					break;
    				}
   			}
  		}
  
  		//找最大值
  		int max = 0;
  		for(int x =0;xmax){
   				max=arr2[x];
   			}
  		}    
  		return max;
 	}


POJ - 3061 Subsequence（连续子序列和>=s的最短子序列长度）

题意：T组实例，每组实例给出n和s，接着n个数。求连续子序列和大于等于s的最短子序列长度。

分析：有点点模拟的意思，形象点说，就像你堆积木，超过一定值S后我们就把最下面的几块积木去掉。具体方法是从前面开始不断累加，当和值超过S时减少前面的数值，然后记录下刚好>=S的ans值，如此重复直到序列尾，输出最小的ans。

 

ＡＣ代码1：

 

复制代码 
 1 #include
 2 #include<string.h>
 3 #include
 4 #include
 5 #include
 6 #include
 7 #include
 8 using namespace std;
 9 #define N 1200000
10 #define INF 0x3f3f3f3f
11 
12 int dp[N];
13 int a[N];
14 
15 int main()
16 {
17     int n,m,T,i,j;
18 
19     scanf("%d", &T);
20 
21     while(T--)
22     {
23         scanf("%d %d", &n, &m);
24         memset(dp,0,sizeof(dp));
25 
26         for(i=1;i<=n;i++)
27         {
28             scanf("%d", &a[i]);
29             dp[i]=dp[i-1]+a[i];
30         }
31 
32         int minn=INF,i=1;;
33         for(j=1;j<=n;j++)
34         {
35              if(dp[j]-dp[i-1]<m)
36                 continue ;
37              while(dp[j]-dp[i]>=m)
38                 i++;
39              minn=min(minn,j-i+1);
40         }
41 
42       if(minn==INF)
43         printf("0\n");
44       else
45         printf("%d\n", minn);
46     }
47     return 0;
48 }
复制代码



最长回文子串 

class Solution {
public:

string longestPalindrome(string str) {
    
    if(str.empty()) return "";
    int len=str.length();
    int min_start=0;
    int max_len=1;
    
    for(int i=0;i0&&right
 
  
 
  
 
  
最长无重复字串(不是子序列，而是连续的)
 
  
 
  
void LNRS_dp_hash_impro(char * arr, int size)
{
    memset(visit, -1, sizeof visit);
    maxlen = maxindex = 0;
    visit[arr[0]] = 0;
    int curlen = 1;
    int last_start = 0;
 
    for(int i = 1; i < size; ++i)
    {
        if(visit[arr[i]] == -1)
        {
            ++curlen;
            visit[arr[i]] = i; /* 记录字符下标 */
        }else
        {
            if(last_start <= visit[arr[i]])
            {
                curlen = i - visit[arr[i]];
                last_start = visit[arr[i]] + 1;
                visit[arr[i]] = i; /* 更新最近重复位置 */
            }else
            {
                ++curlen;
                visit[arr[i]] = i; /* 更新最近重复位置 */
            }
        }
        if(curlen > maxlen)
        {
            maxlen = curlen;
            maxindex = i + 1 - maxlen;
        }
    }
    output(arr);
}
 
  
 
  
 
  
 
  
 
  

 
 
  

 
 
  

 
 
  

 
 
  
最大乘积子数组
 
  
 
  
class Solution {
public:
    int maxProduct(vector& nums) {
        int n=nums.size();
        int posmax=nums[0];
        int negmax=nums[0];
        int res=nums[0];
        for(int i=1;i
 
  
 
  

 
 
  

 
 
  

 
 
  

 
 
  

 
 
  
 
  
#include
#include
#include
using namespace std;
//最长公共子序列 
int lcs1(string str1, string str2) {
    int len1 = str1.length();
    int len2 = str2.length();
    
    vector>c(len1+1,vector(len2+1));
    for (int i = 0; i <= len1; i++) {
        for( int j = 0; j <= len2; j++) {
            if(i == 0 || j == 0) {
                c[i][j] = 0;
            } else if (str1[i-1] == str2[j-1]) {
                c[i][j] = c[i-1][j-1] + 1;
            } else {
                c[i][j] = max(c[i - 1][j], c[i][j - 1]);
            }
        }
    }
    return c[len1][len2];
}

//最长公共子串长度
int lcs2(string str1, string str2) {
    int len1 = str1.length();
    int len2 = str2.length();
    int result = 0;     //记录最长公共子串长度
    vector>c(len1+1,vector(len2+1));
    for (int i = 0; i <= len1; i++) {
        for( int j = 0; j <= len2; j++) {
            if(i == 0 || j == 0) {
                c[i][j] = 0;
            } else if (str1[i-1] == str2[j-1]) {
                c[i][j] = c[i-1][j-1] + 1;
                result = max(c[i][j], result);
            } else {
                c[i][j] = 0;
            }
        }
    }
    return result;
}

int main(){
	string str1="cnblogs";
	string str2="belong";
	cout<
 
  
 
  

 
 
  

 
 
  

 
 
  

 
 
  

 
 
  
 
  
区间dp
 
  
 
  
题目链接：
 
  
http://poj.org/problem?id=1141
 
 
  
题目大意：
 
  
给一个由[,],{,}组成的字符串序列，求增加最少的字符，使该序列能够匹配，并输出最后的方案。
 
  
解题思路：
 
  
区间dp.dp[i][j]表示从i~j 所需的最少的字符使之能匹配，转移的话要么是头尾匹配直接加中间，要么分成两段。
 
  
不过要输出到达路径，所以在用一个path[i][j]表示到达该路径时的选择，-1表示头尾，其他表示中间分开的位置。
 
  
递归输出路径。递归是个好东西，能够很大程度的改变顺序，特别是逆着的。
 
  
PS：这题不能用贪心直接模拟过，不一定非要每步都与前面的都匹配。
 
  
测试样例：(([[)]]  长度应为10 用模拟为12 
 
  
代码：
 
  
 
  
 
   
 
    
 
     [cpp]  view plain 
      copy 
     
 
     
 
      
    
 
   
 
   
     
    
  1.  "font-size:14px;">//递归输出结果，是个好东西  
    2.  
    
  2.  #include  
    3.  
    
  3.  #include  
    4.  
    
  4.  #include  
    5.  
    
  5.  #include  
    6.  
    
  6.  #include  
    7.  
    
  7.  #include  
    8.  
    
  8.  #include  
    9.  
    
  9.  #include  
    10.  
    
  10.  #include  
    11.  
    
  11.  #include  
    12.  
    
  12.  #include  
    13.  
    
  13.  #include  
    14.  
    
  14.  #include  
    15.  
    
  15.  #define eps 1e-6  
    16.  
    
  16.  #define INF 0x1f1f1f1f  
    17.  
    
  17.  #define PI acos(-1.0)  
    18.  
    
  18.  #define ll __int64  
    19.  
    
  19.  #define lson l,m,(rt<<1)  
    20.  
    
  20.  #define rson m+1,r,(rt<<1)|1  
    21.  
    
  21.  //#pragma comment(linker, "/STACK:1024000000,1024000000")  
    22.  
    
  22.  using namespace std;  
    23.  
    
  23.    
    24.  
    
  24.  /* 
    25.  
    
  25.  freopen("data.in","r",stdin); 
    26.  
    
  26.  freopen("data.out","w",stdout); 
    27.  
    
  27.  */  
    28.  
    
  28.  #define Maxn 110  
    29.  
    
  29.  char sa[Maxn];  
    30.  
    
  30.  int dp[Maxn][Maxn],path[Maxn][Maxn]; //dp[i][j]表示区间i~j内需要最少的字符数能够匹配，path[i][j]表示到达该状态是哪种情况，  
    31.  
    
  31.  //-1表示第一个和最后一个，其他表示中间的分段点，然后递归输出  
    32.  
    
  32.  //递归能够改变次序  
    33.  
    
  33.  void output(int l,int r) //递归是个好东西  
    34.  
    
  34.  {  
    35.  
    
  35.     if(l>r)  
    36.  
    
  36.        return ;  
    37.  
    
  37.     if(l==r) //到达了最后  
    38.  
    
  38.     {  
    39.  
    
  39.        if(sa[l]=='('||sa[l]==')')  
    40.  
    
  40.           printf("()");  
    41.  
    
  41.        else  
    42.  
    
  42.           printf("[]");  
    43.  
    
  43.        return ;  
    44.  
    
  44.     }  
    45.  
    
  45.     if(path[l][r]==-1) //首尾，先输出开始，然后递归输出中间，最后输出结尾  
    46.  
    
  46.     {  
    47.  
    
  47.        putchar(sa[l]);  
    48.  
    
  48.        output(l+1,r-1);  
    49.  
    
  49.        putchar(sa[r]);  
    50.  
    
  50.     }  
    51.  
    
  51.     else  
    52.  
    
  52.     {  
    53.  
    
  53.        output(l,path[l][r]);//直接递归输出两部分  
    54.  
    
  54.        output(path[l][r]+1,r);  
    55.  
    
  55.     }  
    56.  
    
  56.  }  
    57.  
    
  57.  int main()  
    58.  
    
  58.  {  
    59.  
    
  59.     while(gets(sa+1)) //有空串，scanf("%s"),不能读空串，然后少一个回车，会出错  
    60.  
    
  60.     {  
    61.  
    
  61.        int n=strlen(sa+1);  
    62.  
    
  62.        memset(dp,0,sizeof(dp));  
    63.  
    
  63.        for(int i=1;i<=n;i++)  
    64.  
    
  64.           dp[i][i]=1; //一个的话只需一个就可以匹配  
    65.  
    
  65.        for(int gap=1;gap//枚举区间长度  
    66.  
    
  66.           for(int i=1;i<=n-gap;i++) //枚举区间开始位置  
    67.  
    
  67.           {  
    68.  
    
  68.              int j=i+gap;  
    69.  
    
  69.              dp[i][j]=INF;  
    70.  
    
  70.              if((sa[i]=='['&&sa[j]==']')||(sa[i]=='('&&sa[j]==')')) //首尾情况  
    71.  
    
  71.                 if(dp[i+1][j-1]
    72.  
    
  72.                    dp[i][j]=dp[i+1][j-1],path[i][j]=-1;  
    73.  
    
  73.              for(int k=i;k//中间分隔情况  
    74.  
    
  74.                 if(dp[i][k]+dp[k+1][j]
    75.  
    
  75.                    dp[i][j]=dp[i][k]+dp[k+1][j],path[i][j]=k;  
    76.  
    
  76.           }  
    77.  
    
  77.        output(1,n);  
    78.  
    
  78.        putchar('\n');  
    79.  
    
  79.     }  
    80.  
    
  80.     return 0;  
    81.  
    
  81.  }  
    82.  
    
  82.    
    83.  
   
 
  
 
  
 HDU 4745 Two Rabbits
 
  
 题目地址
 
  
 题意：
 两只兔子，在n块围成一个环形的石头上跳跃，每块石头有一个权值ai，一只从左往右跳，一只从右往左跳，每跳一次，两只兔子所在的石头的权值都要相等，在一圈内（各自不能超过各自的起点，也不能再次回到起点）它们最多能经过多少个石头(1 <= n <= 1000, 1 <= ai <= 1000)。
 
  
 分析：
 其实就是求一个环中，非连续最长回文子序列的长度。
 dp[i][j] = max{ dp[i + 1][j], d[i][j - 1], (if a[i] == a[j]) dp[i + 1][j - 1] + 2 }
 
  
 
   复制代码 
  
 
  
 1 #include 
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 int dp[1010][1010];
 8 int a[1010];
 9 int main()
10 {
11     int i,j,n;
12     while(scanf("%d",&n)!=EOF)
13     {
14         if(!n) break;
15         memset(dp,0,sizeof(dp));
16         for(i = 1; i <= n ; i++)
17         {
18             scanf("%d",&a[i]);
19             dp[i][i] = 1;
20         }
21         for(i = n ; i >= 1 ;i--)
22         {
23             for(j = i+1; j <= n ; j++)
24             {
25                 if(a[i]==a[j])
26                 dp[i][j] = dp[i+1][j-1]+2;
27                 dp[i][j] = max(dp[i][j],max(dp[i+1][j],dp[i][j-1]));
28             }
29         }
30         int ans=1;
31         for(i = 1; i < n ; i++)
32         ans = max(ans,dp[1][i]+dp[i+1][n]);
33         printf("%d\n",ans);
34     }
35     return 0;
36 }
 
  
 
   复制代码 
  
 
  
 
 
 


                            

                        

                    

                    
                    

                    
                    
                    

                

                

                    
                

            

        

    

    

        
你可能感兴趣的:(算法与数据结构)

        

            

                
    
                    
  • CTF 竞赛密码学方向学习路径规划
                        David Max
CTF学习笔记密码学ctf信息安全
                        
    目录计算机科学基础计算机科学概念的引入、兴趣的引导开发环境的配置与常用工具的安装WattToolkit（Steam++）、机场代理Scoop（Windows用户可选）常用Python库SageMathLinux小工具yafuOpenSSLMarkdown编程基础Python其他编程语言、算法与数据结构（可选）数学基础离散数学与抽象代数复杂性分析密码学的正式学习兴趣的培养做题小技巧系统学习需要了解并
    
                    
    • 
                    
  • C++算法与数据结构
                        闻缺陷则喜何志丹
#算法基础算法数据结构c++动态规划图论背包问题贪心
                        
    求职的感想学历、证书、名气都是敲门砖，大大提高面试机会。能否入职主要取决于：a，项目（行业）经验。b，编程语言的熟练程度。c，算法水平。对于某个具体公司，a>b>c，对于所有公司ab>c，长期而言a
                    
    • 
                    
  • 350页前端校招面试题直击大厂：前端基础、前端核心、计算机基础、项目、Hr面
                        2401_86400095
前端
                        
    **1.HTML2.CSS3.前端基础4.前端核心5.前端进阶6.移动端开发7.计算机基础8.算法与数据结构9.设计模式10.项目11.职业发展12.Hr面**正文HTML1.浏览器页面有哪三层构成，分别是什么，作用是什么?2.HTML5的优点与缺点？3.Doctype作用?严格模式与混杂模式如何区分？它们有何意义?4.HTML5有哪些新特性、移除了哪些元素？5.你做的网页在哪些浏览器测试过,这些
    
                    
    • 
                    
  • 计算机专业考研书目（中科大）
                        FQLSY

                        
    考研408计算机学科专业基础综合一、数据结构1.教材：《数据结构》严蔚敏清华大学出版社清华大学严蔚敏的这本数据结构的教材是国内数据结构教材的权威。也是国内使用最广，其广度远远超越其他同类教材，计算机考研专业课命题必定以它为蓝本。这一本数据结构是2007年的最新版本，完全适合任何学校的考研数据结构的复习之用，是数据结构学习最权威的教材。2.辅导书：《算法与数据结构考研试题精析（第二版）》机械工业出版
    
                    
    • 
                    
  • Java实现家谱家族管理系统，图形化家谱家族树，单机应用程序
                        violet_ever_garden
javajavafx家谱树JAVA图形用户界面设计源代码
                        
    背景算法与数据结构实验内容，使用Java+JavaFX，花了两个星期独自完成。功能（1）普通用户、超级管理员不同角色，不同角色登录后的权限各不相同，普通用户可以进行查询；超级管理员有对所有成员增加、删除和修改的权限。现在的初始超级管理员：admin123456初始普通用户：user555123123（2）家谱中成员的信息中包含姓名、出生日期、婚否、地址、健在否、死亡日期（若其已死亡）等（3）数据以
    
                    
    • 
                    
  • 面试算法LeetCode刷题班—BAT面试官带你刷真题、过笔试
                        Dan Boneh
高级程序设计算法
                        
    课程名称:《面试算法LeetCode刷题班》——BAT面试官带你刷真题、过笔试主讲老师:林老师BAT资深研发工程师(T7/P8级)，致力于搜索引擎及其子系统的研发、迭代与优化，数据分析与挖掘领域专家，多年担任校园招聘、社会招聘面试官，丰富的面试候选人经验。课程简介:掌握算法与数据结构是成为优秀程序员的必经之路，众多国内外知名互联网企业都将算法面试作为程序员招聘的重要和必需途径，只有高效应对各类题目
    
                    
    • 
                    
  • 【算法与数据结构】算法与数据结构知识点
                        晚安66
算法算法
                        
    文章目录一、算法和数据结构和LeetCode介绍二、算法和数据结构入门2.1时间复杂度2.2空间复杂度2.3基础排序算法2.3.1选择排序算法2.3.2冒泡排序算法三、数组3.1二分法查找法3.2双指针法四、链表理论五、哈希表理论五、栈和队列理论5.1单调栈六、二叉树理论6.1树的定义6.2二叉树的存储方式6.3二叉树的遍历方式6.4高度和深度七、回溯算法八、贪心算法九、动态规划9.1背包问题9.
    
                    
    • 
                    
  • 【算法与数据结构】42、LeetCode接雨水
                        晚安66
算法算法
                        
    文章目录一、题目二、解法三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、题目二、解法  思路分析：  程序如下：复杂度分析：时间复杂度：O()O()O()。空间复杂度：O()O()O()。三、完整代码end
    
                    
    • 
                    
  • 【算法与数据结构】496、503、LeetCode下一个更大元素I II
                        晚安66
算法算法
                        
    文章目录一、496、下一个更大元素I二、503、下一个更大元素II三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、496、下一个更大元素I  思路分析：本题思路和【算法与数据结构】739、LeetCode每日温度类似。如果用暴力破解法时间复杂度需要O(m∗n)O(m*n)O(m∗n)，其中mmm和nnn分别是两个数组的长度。单调栈只需要O(
    
                    
    • 
                    
  • 【算法】【数据结构】算法与数据结构的关系
                        琛：D
算法数据结构算法数据结构
                        
    程序=算法+数据结构+语言工具和环境但在算法学习过程中，我认识到算法和数据结构是密不可分的，脱离数据结构谈论算法是空架子。算法：解决问题的步骤和方法。对数据进行操作和处理的方法。数据结构：用来存储数据的方式。数据结构和算法之间的关系可以看作是一种相互依赖的关系。在解决问题时，首先需要选择适当的数据结构来存储和组织数据，然后再设计合适的算法对这些数据进行操作和处理。数据结构的选择可以影响算法的效率和
    
                    
    • 
                    
  • Leetcode64. 最小路径和（C语言）
                        jeanlu
数据结构&算法算法动态规划c语言
                        
    Leetcode64.最小路径和（C语言）算法-动态规划（矩阵路径）：算法与数据结构参考题目：给定一个包含非负整数的mxn网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。每次只能向下或者向右一步，例：输入:[[1,3,1],[1,5,1],[4,2,1]]输出:7思路：动态规划。每个位置存储起点到当前位置的路径和最小值。注意行列下标代码：#definemin(a,b)(a
                    
    • 
                    
  • 算法与数据结构--简析红黑树
                        云逸Dean

                        
    1.为什么要使用红黑树：可以保证在O（logN）的时间复杂度下做查找删除添加2.性质：（来自于维基百科Red–blacktree条目）节点是红色或者黑色的（Eachnodeiseitherredorblack）根是黑色的,有时会被省略，由于根是黑色和红色对规范并没有其他影响(Therootisblack.Thisruleissometimesomitted.Sincetherootcanalway
    
                    
    • 
                    
  • 【算法与数据结构】583、72、LeetCode两个字符串的删除操作+编辑距离
                        晚安66
算法算法
                        
    文章目录一、583、两个字符串的删除操作二、72、编辑距离三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、583、两个字符串的删除操作  思路分析：本题的思路和115、不同的子序列差不多，只是变成了两个字符串都能删除字符。第一步，动态数组的含义。dp[i][j]dp[i][j]dp[i][j]代表使得word1[0,i−1]word1[0,
    
                    
    • 
                    
  • 【算法与数据结构】647、516、LeetCode回文子串+最长回文子序列
                        晚安66
算法算法
                        
    文章目录一、647、回文子串二、516、最长回文子序列三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、647、回文子串  思路分析：判断一个字符串是否为回文串那么必须确定回文串的所在区间，而一维数组无法描述区间，因此我们需要用一个二维的dp数组来表示。我们只需要统计dp数组中回文串的个数即可。第一步，动态数组的含义。dp[i][j]dp[i
    
                    
    • 
                    
  • 【算法与数据结构】718、1143、1035、392、115、LeetCode最长重复子数组+最长公共子序列+不相交的线+判断子序列+不同的子序列
                        晚安66
算法算法
                        
    文章目录一、718、最长重复子数组二、1143、最长公共子序列三、1035、不相交的线四、392、判断子序列五、115、不同的子序列六、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、718、最长重复子数组  思路分析：第一步，动态数组的含义。dp[i][j]dp[i][j]dp[i][j]代表以下标i−1i-1i−1为结尾的nums1，和以下
    
                    
    • 
                    
  • 【算法与数据结构】739、LeetCode每日温度
                        晚安66
算法算法
                        
    文章目录一、题目二、解法三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、题目二、解法  思路分析：  程序如下：复杂度分析：时间复杂度：O()O()O()。空间复杂度：O()O()O()。三、完整代码end
    
                    
    • 
                    
  • python算法与数据结构（搜索算法和拓扑排序算法）---广度优先搜索和拓扑排序
                        他是只猫
算法python数据结构BFS广度优先
                        
    广度优先搜索BFS定义&基本内容广度优先是按照层次由近及远的进行搜索，在当前层次所有可及节点都搜索完毕后才会继续往下搜索，其本质就是寻找从起点到终点的最短路程。树的广度优先搜索树的广度优先遍历，可以看成是层序遍历。访问顺序如图：图的广度优先搜索有向图：边存在方向的图；有向图中度分为入度（in-degree）和出度（out-degree）入度：表示有多少条边指向这个顶点；出度：表示有多少条边是以这个
    
                    
    • 
                    
  • python算法与数据结构---动态规划
                        他是只猫
算法python数据结构动态规划
                        
    动态规划记不住过去的人，注定要重蹈覆辙。定义对于一个模型为n的问题，将其分解为k个规模较小的子问题（阶段），按顺序求解子问题，前一子问题的解，为后一子问题提供有用的信息。在求解任一子问题时，通过决策求得局部最优解，依次解决各子问题。最后通过简单的判断，得到原问题的解。经典案例—斐波那契数列斐波那契数列又称黄金分割数列。因数学家莱昂纳多-斐波那契以兔子繁殖为例引入，故又称兔子数列。1,1,2,3,5
    
                    
    • 
                    
  • 【考研408】算法与数据结构笔记
                        newcih
408算法与数据结构考研
                        
    文章目录绪论数据结构的基本概念算法和算法评价线性表线性表的定义和基本操作线性表的顺序表示线性表的链式表示栈和队列栈基本操作栈的顺序存储结构栈的链式存储队列队列常见的基本操作队列的顺序存储结构队列的链式存储结构双端队列栈和队列的应用栈在括号匹配中的应用栈在表达式求值中的应用栈在递归中的应用队列在层次遍历中的应用队列在计算机系统中的应用特殊矩阵的压缩存储数组的定义数组的存储结构矩阵的压缩存储串串的定义
    
                    
    • 
                    
  • 第十五章 Caché 算法与数据结构 堆排序
                        Cache技术分享

                        
    第十五章Caché算法与数据结构堆排序二叉堆特性最大堆的堆顶是整个堆中的最大元素。最小堆的堆顶是整个堆中的最小元素。调整以最大堆为例，如果删除一个最大堆的堆顶（并不是完全删除，而是跟末尾的节点交换位置），经过自我调整，第2大的元素就会被交换上来，成为最大堆的新堆顶。image.png如上图所示，在删除值为10的堆顶节点后，经过调整，值为9的新节点就会顶替上来；在删除值为9的堆顶节点后，经过调整，值
    
                    
    • 
                    
  • 有事没事，研究研究算法
                        乌龟的慢生活

                        
    图片发自App图片发自App有点意思，算法很有意思的。学习经典算法与数据结构。看图说话，然后代码实现！然后解答实际问题。有意思的。利用好这些软件。
    
                    
    • 
                    
  • 南京邮电大学算法与数据结构设计：文本的加密与解密、校园导航系统
                        一直是我呀
课程设计开源算法数据结构qtc++课程设计
                        
    作者：由于文件数量过多，逐个上传较为繁琐，所以文章中上传的代码只是部分主要的结构，需要源码的小伙伴可以去我的Github上搜索，地址为：GitHub-xxz1314520/Algorithm-and-Program-Design-of-NJUPT:这是我在南京邮电大学计算机学院所开设的课程《算法与数据结构设计》写的项目A.文本的加密和解密一、课题内容和要求设计要求：设计对已知文本进行加密和解密程序
    
                    
    • 
                    
  • 【算法与数据结构】121、122、123、188、309、714、LeetCode买卖股票的最佳时机I II III IV+含冷冻期+含手续费
                        晚安66
算法算法
                        
    文章目录一、121、LeetCode买卖股票的最佳时机1.1动态规划1.2动态规划-滚动数组二、122、买卖股票的最佳时机II三、123、买卖股票的最佳时机III四、188、买卖股票的最佳时机IV五、309、买卖股票的最佳时机含冷冻期六、714、买卖股票的最佳时机含手续费七、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、121、LeetCod
    
                    
    • 
                    
  • 【算法与数据结构】300、LeetCode最长递增子序列
                        晚安66
算法算法
                        
    文章目录一、题目二、解法三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、题目二、解法  思路分析：  程序如下：classSolution{public:intlengthOfLIS(vector&nums){vectordp(nums.size(),1);intresult=1;for(inti=1;inums[j])dp[i]=max(
    
                    
    • 
                    
  • 算法考试复习
                        FakeCSer爱去网吧

                        
    引论算法与数据结构与程序的区别算法是求解问题的过程描述：从蛮力到策略数据结构是数据的组织与存储：从杂乱无章到井然有序程序=算法+数据结构算法描述自然语言伪代码流程图三种不同的计算机问题判断问题（yes,no）例如输入的数是否大于60优化问题（求最优解）例如从A到B的最短路径是什么数值计算常见的计算机问题排序查找串处理图问题组合问题几何问题数值问题概念什么是算法：算法是一系列解决问题的清晰指令，也就
    
                    
    • 
                    
  • 【Leetcode】算法与数据结构 C语言
                        造夢先森
算法与数据结构C语言进阶string函数leetcodemathstack
                        
    字符串：https://leetcode-cn.com/problems/reverse-string/voidswap(char*a,char*b){chart=*a;*a=*b,*b=t;}voidreverseString(char*s,intsSize){for(intleft=0,right=sSize-1;left=m||y=n||grid[x][y]=='0')//遇到边界或‘0’直
    
                    
    • 
                    
  • 【算法与数据结构】198、213、337LeetCode打家劫舍I, II, III
                        晚安66
算法算法
                        
    文章目录一、198、打家劫舍二、213、打家劫舍II三、337、打家劫舍III三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、198、打家劫舍  思路分析：打家劫舍是动态规划的的经典题目。本题的难点在于递归公式和初始化。第一步，dp[j]dp[j]dp[j]的含义。dp[j]dp[j]dp[j]代表到第jjj家的时候，偷窃到的最高金额。第二
    
                    
    • 
                    
  • 「干货」编程语言十大经典算法，你知道几个？
                        蓝桥云课
算法数据结构推荐算法
                        
    算法与数据结构是计算机学习路上的内功心法，也是学好编程语言的重要基础。今天给大家介绍一下十大经典算法。十大经典算法分别是：冒泡排序，插入排序，选择排序，希尔排序，快速排序，归并排序，桶排序，堆排序，计数排序，基数排序。预备知识：算法稳定性如果a==b，排序前a在b的前面，排序后a在b的后面，只要会出现这种现象，我们则说这个算法不稳定（即使两个相等的数，在排序的过程中不断交换，有可能将后面的b交换到
    
                    
    • 
                    
  • 【算法与数据结构】139、LeetCode单词拆分
                        晚安66
算法算法
                        
    文章目录一、题目二、解法三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、题目二、解法  思路分析：本题可以看做一个动态规划问题。其中，字符串s是背包，而字典中的单词就是物品。题目问的是单词能否组成字符串s，就是问物品能不能把背包装满。字典中的单词可以重复使用，因此是一个完全背包问题。第一步，dp[j]dp[j]dp[j]的含义。dp[j]d
    
                    
    • 
                    
  • python算法与数据结构---排序和归并排序
                        茨球是只猫
算法数据结构python排序算法
                        
    学习目标掌握归并排序的基本原理使用python语言解答归并排序题目归并排序原理及过程将两个有序的数组合并成一个有序数组称为从上往下分解：把当前区间一分为二，直至分解为若干个长度为1的子数组从上往下的合并：两个有序的子区域两两向上合并；体现了分治思想，稳定排序复杂度平均时间复杂度：O(NlogN)最坏时间复杂度：O(NlogN)归并排序合并过程temp数组用于存储合并结果，合并后拷贝回原数组；双指针
    
                    
    • 
                                
  • 枚举的构造函数中抛出异常会怎样
                                    bylijinnan
javaenum单例
                                    
    首先从使用enum实现单例说起。 
 
为什么要用enum来实现单例？ 
这篇文章（ 
http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 
1.enum单例简单、容易，只需几行代码： 
 

public enum Singleton {
	INSTANCE;
    
                                
    • 
                                
  • CMake 教程
                                    aigo
C++
                                    
    转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ 
  
CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 
介绍：http://baike.baidu.com/view/1126160.htm 
本文件不介绍CMake的基本语法，下面是篇不错的入门教程： 
http:
    
                                
    • 
                                
  • cvc-complex-type.2.3: Element 'beans' cannot have character
                                    Cb123456
springWebgis
                                    
      cvc-complex-type.2.3: Element 'beans' cannot have character 
    Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
    
                                
    • 
                                
  • jquery实例:随页面滚动条滚动而自动加载内容
                                    120153216
jquery
                                    
    <script language="javascript">
$(function (){
	var i = 4;$(window).bind("scroll", function (event){
		//滚动条到网页头部的 高度，兼容ie,ff,chrome
		var top = document.documentElement.s
    
                                
    • 
                                
  • 将数据库中的数据转换成dbs文件
                                    何必如此
sqldbs
                                    
    旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 
1)数据库生成表结构信息： 
        主要生成数据库配置文件(.conf文
    
                                
    • 
                                
  • 在IBATIS中配置SQL语句的IN方式
                                    357029540
ibatis
                                    
    在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 
 
1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： 
 
 
 
<select id="getForms" param
    
                                
    • 
                                
  • Spring3 MVC 笔记（一）
                                    7454103
springmvcbeanRESTJSF
                                    
        
     自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 
这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 
要看业务，和整体的设计！ 
 
     最近公司要求开发个新系统！
    
                                
    • 
                                
  • Timer与Spring Quartz 定时执行程序
                                    darkranger
springbean工作quartz
                                    
    有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date; 
    
                                
    • 
                                
  • 大端小端转换，le32_to_cpu 和cpu_to_le32
                                    aijuans
C语言相关
                                    
    大端小端转换，le32_to_cpu 和cpu_to_le32   字节序  
http://oss.org.cn/kernel-book/ldd3/ch11s04.html 
        小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
    
                                
    • 
                                
  • Nginx负载均衡配置实例详解
                                    avords

                                    
    [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解  负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 
负载均衡 
先来简单了解一下什么是负载均衡
    
                                
    • 
                                
  • 乱说的
                                    houxinyou
框架敏捷开发软件测试
                                    
    从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！   
这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白.    
不过感觉和程序开发语言差不多，   
瀑布就是顺序，敏捷就是循环.    
瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。   
  
也可以把软件开发理
    
                                
    • 
                                
  • 欣赏的价值——一个小故事
                                    bijian1013
有效辅导欣赏欣赏的价值
                                    
    　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
    
                                
    • 
                                
  • 包冲突问题的解决方法
                                    bingyingao
eclipsemavenexclusions包冲突
                                    
    包冲突是开发过程中很常见的问题： 
其表现有： 
1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 
2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 
3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 
抛如下异常： 
 
java.lang.NoClassDefFoundError: Could not in
    
                                
    • 
                                
  • 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j
                                    bit1129
Stream
                                    
    先来一段废话： 
实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
    
                                
    • 
                                
  • sudoku solver in Haskell
                                    bookjovi
sudokuhaskell
                                    
    这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。 
  
现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
    
                                
    • 
                                
  • java apache ftpClient
                                    bro_feng
java
                                    
    最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 
1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 
 
看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-工厂方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 


package design.pattern;

/*
 * 工厂方法模式：使一个类的实例化延迟到子类
 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）：
 * 有很多不同的产品，它
    
                                
    • 
                                
  • 面试记录语
                                    chenyu19891124
招聘
                                    
    或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 
今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
    
                                
    • 
                                
  • Fire Workflow 1.0正式版终于发布了
                                    comsci
工作workflowGoogle
                                    
    Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 
 官方网站是 http://www.fireflow.org 
 
 经过大家努力,Fire Workflow 1.0正式版终于发布了 
 
 正式版主要变化: 
1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 
2、增加IT
    
                                
    • 
                                
  • Python向脚本传参
                                    daizj
python脚本传参
                                    
    如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 
需要模块：sys 
参数个数：len(sys.argv) 
脚本名：    sys.argv[0] 
参数1：     sys.argv[1] 
参数2：     sys.argv[
    
                                
    • 
                                
  • 管理用户分组的命令gpasswd
                                    dongwei_6688
passwd
                                    
    NAME：  gpasswd - administer the /etc/group file 
SYNOPSIS： 
 gpasswd group 
 gpasswd -a user group 
 gpasswd -d user group 
 gpasswd -R group 
 gpasswd -r group 
 gpasswd [-A user,...] [-M user,...] g
    
                                
    • 
                                
  • 郝斌老师数据结构课程笔记
                                    dcj3sjt126com
数据结构与算法
                                    
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
                                
    • 
                                
  • yii2 cgridview加上选择框进行操作
                                    dcj3sjt126com
GridView
                                    
    页面代码
<?=Html::beginForm(['controller/bulk'],'post');?>
<?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
    
                                
    • 
                                
  • linux mysql
                                    fypop
linux
                                    
    enquiry mysql version in centos linux 
yum list installed | grep mysql 
yum -y remove mysql-libs.x86_64 
enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* 
install mysq
    
                                
    • 
                                
  • Scramble String
                                    hcx2013
String
                                    
    Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. 
Below is one possible representation of s1 = "great":
    
                                
    • 
                                
  • 跟我学Shiro目录贴
                                    jinnianshilongnian
跟我学shiro
                                    
    历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 
  
  
----广告-----------------------------------------------------
    
                                
    • 
                                
  • nginx日志切割并使用flume-ng收集日志
                                    liyonghui160com

                                    
      
   nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
    
                                
    • 
                                
  • Oracle死锁解决方法
                                    pda158
oracle
                                    
    　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
    
                                
    • 
                                
  • java之List排序
                                    shiguanghui
list排序
                                    
       在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
    
                                
    • 
                                
  • servlet单例多线程
                                    utopialxw
单例多线程servlet
                                    
    转自http://www.cnblogs.com/yjhrem/articles/3160864.html 
和   http://blog.chinaunix.net/uid-7374279-id-3687149.html 
Servlet 单例多线程 
Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的
    
                                
    • 
                

            

        

    




    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他