题意：给出一组N个数，每次从中抽出一个数（第一和最后一个不能抽），该次的得分即为抽出的数与相邻两个数的乘积。直到只剩下首尾两个数为止。问最小得分是多少。

最优子结构：

假设总得分最小时最后抽出的数在k位置，则在1:k和k:n之间的得分也是最小的。因为如果1:k或者k:n具有更小得分，则总得分会更小，与假设矛盾。

状态设计：

设dp[i][j]为第i个数到第j个数的最小得分，则dp[1][n]即为题中的解。

1<=i<=n-2;i+2<=j<=n;

dp方程：

dp[i][j]=min(dp[i][k]+dp[k][j]+s[i]*s[k]*s[j]);i<k<j;

观察方程，第一维中依赖的是i以后的值，第二维依赖的是j之前的值，所以第一维循环采用逆序循环，第二维采用顺序循环。

 

Memory: 756K		Time: 0MS
Language: G++		Result: Accepted

这个题目折腾了我很久，估计也有五六个小时。可能是太久（也快半个月了）没做过题，也可能是对矩阵连乘这类DP，或者直接是对DP没有更深入的理解（其实真正领悟DP又何尝简单？可以原谅）。其实矩阵连乘，在前几天才看了第二遍，当时没看书上的代码，认为对于DP看方程看代码其实是没多少意思的，重要的是那个思路，问题的分析，子结构的证明，然后自己写方程写代码。

我是百度矩阵连乘搜到这个题目的，所以这个题目的方法一开始就知道。最先自己简单的分析了一下子结构，然后找了个方程就开始写递归，结果调试就卡住了。然后没用递归，用数组，用堆栈又写了两次，发现都是卡在了同一个地方。

后来怀疑起子结构和方程，原来对子结构没有搞清楚，写出的方程也错的很不靠谱。待我通过了这个题后，看回自己的DP方程，发现兜了一大圈，还真是回到了矩阵连乘这里。

对于一个方法已经知道，类型也见过的题目，总是有一点轻视，加之对原来了解的就不深入，犯错就很容易理解了。

最后说说编程上的知识：

1， memset,strlen等字符串处理函数在G++要用到<cstring>头文件

2， scanf,printf要用到<stdio.h>头文件

3， ；abs在<cstdlib>中；fabs，sin，sqrt等数学函数在<cmath>中

当时我能看懂时间和空间均为O(MN^2)的函数，但可能由于自己看书是直接从动态规划一章看起，书上对于经过优化的函数也没有更多的解析，当时看起来完全不知所云。前几天看的时候，是对着方程结合书上的几句话自己去理解，尝试自己动手去写，但错了。看书上代码，都要自己去理解那些变量数组是干什么用的，感觉也是非常吃力。

1，

我觉得理解那个优化函数，必须先要充分理解那个二维的DP方程：

b[i][j]=max(b[i][j-1]+a[j],max(b[i-1][t])+a[j])  (i-1<=t<j)

b[i][j]表示的是第i段在前j项（含第j项）的最大值。对于b[i][j]含有第j项必须要理解好！则方程的意思是：对于a[j]项，要么将它加到第i段，要么它自己作为新的一段。

注意到方程外层的max选择，都要加上a[j]这一项。这里可能很容易产生一个疑问，如果a[j]是一个负数，为什么还要加上a[j]呢？回到b[i][j]所表示的意义上解释，由于b[i][j]表示的是含有第j项的最大值，所以a[j]是肯定要加进来的。假使a[j]是一个负数，它加进来了也不会影响在第i段中前j-1项的最大值。

所以第m段的最大值，并不是b[m][n]，而是b[m][m~n]之间的最大值。

同样道理，第i-1段的最大值是b[i-1][t],(i-i<=t<j)。

2，

理解了上述的DP方程后，再来考虑优化，正如书上所说的，由于在第i段中，只用到第i段和第i-1段的值。如果采用一维数组存储b[]，只要在计算第i段的时候，没有去改变第i-1段保留下来的值即可。再考虑到，内层max选择，需要用到第i-1段在i-1到j-1位置的最大值，不但要进行重复计算，也影响到b[j]的计算，因为j前面的值既要用作b[j]的计算，也要更新作为下一段i+1计算时所用。

为了解决这个问题，书上是利用了一个辅助的一维数组c[]，c[j]保存的是上一段i-1在j位置的最大值。显然计算第i段在j位置的值b[j]要用到的c[]的下标是从i-1到j-1的。

那么这时DP方程可以变为：

b[j]=max(b[j-1]+a[j],c[j-1]+a[j])

要注意，b[j-1]与c[j-1]是相差一段的，即b[j-1]计算的是第i段的值，而c[j-1]记录的是i-1段的值。

这里有一个关键是对c[]在计算第i段值b[j]的时候，要及时更新，以作计算下一段使用。

3，

以上的具体实现自己写不出来，还是照看书上的代码，略作解析。其实明白了上面说明的两段，书上代码是很好理解的。书上对于边界条件的处理，我觉得做得非常好，而我也正是错在这个地方。

这个题目的是求一个大整数p（10^101）开n（1<=n<=200）次方的结果k，即k^n=p或者，n=log k (p).

题目说保证p和n都是整数，并且求到得结果k一定是一个整数。但discuss里有说，有些测试数据是不存在整数k的。

这个题目的本意应该是高精度加二分吧，但我没写。

在discuss看到，有些是直接用double和pow()函数的，一句话AC了以后，有很大的“罪恶感”。

本人小菜，连double和pow()都不会用，用了也是一头雾水，觉得这种方法能通过，完全是因为测试数据太弱。

（在VC++ 6.0调试）

一句话能AC的C代码是这样的：

首先用double接受一个10^101次方的数，确实可以，因为double的范围是-1.7^308~1.7^308，但精度只有16或17位（四舍五入位）。

然后设p是一个大于17位的整数，那么四舍五入后可能得到的两个值p1和p2，不妨记p1>p,p2<p。

就算测试数据都是合法的，就是说能保证k是一个整数，即有k=p^(1/n)。那么可以保证的是p1^(1/n)>k而p2^(1/n)<k的。

那么问题就来了，p1^(1/n)的上界怎么确定，p2^(1/n)的下界又怎么确定呢？

用double和pow()函数至少要能确保k+1>p1^(1/n)>k和k-1<p2^(1/n)<k吧？因为只有这样，对结果pow(p,1/n)四舍五入才能得到结果k。

但如何能确保对p用double存储的时候得到的估计值p1和p2的精确度在

p1-p<(k+1)^n-k^n和p-p2>k^n-(k-1)^n呢？

本人的智商只能到这里，还望各路神牛不吝赐教。

题意：在一块地里面，干燥的点标记为0，潮湿的点标记为1；求相连的1的最大个数。

由于自己对搜索不太熟悉，当时以为是记忆化搜索，后来用dfs和bfs各写了一次后，感觉就是一纯粹的搜索而已。

我到目前也还觉得，记忆化搜索是DP的一类，搜索过的地方，记录下来，是要多次用到的。而这个题的搜索，只需简单的标记一下搜索过的地方，以便不会再搜，而对已搜索的地方进行标记是搜索题的一个共性吧？

当时写dfs多开了一个数组进行标记，后来看了一下别人的代码，看到标记数组都不用开，直接在原数组进行标记就得。这样我才开始思考，记忆化搜索与简单搜索的不同，记忆化搜索由于要用到搜索过的地方，直接用原数组进行了标记，就无法记录（也不能太绝对，可能有些情况用记录值也可以达到标记的效果，这个题貌似也可以，但可能就比较麻烦）。

这个题目用原数组进行标记的话，就要开一个变量统计每一轮搜索的最大值。但这种方法确实是好。

然后用bfs来写的话，就要用到一个队列。当时自己写一个队列类，调了N久才发现自己错在一个很低级的理解错误上。我定义一个类，类里面有静态成员，我的目的就是想让静态数据成员进行记录队列长度。然后又将类像链表结构体一样进行动态分配进行链接，还以为那个静态成员依然是原来那个。

写出来后发现有很大浪费，主要是由于指针指向没有认真分析，然后稳健性也非常不好。

干脆用STL的queue算了。

然后又没有注意同一个点进行了多次进队，WA一次。

题意：

一个学生用M天的时间复习N门课程，每门课程花费不同的天数，有不同的收获。问如何安排这M天，使得收获最大。

思路：

可以将每一门课看成一个分组，每门课不同天数的选择看成是分组的物品（显然只能有一个选择），物品的费用即为花费的天数，物品的价值为题中给出的收获。该题中背包容量最大为M。

设dp[x]为前i组物品，在背包容量为x（即费用为x）时的最大价值。则将i从1到N进行过历遍后（第一重循环），dp[m]即为所求。

在这种状态设置中，容易想出以下两种阶段递推方式（以下所述都为第二和第三重循环）：

1，在同一个背包容量中，对不同费用的物品进行枚举比较：

for(j=MAX;j>=1;--j)   //背包容量

      for(k=1;k<=m;++k)  //不同费用的物品

2，在同一费用的物品中，对放在不同背包容量时计算最大价值：（该方式同《背包九讲-分组背包》中的伪代码部分）

for(k=1;k<=m;++k)    //不同费用的物品

      for(j=MAX;j>=1;--j)  //背包容量

简略分析：

1，分析第一种递推方式的正确:

该方式即求在容量为j的背包中，选择哪一个物品可以有最大价值。

看递推方程：dp[j]=max(dp[j],dp[j-c[k]]+w[k]);（其中c[k]为k物品的费用，w[k]为价值），由于递降枚举背包容量，max比较中的dp[j]是由上一组物品决策所得，在这里将被忽略。因为就算不忽略，在本组物品中dp[j]的决策依然要取决于dp[j-c[k]]+w[k]。

而同样由于递降枚举背包容量（第二重循环），dp[j-c[k]]在本组物品中是未进行过决策的，亦即背包容量为j-c[k]时，在本组物品中是没有选择任何物品的，这可以保证对dp[j]决策时，不会多选本组中的物品。

2，分析第二种递推方式的错误：

该方式即求对物品k，放在所有背包中，计算各个最大价值。

同样是递推方程：dp[j]=max(dp[j],dp[j-c[k]]+w[k]);（其中c[k]为k物品的费用，w[k]为价值）。能否保证dp[j-c[k]]在本组中未经决策，就成了该递推方式对错的关键。

由于背包容量的递降枚举在第三重循环，只能保证k物品不会重复选择。对于另一k0物品，当背包容量枚举到j-c[k]的时候，由方程可以有：dp[j-c[k]]=max(dp[j-c[k]],dp[j-c[k]-c[k0]]+w[k0]，亦即dp[j-c[k]]可能在本组中的其他物品中进行过决策。

那么这样就可能导致在一组物品中选择了多件物品。

----------------------------------------------------------------------------------------------------------------------

周五的早上AC了那个题目，但是感觉留下了一堆的问题。然后忙了两天别的事，直到今天才感觉彻底搞懂了。

在最近的几个题中，也算逐渐明白知识学习与能力培养的区别。

----------------------------------------------------------------------------------------------------------------------

以下附《背包九讲-分组背包》中的内容和HDU 1712的代码。

分组背包：

P06: 分组的背包问题
 问题
 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

 算法
 这个问题变成了每组物品有若干种策略：是选择本组的某一件，还是一件都不选。也就是说设f[k][v]表示前k组物品花费费用v能取得的最大权值，则有f[k][v]=max{f[k-1][v],f[k-1][v-c[i]]+w[i]|物品i属于第k组}。

 使用一维数组的伪代码如下：

 for 所有的组k
 for 所有的i属于组k
 for v=V..0
 f[v]=max{f[v],f[v-c[i]]+w[i]}

 另外，显然可以对每组中的物品应用P02中“一个简单有效的优化”。

 小结
 分组的背包问题将彼此互斥的若干物品称为一个组，这建立了一个很好的模型。不少背包问题的变形都可以转化为分组的背包问题（例如P07），由分组的背包问题进一步可定义“泛化物品”的概念，十分有利于解题。

----------------------------------------------------------------------------------------------------------------------

题意：有N个不同长度fence，求用所有fence能组成的最大三角形的面积。

几天前就看到这个题了，今天才过掉，对这个题感觉非常失败。

首先第一想法是：将总边长的三分之一做为背包容量，进行一次0-1背包，然后再用剩下的三分之二边长的一半做背包容量，再进行一次0-1背包。但问题是进行第一次背包的时候要记录使用过的边，以便在第二次背包时不再使用。但由于能力问题，动手写过两次都无法解决这个问题。百度一下，发现人家也想到这个思路，但都被否决了，原因是这样的思路，通过找三边差值最小，并不能保证面值最大。

然后我就没想法了。直到今天，看到marvin（网上认识的ACMer）的blog，才知道思路应该是这样的：枚举第一条边和第二条边的组合，用sgn[j][k]标记第一边长为j，第二边长为k。如果能从给出的边里组成这两条边，则进行标记。

看到这个思路后，发现原来就是这么简单，但怎么自己就没有想到呢。然后马上动手就写，又WA到快吐血。

虽然很快发现问题出在了用背包枚举两边组合的那几行代码，但就是改不过来，在那里纠结得跳楼的心都有。做了一个星期的背包，居然连这几行代码都写不出，都羞死了。

写不出那几个代码的原因：1，对用背包枚举两边组合的原理理解不透彻。2，没有认真分析组合情况。3，做单纯的背包题时留下的思维僵硬。4.，将或运算想当然的写成了并运算。

AC了这个题目后，对背包枚举两边组合部分的三重循环的边界条件感觉还是很抽象。再深入去想，才逐渐明了。

1，需要枚举的两条边的长度都是不能超过总长的一半的。

2，由于各边只能使用一次，同0-1背包，循环需要用逆序。

3，对于第条边，如果已有sgn[j-fence[i]][k]或者sgn[j][k-fence[i]]，则必有sgn[j][k]。由于这种组合只需满足其中一个即可，所以j和k都要枚举到0并且要保证j>=fence[i]或者k>=fence[i]。

4，优化速度的问题。由于j和k可能会出现长度交换时会进行重复计算，所以在计算的时候可以只取j>=k的情况，但枚举组合的时候能取j>=k进行枚举吗？表面上对j>=k的情况进行过枚举，似乎就满足目的了。但实际上，这样的j>=k的限制导致，能枚举，但不能有效地标记组合。

设sgn[j0][k0]为确定组合(0<=k0<=j0)  （确定组合即为能够确定这种组合的存在与否）

若k0+fenc[i]>j0时

fence[i]只能加到第一边，得到确定组合sgn[j0+fence[i]][k0]

当fence[i+1]+k0>j0+fence[i]时，(显然，这时fence[i+1]>fence[i])

fence[i+1]又只能加到第一边。

这样sgn[j0+fence[i+1]][k0+fence[i]]的组合就只能标记为失败了。

解决方式是：对于fence[i]，只要第一边不使用这个fence[i]的时候，必须要让它能够加到第二边。这样去k=j+fence[i]即可。

在pku用二维费用重做了一次1882以后，发现这个题其实也挺简单的。

先说一下pku1882，第一个费用是张数，第二个费用是与价值等同的重量，即题中的面值。

可以设计状态为f[i][j]表示用到第i张邮票组成面值为j时能获得的最大价值，即能组成最大的面值（<=j）。然后是转化为完全背包来做，循环顺序由低到高。

然后hdu 2159比pku 1882好处理，要处理的数据比较少。不同的是，二维费用改变了，背包状态的设计也改变了。

设f[i][j]表示杀到第i个怪，忍耐度在j的时候能获得的最大价值。注意这样设计状态的话，开的数组不用很大。我是数组开小了，贡献了一次RE，很厚道，报的是RE，如果是WA，就难受了。

这样设计状态，在后面查找结果的时候要对j进行一次历遍查找。

 其实这个题找到了切入口后，是挺简单的。我似乎总有一种先入为主的倾向，想到一点点就下手，结果浪费时间，还掉入死胡同里。总之我是没找到那个切入口，然后看了一下discuss，原来排序就可以了，ft！！怎么我就笨得想不到了。其实我是想过排序，但没有深入去考虑。

 整个题最后的解肯定是不大于最大高度的type的。

将最大高度排序后，先叠好高度低的，高度大的叠在上面。

每一高度只要能组合就行进标记，不再浪费后面的blocks。同时对于某一blocks，只要枚举高度到该type的最大高度即可，并记录改高度使用了该type的blocks的个数。（背包部分）

 1#include <iostream>
 2#include <algorithm>
 3using namespace std;
 4const int MAX=40000;
 5const int MMAX=400;
 6struct type
 7{
 8    int h,a,c;
 9}data[MMAX+1];
10bool cmp(type x,type y)
11{
12    return x.a<y.a;
13}
14int cnt[MAX+1];
15bool sgn[MAX+1];
16int main()
17{
18    int n,i,j;
19    scanf("%d",&n);
20    for(i=1;i<=n;++i)    scanf("%d%d%d",&data[i].h,&data[i].a,&data[i].c);
21    sort(data+1,data+1+n,cmp);
22
23    memset(sgn,0,sizeof(sgn));
24    sgn[0]=1;
25    for(i=1;i<=n;++i)
26    {
27        memset(cnt,0,sizeof(cnt));
28        for(j=data[i].h;j<=data[i].a;++j)
29            if(!sgn[j]&&sgn[j-data[i].h]&&cnt[j-data[i].h]<data[i].c)
30            {
31                sgn[j]=1;
32                cnt[j]=cnt[j-data[i].h]+1;
33            }
34    }
35
36    for(j=data[n].a;j>=0;--j)
37        if(sgn[j])
38
39            break;
40    printf("%d\n",j);
41    return 0;
42}

正如网上说的，这是个挺裸的背包了。做了几个背包的题后看到这题，感觉就挺简单了。

这里需要注意的是首先要能判断题目有没有解，有解的情况下要找出最小解。

思路依然是数组标记的方法，对于第j面值，如果第j-w[i]面值有解，则j面值肯定有解。

这时要找最小解。要注意的是，如果j面值当前是0的话，首先为了确保有解，这时不用找最小解，直接加过去就得。

 1#include <iostream>
 2    using namespace std;
 3    const int MAX=10000;
 4    int w[MAX+1],v[MAX+1];
 5    int dp[MAX+1];
 6    bool sgn[MAX+1];
 7    int main()
 8    {
 9        int t;
10        scanf("%d",&t);
11        while(t--)
12        {
13            int start,end,n,i,j;
14            scanf("%d%d%d",&start,&end,&n);
15            for(i=1;i<=n;++i)
16                scanf("%d%d",&v[i],&w[i]);
17
18            memset(dp,0,sizeof(dp));
19            memset(sgn,0,sizeof(sgn));
20            sgn[0]=1;
21            for(i=1;i<=n;++i)
22                for(j=w[i];j<=MAX;++j)
23                    if(sgn[j-w[i]]&&dp[j]!=0)
24                    {
25                        dp[j]=dp[j]<dp[j-w[i]]+v[i]?dp[j]:dp[j-w[i]]+v[i];
26                        sgn[j]=1;
27                    }
28                    else if(sgn[j-w[i]]&&dp[j]==0)
29                    {
30                        dp[j]=dp[j-w[i]]+v[i];
31                        sgn[j]=1;
32                    }
33
34            if(dp[end-start]==0)
35                printf("This is impossible.\n");
36            else
37                printf("The minimum amount of money in the piggy-bank is %d.\n",dp[end-start]);
38        }
39        return 0;
40    }
41

这个题目跟3211 Washing Clothes做法非常相似，虽然3211是0-1背包，1014是多重背包。思路都是将总价值的一半作为背包容量，然后进行背包策略就行了。

用多重背包的个数标记，时间为O(N*M),一次AC。

然后用二进制物品压缩，数组开小了，居然报WA，晕死。

 1#include <iostream>
 2using namespace std;
 3const int MAX=60000;
 4bool sgn[MAX+1];
 5int cnt[MAX+1];
 6int data[7];
 7int main()
 8{
 9    int cas=0;
10    while(cin>>data[1]>>data[2]>>data[3]>>data[4]>>
11        data[5]>>data[6])
12    {
13        int i,j,n=6,sum=0;
14        for(i=1;i<=n;++i)
15            if(data[i]!=0)
16                break;
17        if(i>n)        break;
18
19        ++cas;
20
21        memset(sgn,0,sizeof(sgn));
22        sgn[0]=1;
23        for(i=1;i<=n;++i)
24        {
25            memset(cnt,0,sizeof(cnt));
26            for(j=i;j<=MAX;++j)
27                if(!sgn[j]&&sgn[j-i]&&cnt[j-i]<data[i])
28                {
29                    cnt[j]=cnt[j-i]+1;
30                    sgn[j]=1;
31                }
32        }
33        
34        for(i=1;i<=n;++i)
35            sum+=data[i]*i;
36        if(sum%2||!sgn[sum/2])
37        {
38            cout<<"Collection #"<<cas<<":"<<endl;
39            cout<<"Can't be divided."<<endl;
40            cout<<endl;
41        }
42        else
43        {
44            cout<<"Collection #"<<cas<<":"<<endl;
45            cout<<"Can be divided."<<endl;
46            cout<<endl;
47        }
48    }
49    return 0;
50}
51

题意：

有一堆衣服，多种颜色，每种颜色的可能有多件。有两个洗衣服速度相同的人要洗干净这堆衣服。每件衣服都有一个洗干净所要花费的时间。两个人同时工作，但只有一种颜色的衣服都洗完后，两人才可以开始洗其他颜色。问这两个人洗完这堆衣服最少需要多少时间。

思路：将某种颜色的时间之和的一半作为0-1背包的容量，物品的价值与重量等同于该种颜色的衣服所花费的时间，这是关键思路啊！只要求得这个背包的能获得的最大价值，就是说在这一半的时间里，有多少是被最有效利用的。然后总时间减去这个有效利用的，就是洗完这堆衣服最少要花费的时间。

要处理这个题的输入可能比较麻烦。将输入的数据转化为要进行背包的数据后，背包部分就简单了。

如果，这个题改一下，要分两行输出没人要洗的衣服呢？又怎么处理了？

 1#include <iostream>
 2#include <string>
 3#include <algorithm>
 4using namespace std;
 5const int MAX=50000;  //变成两个背包以后，一个的容量最多就是50000
 6char name[150];     //这个没什么用，就是吃掉那一行的名字输入
 7int sum[10];        //每一种颜色的时间之和
 8struct clother
 9{
10    int tim;
11    string color;
12}clo[100];
13int data[12][100];    //将原来读入的数据转化后好进行0-1背包
14int dp[10][MAX+1];    //不解析
15bool cmp(clother a,clother b)
16{return a.color<b.color;}
17
18int main()
19{
20    int m,n;
21    while(cin>>m>>n&&(n||m))
22    {
23        getchar();
24        cin.getline(name,150);
25        int i,j,k;
26        for(i=1;i<=n;++i)
27            cin>>clo[i].tim>>clo[i].color;
28        sort(clo+1,clo+1+n,cmp);         //输入完以后马上排序
29        
30        data[1][1]=clo[1].tim;
31        for(i=2,j=1,k=2;i<=n;++i)      //data[j][0]是记录第j种颜色的衣服件数
32            if(clo[i].color==clo[i-1].color)
33                data[j][k++]=clo[i].tim;
34            else
35            {
36                data[j][0]=--k;
37                ++j;
38                k=2;
39                data[j][1]=clo[i].tim;
40            }
41        data[j][0]=--k;
42        n=j;     //n变成了需要进行背包的颜色种数
43                //这一段很容易理解，但可能处理比较麻烦，从排序后的第二个数据，即i=2开始
44                //感觉这样比较好处理
45
46        memset(sum,0,sizeof(sum));   //这段是数据转化后进行时间之和统计
47        for(i=1;i<=n;++i)
48        {
49            for(j=1;j<=data[i][0];++j)
50                sum[i]+=data[i][j];
51        }
52
53        memset(dp,0,sizeof(dp));   //这一段就是进行0-1背包了
54        for(i=1;i<=n;++i)
55            for(j=1;j<=data[i][0];++j)
56                for(k=MAX;k>=data[i][j];--k)
57                    dp[i][k]=dp[i][k]>dp[i][k-data[i][j]]+data[i][j]?
58                    dp[i][k]:dp[i][k-data[i][j]]+data[i][j];
59
60        for(i=1;i<=n;++i)
61            sum[i]-=dp[i][sum[i]/2];  
62                //摘自poj discuss TangMing 的一句话：
63                //把sum[i]/2的背包最大填满,第i种颜色耗时就为 sum[i]-dp[sum[i]/2];
64                //虽然这段代码很短，但是整个思路的关键
65
66        for(i=1;i<=n;++i)
67            sum[0]+=sum[i];
68        cout<<sum[0]<<endl;
69    }
70    return 0;
71}

我觉得这个题目跟pku 1276 cash machine和pku 1882 stamps都有点像。
首先与1276 cash machine一样，都是价值等于重量的多重背包，但1276可以用二进制压缩物品转0-1背包，这个题

目当然也可以，但会超时。所以discuss有一帖说教主忽悠了大家。
与1882 stamps像，是因为是都是有张数限制，都是通过完全背包来做吧，个人觉得。只是张数限制稍有不同，一个

是单个物品张数，一个是所有物品张数。就因为这个，两个题一个分在多重背包，一个分在了完全背包。转完全背

包后，时间就可以变为O(N*M)了。

我是看《背包九讲》的二进制压缩物品，然后直接拿这个题开刀。超时几次后，上网找O(N*M)的算法途中，看到别

人的一点提示，发现跟1882可以一样做法。

题意：
有多种面值不同的硬币，每种硬币有多枚，给出一个数M，求出1到M之间，有多少个面值是可以通过这些硬币组成的

。

思路：
定义一个标记数组sgn[MAX+1]，将1到MAX之间的能组成的面值进行标记。一个张数统计数组num[MAX+1],表示对于第

i种硬币，当组成j面值时，使用的张数num[j]。
这里可能有一个比较绕的问题：过早的使用完了第i种硬币，会不会对第i+1种硬币进行策略的时候造成影响呢？答

案是会的，但正是需要这种影响。对第i+1种硬币进行策略组合的时候，正是建立在前i种硬币组成的基础上。
对已组合的面值j进行标记，一是因为这是后面组成面值的基础，二能保证对后面的硬币个数不会造成浪费。

 1#include <iostream>
 2using namespace std;
 3const int MAX=100000;
 4bool sgn[MAX+1];
 5int cnt[MAX+1];
 6int a[101],c[101];
 7int main()
 8{
 9    int n,m;
10    while(scanf("%d%d",&n,&m)&&(n||m))
11    {
12        int i,j;
13        for(i=1;i<=n;++i)    scanf("%d",&a[i]);
14        for(i=1;i<=n;++i)    scanf("%d",&c[i]);
15        memset(sgn,0,sizeof(sgn));
16        sgn[0]=1;
17
18        for(i=1;i<=n;++i)
19        {
20            memset(cnt,0,sizeof(cnt));
21            for(j=a[i];j<=MAX;++j)
22                if(!sgn[j]&&sgn[j-a[i]]&&cnt[j-a[i]]<c[i])
23                {
24                    cnt[j]=cnt[j-a[i]]+1;
25                    sgn[j]=1;
26                }
27        }
28
29        for(i=1,j=0;i<=m;++i)
30            if(sgn[i])
31                ++j;
32
33        printf("%d\n",j);
34    }
35    return 0;
36}

题意：
取款机里有多种不同面值的钞票，各种面值的钞票的张数也不同，给出取款值CASH，问最多能拿出多少钱。

思路：
将钞票看成是价值等于重量的物品，取款值为背包容量，那么这个题就是一个典型的多重背包。
从数据规模考虑，直接变为0-1背包求解，O(CASH*NK*N)的时间肯定超时。参考《背包九讲》中的用二进制压缩

物品可以将时间优化为O(CASH*N*logNK)，这样可以变成物品个数不超过100个的0-1背包。
然后便是0-1背包的求解了。

失误：
由于第一次学多重背包，看到二进制压缩物品时，当时以为看懂了，提交后错了N多次，才发现压缩时的最后一

项系数搞错了。然后处理不好，又出现负数的情况，导致一直RE。修补压缩物品部分，感觉又长又臭，遂通过研

究一番将物品压缩部分缩小到11行。

 1#include <iostream>
 2#include <math.h>
 3using namespace std;
 4const int MAX=100005;
 5int w[150],dp[MAX+1];
 6struct deno
 7{
 8    int cnt;
 9    int num;
10}data[12];
11int main()
12{
13    int n,m;
14    while(scanf("%d",&n)!=EOF)
15    {
16        scanf("%d",&m);
17        int i,j,k=1,tmp;
18        for(i=1;i<=m;++i)
19            scanf("%d%d",&data[i].cnt,&data[i].num);
20
21        memset(dp,0,sizeof(dp));
22        memset(w,0,sizeof(w));
23
24        for(i=1;i<=m;++i)
25        {
26            j=0;
27            while(data[i].cnt+1>=pow(2.0,j+1))
28            {
29                tmp=pow(2.0,j++);
30                w[k++]=tmp*data[i].num;
31            }
32            tmp=data[i].cnt+1-pow(2.0,j);
33            if(tmp)
34                w[k++]=tmp*data[i].num;
35        }
36
37        for(i=1,--k;i<=k;++i)
38            for(j=MAX;j>=w[i];--j)
39                dp[j]=dp[j]>dp[j-w[i]]+w[i]?dp[j]:dp[j-w[i]]+w[i];
40
41        printf("%d\n",dp[n]);
42    }
43    return 0;
44}
45
46

题意：
给出多组由不同面值组成的邮票，求出由给出的那些面值能组成连续面额值最大的一组。（具体见原题，做完后发

现是95年的finals,呵呵）

刚看完背包九讲的第二讲完全背包，百度一下pku 完全背包，看到有说pku1882是一完全背包。按照完全背包去想，

写出的代码调了很久，然后越调发现越不像完全背包。完全背包里物品都有一个价值，物品个数不限，而在这个题

目里，都不满足这两个条件，可能我太水吧，但我真的不知道怎么能将这个题按完全背包去想。如果说有相似的话

，我觉得就是在状态设计和递推顺序与完全背包是很相似的，可能吧，就是这个原因，就可以将这个DP分在完全背

包一类中。

思路：
假设邮票没有张数限制，那么就很像完全背包了(ft!!)。然后对1到1000（最多是(91+92+……100)*10）的各种面额

进行枚举。同时记录每一种面额的最小张数。最后做一次统计，张数为0或是大于题目要求的都是不符合的面额。
枚举的过程是很像完全背包是挺相似的说。

题目的测试数据里有一些毛病，在每一组邮票中，面值为1的邮票是一定出现了的。

 1#include <iostream>
 2using namespace std;
 3const int MAX=961;
 4int dp[12][MAX];
 5int data[12][12];
 6int fmin(int a,int b)
 7{return a<b?a:b;}
 8int main()
 9{
10    int s;
11    while(scanf("%d",&s)&&s)
12    {
13        memset(dp,0,sizeof(dp));
14        int n,i,j,k;
15        scanf("%d",&n);
16        for(i=1;i<=n;++i)
17        {
18            scanf("%d",&data[i][0]);
19            for(j=1;j<=data[i][0];++j)
20            {
21                scanf("%d",&data[i][j]);
22                dp[i][data[i][j]]=1;
23            }
24        }
25        
26        for(i=1;i<=n;++i)
27            for(j=1;j<=data[i][0];++j)
28                for(k=data[i][j]+1;k<=MAX-1;++k)
29                    if(dp[i][k-data[i][j]]==0)
30                        dp[i][k]=0;
31                    else if(dp[i][k]==0)
32                        dp[i][k]=dp[i][k-data[i][j]]+1;
33                    else
34                        dp[i][k]=fmin(dp[i][k],dp[i][k-data[i][j]]+1);
35        
36        for(i=1;i<=n;++i)
37        {
38            for(j=1;j<=MAX-1;++j)
39                if(dp[i][j]==0||dp[i][j]>s)
40                    break;
41            data[i][data[i][0]+1]=j-1;
42        }
43
44        k=1;
45        for(i=2;i<=n;++i)
46            if(data[i][data[i][0]+1]>data[k][data[k][0]+1])
47                k=i;
48            else if(data[k][data[k][0]+1]==data[i][data[i][0]+1]&&data[i][0]<data[k][0])
49                k=i;
50            else if(data[k][data[k][0]+1]==data[i][data[i][0]+1]&&data[k][0]==data[i][0]
51                    &&data[i][data[i][0]]<data[k][data[k][0]])
52                k=i;
53    
54        printf("max coverage = %d : ",data[k][data[k][0]+1]);
55        for(i=1;i<=data[k][0];++i)
56            printf("%d ",data[k][i]);
57        printf("\n");
58    }
59    return 0;
60}
61

 1#include <iostream>
 2using namespace std;
 3int d[12][12][1002];
 4int test[12][13];
 5int fmax(int a,int b)
 6{return a>b?a:b;}
 7int main()
 8{
 9    int s,n;
10    while(scanf("%d",&s)&&s)
11    {
12        scanf("%d",&n);
13        int i,j,k,l;
14        for(i=1;i<=n;++i)
15        {
16            scanf("%d",&test[i][0]);
17            for(j=1;j<=test[i][0];++j)    scanf("%d",&test[i][j]);
18        }
19
20        memset(d,0,sizeof(d));
21        for(i=1;i<=n;++i)
22        {
23            for(j=1;j<=test[i][0];++j)
24                for(k=1;k<=s;++k)
25                    for(l=test[i][j];l<=1000;++l)
26                        d[i][k][l]=fmax(d[i][k][l],d[i][k-1][l-test[i][j]]+test[i][j]);
27            for(j=1;j<=1000;++j)
28                if(d[i][s][j]!=j)
29                    break;
30            test[i][test[i][0]+1]=j-1;
31        }
32
33        k=1;
34        for(i=2;i<=n;++i)
35            if(test[i][test[i][0]+1]>test[k][test[k][0]+1])
36                k=i;
37            else if(test[i][test[i][0]+1]==test[k][test[k][0]+1]
38                &&test[i][0]<test[k][0])
39                k=i;
40            else if(test[i][test[i][0]+1]==test[k][test[k][0]+1]
41                &&test[i][0]==test[k][0]
42                &&test[i][test[i][0]]<test[k][test[k][0]])
43                k=i;
44
45        printf("max coverage = %d : ",test[k][test[k][0]+1]);
46        for(i=1;i<=test[k][0];++i)
47            printf("%d ",test[k][i]);
48        printf("\n");
49    }
50    return 0;
51}

题意：
某人有一大笔资金s(s<1000000)，想通过购买债券获利。现有n(n<=10)种债券可买。已知每种债券购买金额w(1000的倍数)和一年后的获利v(不多于购买金额的10%)。可以将每年得到的所有获利都再次投入。问t(t<=40)年后，该人共有多少钱。

看懂题目的第一感觉是没思路，在网上找别的完全背包，找不到了，只能去想这个题。

当时的第一思路是每年获利后都做一次完全背包。至于状态压缩，是将原有资金和购买金额都除以1000，获利不变。每次背包后，都将最大获利除以1000，加到原有资金里（用double型）。
过了样例，提交返回了多次RE。看discuss说数组开小了。为了验证的却是数组越界的错误，一下狠心数组开大了两个数量级。
这下不是RE了，是WA。还是PKU比HDU厚道一点，数组访问越界是报RE，不是WA。

我觉得我是完全看懂了题意，是跟着题意写的代码，而且一次过了样例，这说明思路没错啊。在这种情况下，是可以少测别的数据吧，最多就是测一下边界数组。而直觉告诉我，边界是没问题的。

我怀疑状态压缩出乱子了（没试过压缩的），就干脆不压了，每次RE后都加大数组，一直到MLE。然后编译选错，又来了几个CE。盼星星盼月亮就是盼不到一个AC。
上网查看别人的代码，发现思路跟我的好像不一样。而且都不像我那样，用到double型。我也去掉double类型，将获利先加到总金额，在除以1000赋值给整形。这下提交终于看到AC了。

虽然AC了，但还是有三个地方是不懂得。

1，为什么数组要开到46000呢。
假设将所有资金都能获得最大获利，那么40年后，就是：
1 000 000*(1.1^40)=45259255.568175951805889356034897
2,为什么我用double的时候会出错呢？
其实现在还是不懂，估计也就是有精度损失。
3，别人的思路为什么只求一次完全背包，就的了呢？
由于可以知道40年后的最大金额，不超过46000（压缩后），一次背包后，就能得出每一金额的最大获利。然后每一年获利后都加进去，直接提取出来就可以再次求获利。

 1#include <iostream>
 2#include <algorithm>
 3using namespace std;
 4const int MAX=46000;
 5int dp[MAX],w[12],v[12];
 6int fmax(int a,int b)
 7{return a>b?a:b;}
 8int main()
 9{
10    int t;
11    scanf("%d",&t);
12    while(t--)
13    {
14        int money,year,bond,i,j,sum;
15        scanf("%d%d%d",&money,&year,&bond);
16        for(i=1;i<=bond;++i)
17        {
18            scanf("%d%d",&w[i],&v[i]);
19            w[i]/=1000;
20        }
21
22        memset(dp,0,sizeof(dp));
23        for(i=1;i<=bond;++i)
24            for(j=w[i];j<=MAX-1;++j)
25                dp[j]=fmax(dp[j],dp[j-w[i]]+v[i]);
26
27        while(year--)
28        {
29            sum=money/1000;
30            money+=dp[sum];
31        }
32        printf("%d\n",money);
33    }
34    return 0;
35}

这个题目想了我很久，看着所有讨论都说是简单题，想死的心都有。
最后自己还是想不出来，看了人家的DP状态设计才写出来了。

刚开始，总是往一维DP（其实不算DP吧，都没有状态转移的，只是简单的递推而已）里想，
还想出了其他一些结论，只是还不至于能解出这个题，说白了就是，还是没想到。
以下的内容都是参考了网上已经摆放了N久的题解，加上了自己的理解而已。

假设dp[i][j]为：将i这一个数拆分为串里元素均不少于j的回文串的总个数。
对于这种状态设计的理解很重要，至少要理解里面的两个意思：
1，串里元素均不少于j，也就是这些回文串最外面的两个数至少为j。
2，当j=1时，dp[i][j]即表示，元素之和为i的回文串的总个数，因为元素至少都要为1。
 很明显，dp[i][1]包含了dp[i][2]，dp[i][2]又包含了dp[i][3]……。

然后对于dp[i][j]，再分两层理解来设计转移方程：
1，当最外面的两个元素为j的时候，这两个元素之间的其他元素之和就为i-2*j。
 dp[i-2*j][j]里的所有个数只要往两边加上j就变成了dp[i][j]的一部分解。
2，当最外面的两个元素大于j的时候，只要将dp[i][j]加上dp[i][j+1]即可。
 因为dp[i][j+1]包含了dp[i][j+2]。

所以DP方程可以设计为下：

dp[i][j]=dp[i][j+1]+dp[i-2*j][j];

然后是处理这个方程的边界条件。j<=i,当j==i的时候，dp[i][j]==1；

当i-2*j<0的时候，即代表i不能拆分，应直接加0
当i-2*j==0的时候，这时该这么理解，i可以拆分为最外两个元素为j，中间元素为0
即不存在中间元素，这时的回文串只有一个，即(j,j)。所以dp[0][j]应初始化为1

 1#include <iostream>
 2using namespace std;
 3__int64 dp[301][301];  //假设了数组最大的输入为300。
 4int main()
 5{
 6    int i,j;
 7    for(i=1;i<=300;++i)  //初始化，详细见上。
 8    {
 9        dp[0][i]=1;    
10        dp[i][i]=1;
11    }
12    for(i=2;i<=300;++i)
13        for(j=i-1;j>=1;--j)
14        {
15            dp[i][j]=dp[i][j+1]+(i>=2*j?dp[i-2*j][j]:0);
16            //如果不对i-2*j进行判断，会导致数组访问下溢
17        }
18    int n;
19    while(scanf("%d",&n)!=EOF&&n)
20    {
21        printf("%d %I64d\n",n,dp[n][1]);
22    }
23    return 0;
24}
25

看来看去，就剩下快排是可以省掉的，但无大碍。无奈上网找答案，看到一代码跟我的省掉快排后就几乎是一模一样了。这下百分百确定思路没错了，只能喊着命苦继续Debug。

最后居然发现是数组开小了。
思路：先初始化数组，然后在时间上从低往上，每个时间点都进行一次更新。
错误的就是，直接从时间上操作数组，更新时间也没有对每个时间点进行。

题意：每个人都有三个天赋，分别是体能，智商，情商。这三个天赋都有一个最高点。每个天赋的最高点都有出现的周期，分别是23,28,33天。假设三个天赋在某一年的第p,i,e三天分别出现了。问，从该年的第n天开始，还要经过多少天，这三个天赋会在同一天出现。

中国剩余定理（中国古代求解一次同余式组的方法）

引出：
公元前后的《孙子算经》中有“物不知数”问题：“今有物不知其数，三三数之余二 ，五五数之余三 ，七七数之余二，问物几何？”答为“23”

方法：
设总数n,三个除数分别为a,b,c，三个余数依次为p,i,e，即：
n%a==p;
n%b==i;
n%c==e;

令x满足x%b==0&&x%c==0&&x%a==1,y满足y%a==0,y%c==0,y%b==1,z满足z%a==0,z%b==0,z%c==1;

则n=x*p+y*i+z*e分别除以a,b,c，余数必分别为p,i,e.

当然n不一定是满足条件的最小数。通过将n对a*b*c求余即可得到满足条件的最小数。

当时对这个方法了解不清，半懂不懂得调试了很久。明白了这个定理以后，其实就水题一道。

这个题目要注意的地方是三个天赋一起出现的那一天可能出现在给出的日期前面。这样的话，只要将出现的那一天加上一个“大周期”即为第二次出现的天数。

得很。以致我一直没去碰这个题，虽然我早知道这是个水题。昨天去做

是因为那个贪心的题目想了很久也没思路，也快够钟熄灯睡觉了。所以

只能以一个水题完成任务。
看题肯定要借助有道词典，不然真的看不下去。看懂后发现果真是水题

。
题意如下：输入给出多个正整数，以0结束输入。对每个数，判断它是

perfect，还是abundant，deficient。
思路：找到每个数小于自身的所有因数，将他们相加，如果等于原来的

数，就是perfect，大于则是abundant，小于则是deficient。
注意的地方：“1”是deficient，因为是要小于自身的因数。（WA一次

）
 用试除法找因数，时间复杂度是O(N^1/2)。
 注意输出是设置宽度。

C的优势真的很明显。有空得研究一下C的语法。

PKU1861
在PKU1861里，循环下标从一开始，但我用了vector的push_back，sort，都没有注意这个问题，在试调花了不少时间，还导致了一个Validator Error，当然将相同代码再提交就WA了，不知道怎么回事。


暂结：
1.可以只用一个关系数组来作辅助
2.关系中的合并与查找可以写得不那么分明，毕竟也只有几个语句。当然分两个函数来写，思路都结构都会比较清晰。
3.判断两个对象所在集合不能直接用关系数组进行一次对比，即不能通过比较父亲，而是要循环到集合顶点，即祖先。
4.同样，合并两个对象，也要找到集合顶点。
5.并查集还有路径压缩的东西。

ps:在杭电找了几个说是并查集的题，看了两个，不会做。感觉有点难，看起来也不像并查集。还是先这样吧，校赛将近，还有别的要复习准备，不能一个算法吊死。