1. 机器分配模型
2. 船
3. 楼梯问题
4. 田忌赛马
5. 最长公共子串

然后就是有关矩形的动态规划。如下：

1. 滑雪
2. 工业时代

还有区间类的：

1. 凸多边形划分
2. 最大乘积
3. 石子合并（用到了四边形不等式）
4. 数字游戏

然后有三道测试题：

1. 四塔问题
2. 关灯
3. 任务安排

下午开始将树形的动态规划。

1. 聚会的快乐
2. 三色二叉树
3. 皇宫看守
4. 珠宝
5. 符文之旅（最大与最小）

没有写的题目以后会逐步完成。

一棵二叉树可以按照如下规则表示成一个由0、1、2 组成的字符序列，我们称之为“二叉树序列S”：

2表示该树有两个子节点， 和分别表示其两个子树的二叉树序列

1表示该树有一个子节点， 为其子树的二叉树序列

0表示该树没有子节点

你的任务是要对一棵二叉树的节点进行染色。每个节点可以被染成红色、绿色或蓝色。并且，一个节点与其子节点的颜色必须不同，如果该节点有两个子节点，那么这两个子节点的颜色也必须不相同。给定一棵二叉树的二叉树序列，请求出这棵树中最多和最少有多少个点能够被染成绿色。

【输入文件】

输入文件名：TRO.IN

输入文件仅有一行，不超过10000 个字符，表示一个二叉树序列。

【输出文件】

输出文件名：TRO.OUT

输出文件也只有一行，包含两个数，依次表示最多和最少有多少个点能够被

染成绿色。

【样例输入】

1122002010

【样例输出】

5 2

【分析】

1.动归分析

拿最大来说。

每个节点的状态只有三种颜色，我们用f[i][0],f[i][1]分别代表第i个点染绿色和不然绿色的最多的点数。因为如果一个点不染绿色，那么他染另两种颜色是等价的。如此我们就得到了如下的动规方程：

• 叶子：f[i][0]=1; f[i][1]=0;
• 一个子节点：f[i][0]=f[子节点][1]; f[i][1]=max(f[子节点][0],f[子节点][1]);
• 两个子节点：f[i][0]=f[左儿子][1]+f[右儿子][1]; f[i][1]=max(f[左儿子][1]+f[右儿子][0],f[左儿子][0]+f[右儿子][1]);

最后输出就是max(f[0][1],f[0][0])。

最小的和最大的相同。

2.树的确定

因为是一棵二叉树的前序遍历，那么对于一个有子节点的点来说，左儿子就是i+1。我们引进一个link[i]，表示以i为根的子树最后一个点的标号，那么r[i]=link[l[i]]+1。

对于link[l]，我们如此确定：

• 叶子：link[l]=l;
• 一个子节点：link[l]=link[l+1];
• 两个子节点：link[l]=link[link[l+1]+1];

然后就是实现了。因为自己弄得还是不是很熟，打了两节课。

  1: #include <stdio.h>
  2: #include <string.h>
  3: #include <iostream>
  4: #define maxn 10010
  5: #define MAXINT 10000000
  6: using namespace std;
  7: 
  8: char s[maxn];
  9: int f[maxn][2];
 10: int link[maxn];
 11: int n;
 12: int l[maxn],r[maxn];
 13: 
 14: int _find(int x)
 15: {
 16:     if (link[x]) return link[x];
 17:     if (s[x]=='0') link[x]=x;
 18:     else
 19:         if (s[x]=='1') link[x]=_find(x+1);
 20:         else
 21:             link[x]=_find(_find(x+1)+1);
 22:     return link[x];
 23: }
 24: 
 25: void find1(int x)
 26: {
 27:     if (f[x][0]) return;
 28:     if (s[x]=='0')
 29:     {
 30:         f[x][0]=1;
 31:         f[x][1]=0;
 32:     }
 33:     else
 34:         if (s[x]=='1')
 35:         {
 36:             find1(l[x]);
 37:             f[x][0]=f[l[x]][1]+1;
 38:             f[x][1]=max(f[l[x]][1],f[l[x]][0]);
 39:         }
 40:         else
 41:         {
 42:             find1(l[x]);
 43:             find1(r[x]);
 44:             f[x][0]=f[l[x]][1]+f[r[x]][1]+1;
 45:             f[x][1]=max(f[l[x]][1]+f[r[x]][0],f[l[x]][0]+f[r[x]][1]);
 46:         }
 47: }
 48: 
 49: void find2(int x)
 50: {
 51:     if (f[x][0]<MAXINT) return;
 52:     if (s[x]=='0')
 53:     {
 54:         f[x][0]=1;
 55:         f[x][1]=0;
 56:     }
 57:     else
 58:         if (s[x]=='1')
 59:         {
 60:             find2(l[x]);
 61:             f[x][0]=f[l[x]][1]+1;
 62:             f[x][1]=min(f[l[x]][1],f[l[x]][0]);
 63:         }
 64:         else
 65:         {
 66:             find2(l[x]);
 67:             find2(r[x]);
 68:             f[x][0]=f[l[x]][1]+f[r[x]][1]+1;
 69:             f[x][1]=min(f[l[x]][1]+f[r[x]][0],f[l[x]][0]+f[r[x]][1]);
 70:         }
 71: }
 72: 
 73: int main()
 74: {
 75:     freopen("tro.in","r",stdin);
 76:     freopen("tro.out","w",stdout);
 77:     
 78:     scanf("%s",s);
 79:     n=strlen(s);
 80:     _find(0);
 81:     for (int i=0;i<n;++i)
 82:     {
 83:         l[i]=i+1;
 84:         r[i]=link[l[i]]+1;
 85:     }
 86:     find1(0);
 87:     printf("%d ",max(f[0][0],f[0][1]));
 88:     for (int i=0;i<n;++i)
 89:         f[i][0]=f[i][1]=MAXINT;
 90:     find2(0);
 91:     printf("%d\n",min(f[0][0],f[0][1]));
 92:     return 0;
 93: }
 94: 

注意初始化s[i][j]的时候要加上100000而不是10！！！我傻叉子了= =

  1: #include <stdio.h>
  2: #define MAXINT 10000000
  3: #define maxn 200
  4: 
  5: int f[maxn][maxn][maxn][2];//0 max|||| 1 min
  6: int s[maxn][maxn];
  7: int a[maxn];
  8: int n,m;
  9: int maxans,minans=MAXINT;
 10: 
 11: void find(int x,int y,int t)
 12: {
 13:     if (f[x][y][t][0]) return;
 14:     if (t==1)
 15:     {
 16:         f[x][y][1][0]=f[x][y][1][1]=s[x][y];
 17:         return;
 18:     }
 19:     for (int k=x+t-1-1;k<y;++k)
 20:     {
 21:         find(x,k,t-1);
 22:         if (f[x][k][t-1][1]*s[k+1][y]<f[x][y][t][1]) f[x][y][t][1]=f[x][k][t-1][1]*s[k+1][y];
 23:         if (f[x][k][t-1][0]*s[k+1][y]>f[x][y][t][0]) f[x][y][t][0]=f[x][k][t-1][0]*s[k+1][y];
 24:     }
 25: }
 26: 
 27: int main()
 28: {
 29:     freopen("game.in","r",stdin);
 30:     freopen("game.out","w",stdout);
 31:     
 32:     scanf("%d%d",&n,&m);
 33:     for (int i=1;i<=n;++i)
 34:     {
 35:         scanf("%d",&a[i]);
 36:         a[i+n]=a[i];
 37:     }
 38:     for (int i=1;i<=2*n;++i)
 39:         for (int j=i;j<=2*n;++j)
 40:             for (int k=1;k<=m;++k)
 41:                 f[i][j][k][1]=MAXINT;
 42:     for (int i=1;i<=2*n;++i)
 43:         for (int j=i;j<=2*n;++j)
 44:             s[i][j]=(s[i][j-1]+a[j]+100000)%10;
 45:     for (int i=1;i<=n;++i) find(i,i+n-1,m);
 46:     for (int i=1;i<=n;++i)
 47:     {
 48:         if (f[i][i+n-1][m][0]>maxans) maxans=f[i][i+n-1][m][0];
 49:         if (f[i][i+n-1][m][1]<minans) minans=f[i][i+n-1][m][1];
 50:     }
 51:     printf("%d\n%d\n",minans,maxans);
 52:     return 0;
 53: }
 54: 

寻找一个由n个整数组成的数列，其中任意连续p个整数之和为正，任意连续q个整数之和为负。若不存在这样的整数数列，则输出NO，否则输出其中一个数列。

【输入】

对于每个测试点将给你M组数据，要求你对于每组数据，判断是否存在这样的整数数列。

输入的第一行是一个正整数M，（1<=N<=10000）,接下来的M行对应M组数据，每行有三个正整数N、P、Q（1<=n,p,q<=10^8）。

【输出】

输出数据共N行，每行为yes或者no，如果第I组数据有解，则在第I行输出yes，否则输出no

【输入输出示例】

【评分标准】

对于每个测试点，如果你能够在1S内通过每组数据，你将得到这个测试点的分数，否则，这个测试点你只能得0分。

【分析】

原题目是要求输出一种可能的解，如果没有解就输出-1。这样的话就要用到差分约束。

现在的话，只需要一个公式。如果有解，应满足：n<=q+p-gcd(p,q)-1。

  1: #include <stdio.h>
  2: #include <iostream>
  3: using namespace std;
  4: 
  5: int n,m,p,q;
  6: 
  7: int gcd(int a,int b)
  8: {
  9:     if (a<b) swap(a,b);
 10:     int t;
 11:     while (b!=0)
 12:     {
 13:         t=a;
 14:         a=b;
 15:         b=t%a;
 16:     }
 17:     return a;
 18: }
 19: 
 20: int main()
 21: {
 22:     freopen("sequence.in","r",stdin);
 23:     freopen("sequence.out","w",stdout);
 24:     
 25:     scanf("%d",&m);
 26:     for (int i=0;i<m;++i)
 27:     {
 28:         scanf("%d%d%d",&n,&p,&q);
 29:         if (n<=p+q+gcd(p,q)-1) printf("YES\n");
 30:         else printf("NO\n");
 31:     }
 32:     return 0;
 33: }
 34: 

下面是我写的查分约束。

  1: #include <stdio.h>
  2: #define MAXINT 1000000
  3: #define maxn 1010
  4: 
  5: struct ss
  6: {
  7:     int x,y,dis;
  8: } l[10000];
  9: 
 10: int s[maxn];
 11: int a[maxn];
 12: int d[maxn];
 13: int n,q,p,tot;
 14: 
 15: int main()
 16: {
 17:     scanf("%d%d%d",&n,&p,&q);
 18:     for (int i=0;i<=n;++i)
 19:         if (i+p>n) break;
 20:         else
 21:         {
 22:             l[++tot].x=i+p;
 23:             l[tot].y=i;
 24:             l[tot].dis=-1;
 25:         }
 26:     for (int i=0;i<=n;++i)
 27:         if (i+q>n) break;
 28:         else
 29:         {
 30:             l[++tot].x=i;
 31:             l[tot].y=i+q;
 32:             l[tot].dis=-1;
 33:         }
 34:     for (int i=1;i<=n;++i)
 35:     {
 36:         for (int j=1;j<=tot;++j)
 37:             if (d[l[j].y]>d[l[j].x]+l[j].dis)
 38:                 d[l[j].y]=d[l[j].x]+l[j].dis;
 39:         for (int j=1;j<=tot;++j)
 40:             if (d[l[j].y]>d[l[j].x]+l[j].dis)
 41:             {
 42:                 printf("-1\n");
 43:                 return 0;
 44:             }
 45:     }
 46:     for (int i=0;i<=n;++i)
 47:         s[i]=d[i];
 48:     for (int i=1;i<=n;++i) printf("%d\n",s[i]-s[i-1]);
 49:     return 0;
 50: }
 51: 

下午两点多的时候曹老师开始讲课。

今天的课程是两个内容：全面分析试题，动态规划。

曹老师拿他给自己的学生布置的任务做例子，大概的说了一下从一个题目的模型到完整的题目的过程。首先曹老师给了4道题目，都只是大概的描述。然后将每个条件定严谨。确定输入输出的格式。分析可以用什么算法，每种算法的时间复杂度以及可以通过的数据范围。根据算法定出数据，写出标程。曹老师说他们的学生每个人通过自己的分析，做出10个数据，然后大概100多个测试点来测试每个人写的程序。

以下是4道题目。第二题有些瓶颈，一会再发。

1. 动态规划-走迷宫问题
2. 空缺
3. 贪心-买彩票
4. 数学问题-Black and White

寻找一个由n个整数组成的数列，其中任意连续p个整数之和为正，任意连续q个整数之和为负。若不存在这样的整数数列，则输出NO，否则输出其中一个数列。

【输入】

对于每个测试点将给你M组数据，要求你对于每组数据，判断是否存在这样的整数数列。

输入的第一行是一个正整数M，（1<=N<=10000）,接下来的M行对应M组数据，每行有三个正整数N、P、Q（1<=n,p,q<=10^8）。

【输出】

输出数据共N行，每行为yes或者no，如果第I组数据有解，则在第I行输出yes，否则输出no

【输入输出示例】

【评分标准】

对于每个测试点，如果你能够在1S内通过每组数据，你将得到这个测试点的分数，否则，这个测试点你只能得0分。

【分析】

原题目是要求输出一种可能的解，如果没有解就输出-1。这样的话就要用到差分约束。

现在的话，只需要一个公式。如果有解，应满足：n<=q+p+gcd(p,q)-1。

  1: #include <stdio.h>
  2: #include <iostream>
  3: using namespace std;
  4: 
  5: int n,m,p,q;
  6: 
  7: int gcd(int a,int b)
  8: {
  9:     if (a<b) swap(a,b);
 10:     int t;
 11:     while (b!=0)
 12:     {
 13:         t=a;
 14:         a=b;
 15:         b=t%a;
 16:     }
 17:     return a;
 18: }
 19: 
 20: int main()
 21: {
 22:     freopen("sequence.in","r",stdin);
 23:     freopen("sequence.out","w",stdout);
 24:     
 25:     scanf("%d",&m);
 26:     for (int i=0;i<m;++i)
 27:     {
 28:         scanf("%d%d%d",&n,&p,&q);
 29:         if (n<=p+q+gcd(p,q)-1) printf("YES\n");
 30:         else printf("NO\n");
 31:     }
 32:     return 0;
 33: }
 34: 

电视里面正放着“抽百万大奖，赢幸福生活”的宣传广告，bird看后也想去试试手气，当然，作为经济学院的高材生，他可不屑只是单纯的去碰运气。经过他的一番分析，发现，商家在彩票里面做了手脚，使得每个抽奖点的中奖概率不是完全一样的，而且随着时间的变化而变化，不过这种变化是有规律的。对于第I个抽奖点，最开始的中奖概率是百万分之Pi，以后每抽一张彩票后都要重新排队，花费的时间是T分钟，每抽一次减少的概率为Di。

由于可怜的bird还有一大堆的作业没做，他只能抽出H个小时去买彩票。由于抽奖地点都在一路公共汽车的线路上，所以怕麻烦的bird决定按车站顺序抽奖，当然，bird可以从任意一站开始抽奖，对于经过的抽奖点可以买彩票，也可以不买。假设从第I个抽奖点到第I+1个抽奖点需要做Ci分钟的汽车。

Bird希望能在有限的H个小时内获得最好的运气——即抽奖的概率和最大。

[输入] 输入文件名：(tickt.in)

第一行为一个整数n，表示抽奖点的个数，1<=n<=200

第二行是两个整数H和T，1<=H<=10，1<=T<=60。

接下来的n行，每行3个整数，分别是Pi，Di，Ci（Cn=0）。1<=Pi<=10000，Di<=Pi，1<=Ci<=600。

[输出] 输出文件名：(tickt.out)

文件仅有一行，为一个整数，即抽奖概率和的最大值。

【输入输出样例】

【样例说明】

首先，bird从1号开始抽奖，花费20分钟，得到概率200，然后坐车到2号，花费10分钟，再花20分钟得到概率300，概率和是500，花费50分钟。

【评分标准】

对于每个测试点，如果你能够在规定的时间内通过每组数据，你将得到这个测试点的分数，否则，这个测试点你只能得0分。

【分析】

由CEOI的钓鱼改编，具体可以看《算法艺术与信息学竞赛》P13。

  1: #include <stdio.h>
  2: #include <iostream>
  3: #define maxn 210
  4: using namespace std;
  5: 
  6: int b[maxn][maxn];
  7: int p[maxn],d[maxn],c[maxn];
  8: int h,t,tot;
  9: struct ss
 10: {
 11:     int pi,di;
 12: } hp[maxn];
 13: int remain,ans,teans,n;
 14: 
 15: void down(int x)
 16: {
 17:     int te=2*x;
 18:     while (te<=tot)
 19:     {
 20:         if ((te+1<=tot)&&(hp[te].pi<hp[te+1].pi)) ++te;
 21:         if (hp[x].pi>hp[te].pi) break;
 22:         swap(hp[x],hp[te]);
 23:         x=te;
 24:         te=x*2;
 25:     }
 26: }
 27: 
 28: int main()
 29: {
 30:     freopen("ticket.in","r",stdin);
 31:     freopen("ticket.out","w",stdout);
 32:     
 33:     scanf("%d%d%d",&n,&h,&t);
 34:     h*=60;
 35:     for (int i=1;i<=n;++i) scanf("%d%d%d",&p[i],&d[i],&c[i]);
 36:     for (int i=1;i<=n;++i)
 37:         for (int j=i+1;j<=n;++j)
 38:             b[i][j]=b[i][j-1]+c[j-1];
 39:     for (int i=1;i<=n;++i)
 40:         for (int j=n;j>=i;--j)
 41:         {
 42:             teans=0;
 43:             remain=h-b[i][j];
 44:             memset(hp,0,sizeof(hp));
 45:             for (int k=1;k<=j-i+1;++k)
 46:             {
 47:                 hp[k].pi=p[i+k-1];
 48:                 hp[k].di=d[i+k-1];
 49:             }
 50:             tot=j-i+1;
 51:             for (int k=j-i+1;k>=1;--k) down(k);
 52:             while ((remain>=t)&&(hp[1].pi>0))
 53:             {
 54:                 teans+=hp[1].pi;
 55:                 hp[1].pi-=hp[1].di;
 56:                 remain-=t;
 57:                 down(1);
 58:             }
 59:             if (teans>ans) ans=teans;
 60:         }
 61:     printf("%d\n",ans);
 62:     return 0;
 63: }
 64: 

[题目描述]

有一个n*n的迷宫，每个方格里都有着相应的数字。你从左上角出发，每次可以向上下左右四个方向最多移动k格，并且要求你每次到达的方格里的数字必须大于上一次所在方格的数字。现在要求你走过的方格的所有数之和最大，问这个最大和是多少。

[输入]

输入数据第一行为两个正整数N、K（1<=N<=100,0<=K<=N）

接下来的n行，每行有n个不超过integer范围的整数，表示地图中的数。

[输出]

输出数据只有一行，为最大的和。

[输入输出示例]

输入(maze.in) 输出(maze.out)

3 1 25

3 6 2

4 7 9

2 3 1

[评分标准]

对于每个测试数据，如果你能够得出正确的答案，那么你将得到满分，否则得0分。

[分析]

很明显的动态规划，应该是从《滑雪》那道题改编而来的。

  1: #include <stdio.h>
  2: #define maxn 110
  3: 
  4: int a[maxn][maxn];
  5: int f[maxn][maxn];
  6: int n,ans,k;
  7: int xx[4]={0,0,1,-1};
  8: int yy[4]={1,-1,0,0};
  9: 
 10: int find(int x,int y)
 11: {
 12:     if (f[x][y]) return f[x][y];
 13:     int temx,temy;
 14:     for (int i=0;i<4;++i)
 15:         for (int j=1;j<=k;++j)
 16:         {
 17:             temx=x+xx[i]*j;
 18:             temy=y+yy[i]*j;
 19:             if ((temx>0)&&(temx<=n)&&(temy>0)&&(temy<=n))
 20:                 if ((a[temx][temy]>a[x][y])&&(find(temx,temy)>f[x][y]))
 21:                     f[x][y]=find(temx,temy);
 22:         }
 23:     f[x][y]+=a[x][y];
 24:     return f[x][y];
 25: }
 26: 
 27: int main()
 28: {
 29:     freopen("maze.in","r",stdin);
 30:     freopen("maze.out","w",stdout);
 31:     
 32:     scanf("%d%d",&n,&k);
 33:     for (int i=1;i<=n;++i)
 34:         for (int j=1;j<=n;++j)
 35:             scanf("%d",&a[i][j]);
 36:     printf("%d\n",find(1,1));
 37:     return 0;
 38: }
 39: 

从今天开始进入为期5天的“长沙一中学习”专题活动~

也许这几天用不了writer了，因为安装的时候ms要重新启动。西区的电脑有还原卡的。

To be continued.

【问题描述】

做过了乘积最大这道题，相信这道题也难不倒你。

已知一个数串，可以在适当的位置加入乘号（设加了k个，当然也可不加，即分成k+1个部分），设这k+1个部分的乘积（如果k=0,则乘积即为原数串的值）对m 的余数（即mod m）为x;

现求x能达到的最小值及该情况下k的最小值，以及x能达到的最大值及该情况下的k的最小值（可以存在x的最小值与最大值相同的情况）。

【输入】

第一行为数串，长度为n 满足2<=n<=1000，且数串中不存在0；

第二行为m，满足2<=m<=50。

【输出】

四个数，分别为x的最小值 和 该情况下的k，以及x的最大值和 该情况下的k，中间用空格隔开。

【样例输入】

4421

22

【样例输出】

0 1 21 0

既然题目要求的都是乘号的最小值，那么我们自然地就会想到动归数组中记录乘号的最小值。f[i][j]表示0~i的串达到j这个余数所需最少的乘号数。预处理b[i][j]表示从i到j的数对m的余数。

  1: #include <stdio.h>
  2: #include <string.h>
  3: #define MAXINT 100000
  4: #define maxn 1010
  5: 
  6: int f[maxn][50];
  7: int b[maxn][maxn];
  8: int n,m;
  9: char s[maxn];
 10: int tem;
 11: 
 12: int main()
 13: {
 14:     freopen("input.txt","r",stdin);
 15:     freopen("output.txt","w",stdout);
 16:     
 17:     scanf("%s%d",s,&m);
 18:     n=strlen(s);
 19:     for (int i=0;i<n;++i)
 20:         for (int j=0;j<m;++j)
 21:             f[i][j]=MAXINT;
 22:     for (int i=0;i<n;++i)
 23:     {
 24:         tem=(tem*10+s[i]-'0')%m;
 25:         f[i][tem]=0;
 26:     }
 27:     for (int i=0;i<n;++i)
 28:     {
 29:         tem=0;
 30:         for (int j=i;j<n;++j)
 31:         {
 32:             tem=(tem*10+s[j]-'0')%m;
 33:             b[i][j]=tem;
 34:         }
 35:     }
 36:     for (int i=0;i<n;++i)
 37:         for (int j=0;j<m;++j)
 38:             if (f[i][j]<MAXINT)
 39:                 for (int k=i+1;k<n;++k)
 40:                 {
 41:                     tem=(j*b[i+1][k])%m;
 42:                     if (f[i][j]+1<f[k][tem]) f[k][tem]=f[i][j]+1;
 43:                 }
 44:     for (int i=0;i<m;++i)
 45:         if (f[n-1][i]<MAXINT)
 46:         {
 47:             printf("%d %d ",i,f[n-1][i]);
 48:             break;
 49:         }
 50:     for (int i=m-1;i>=0;--i)
 51:         if (f[n-1][i]<MAXINT)
 52:         {
 53:             printf("%d %d\n",i,f[n-1][i]);
 54:             break;
 55:         }
 56:     return 0;
 57: }
 58: 

【问题描述】

n个人在做传递物品的游戏,编号为1-n。

游戏规则是这样的：开始时物品可以在任意一人手上，他可把物品传递给其他人中的任意一位；下一个人可以传递给未接过物品的任意一人。

即物品只能经过同一个人一次，而且每次传递过程都有一个代价；不同的人传给不同的人的代价值之间没有联系；

求当物品经过所有n个人后，整个过程的总代价是多少。

【输入】

第一行为n,表示共有n个人（16>=n>=2）；

以下为n*n的矩阵，第i+1行、第j列表示物品从编号为i的人传递到编号为j的人所花费的代价，特别的有第i+1行、第i列为-1（因为物品不能自己传给自己），其他数据均为正整数(<=10000)。

(对于50%的数据，n<=11)。

【输出】

一个数，为最小的代价总和。

【样例输入】

2

-1 9794

2724 –1

【样例输出】

2724

时间到了啊~ 明天再继续写。

是一个用二进制来表示图的状态的动态规划，或者说是记忆化搜索。f[i][j]中，i来表示图的二进制状态，j表示这个状态中第一个点。

  1: #include <stdio.h>
  2: #include <iostream>
  3: #define maxn 20
  4: #define MAXINT 1000000
  5: using namespace std;
  6: 
  7: int dis[maxn][maxn];
  8: int n;
  9: int f[70000][20];
 10: int ans=MAXINT;
 11: 
 12: int find(int a,int b)
 13: {
 14:     if (f[a][b]!=MAXINT) return f[a][b];
 15:     int tem=a;
 16:     a-=(1<<b);
 17:     if (!a)
 18:     {
 19:         f[tem][b]=0;
 20:         return 0;
 21:     }
 22:     for (int i=0;i<n;++i)
 23:         if ((1<<i)&a)
 24:             f[tem][b]=min(find(a,i)+dis[b][i],f[tem][b]);
 25:     return f[tem][b];
 26: }
 27: 
 28: int main()
 29: {
 30:     freopen("input.txt","r",stdin);
 31:     freopen("output.txt","w",stdout);
 32:     
 33:     scanf("%d",&n);
 34:     for (int i=0;i<n;++i)
 35:         for (int j=0;j<n;++j)
 36:             scanf("%d",&dis[i][j]);
 37:     for (int i=0;i<(1<<n);++i)
 38:         for (int j=0;j<n;++j)
 39:             f[i][j]=MAXINT;
 40:     for (int i=0;i<n;++i)
 41:         if (find((1<<n)-1,i)<ans)
 42:             ans=find((1<<n)-1,i);
 43:     printf("%d\n",ans);
 44:     return 0;
 45: }
 46: 

【问题描述】

天苍苍，野茫茫，JSZX的菜鸟们来到OI牧场旅游，看到了好多好多的牛。OI牧场所有的牛都觉得自己的Rp最高（简称RP牛），为此他们常争论不休。于是，他们让JSZX的菜菜们用最最朴素的方法找出这只RP牛。

经过讨论，最菜的mmk想出了最朴素的方法：

我们要以cows的名字为线索，来找出RP牛。

首先，得到n头牛的名字清单（每头牛的名字是一个仅包含小写字母的字符串，且这些牛的读写方式比较特殊—从右到左），然后对每头牛进行检验，检验按照牛的读写方式进行。规则如下：

1．Rp 牛的名字中必须有子串“jszxoier”

2．将名字中的每个“cow”的替换为“bird”。

3．计算Rp值：A为名字中子串“r”的个数；

B为名字中子串“p”的个数；

C为名字中字串“rp”的个数；

Rp值即为5×A+5×B+20×C。

最后输出RP牛的名字，若有多个RP牛，则输出名字最短的那个。

假如你也是牛中一员，尽管你很不屑这样的水题，但是，你很想到RP牛那里分点Rp，所以你决定解决这道题，并算出RP牛的Rp是多少。

【输入】

第一行，一个数n（n<=3000）。

接下来的n行，每行一个字符串，长度<=300，数据保证存在RP牛。

【输出】

共两行

第一行为RP牛的名字

第二行为RP牛的Rp值

【样例输入】

8

reioxzsjzmy

mmk

jwc

zxf

jwc

wangwei

xcy

yuhc

【样例输出】

reioxzsjzmy

5

我用KMP匹配的，代码挺短，还比string.h的好用。

  1: #include <stdio.h>
  2: #include <string.h>
  3: #include <iostream>
  4: #define maxn 400
  5: using namespace std;
  6: 
  7: int f[maxn];
  8: char *aa="jszxoier",*bb="cow",*ee="rp",s[maxn];
  9: int a,b,c,tem,ans,anslen,len,m;
 10: int n;
 11: bool t;
 12: char anss[400];
 13: 
 14: void initf(char *s)
 15: {
 16:     memset(f,0,sizeof(f));
 17:     m=strlen(s);
 18:     int k=-1;
 19:     f[0]=-1;
 20:     for (int i=1;i<m;++i)
 21:     {
 22:         while ((k>-1)&&(s[k+1]!=s[i])) k=f[k];
 23:         if (s[k+1]==s[i]) ++k;
 24:         f[i]=k;
 25:     }
 26: }
 27: 
 28: void changef(char *s)
 29: {
 30:     initf(s);
 31:     int k;
 32:     for (int i=0;i<m;++i)
 33:     {
 34:         k=f[i];
 35:         while ((k>-1)&&(s[k+1]==s[i+1])) k=f[k];
 36:         f[i]=k;
 37:     }
 38: }
 39: 
 40: int main()
 41: {
 42:     freopen("input.txt","r",stdin);
 43:     freopen("output.txt","w",stdout);
 44:     
 45:     scanf("%d",&n);
 46:     for (int dt=1;dt<=n;++dt)
 47:     {
 48:         memset(s,0,sizeof(s));
 49:         scanf("%s",s);
 50:         strrev(s);
 51:         changef(aa);
 52:         len=strlen(s);
 53:         int k=-1;
 54:         t=0;
 55:         for (int i=0;i<len;++i)
 56:         {
 57:             while ((k>-1)&&(aa[k+1]!=s[i])) k=f[k];
 58:             if (aa[k+1]==s[i]) ++k;
 59:             if (k==m-1)
 60:             {
 61:                 t=1;
 62:                 break;
 63:             }
 64:         }
 65:         if (!t) continue;
 66:         a=b=c=0;
 67:         changef(bb);
 68:         for (int i=0;i<len;++i)
 69:         {
 70:             while ((k>-1)&&(bb[k+1]!=s[i])) k=f[k];
 71:             if (bb[k+1]==s[i]) ++k;
 72:             if (k==m-1) ++a;
 73:         }
 74:         for (int i=0;i<len;++i)
 75:             if (s[i]=='r') ++a;
 76:         for (int i=0;i<len;++i)
 77:             if (s[i]=='p') ++b;
 78:         changef(ee);
 79:         for (int i=0;i<len;++i)
 80:         {
 81:             while ((k>-1)&&(ee[k+1]!=s[i])) k=f[k];
 82:             if (ee[k+1]==s[i]) ++k;
 83:             if (k==m-1) ++c;
 84:         }
 85:         tem=a*5+b*5+c*20;
 86:         if (tem>ans)
 87:         {
 88:             memset(anss,0,sizeof(anss));
 89:             strcat(anss,s);
 90:             ans=tem;
 91:             anslen=len;
 92:         }
 93:         else
 94:             if (tem==ans)
 95:                 if (len<anslen)
 96:                 {
 97:                     memset(anss,0,sizeof(anss));
 98:                     strcat(anss,s);
 99:                 }
100:     }
101:     strrev(anss);
102:     printf("%s\n%d\n",anss,ans);
103:     return 0;
104: }
105: 

用到了分类的思想。对于f[i][j]代表i分为j份。我们分为以下两类：

1. 每份都没有1：那么我们只需要将每份都减1然后保证有j份。即加上f[i-j][j]。
2. 至少有一份1：那么我们提出1个1,即加上f[i-1][j-1]。

  1: #include <stdio.h>
  2: #define maxn 300
  3: 
  4: int f[maxn][maxn];
  5: int n,m;
  6: 
  7: int main()
  8: {
  9:     scanf("%d%d",&n,&m);
 10:     f[0][0]=1;
 11:     for (int i=1;i<=n;++i)
 12:         for (int j=1;j<=m;++j)
 13:             if (i-j>=0)
 14:                 f[i][j]=f[i-j][j]+f[i-1][j-1];
 15:     printf("%d\n",f[n][m]);
 16:     return 0;
 17: }
 18: 

  1: #include <stdio.h>
  2: #define maxn 100
  3: 
  4: unsigned long long f[maxn];
  5: int n,m;
  6: 
  7: int main()
  8: {
  9:     f[0]=1;
 10:     scanf("%d%d",&n,&m);
 11:     for (int i=1;i<=n;++i)
 12:     {
 13:         f[i]=f[i-1]*2;
 14:         if (i-m-1>=0) f[i]-=f[i-m-1];
 15:         if (i-m-1==-1) f[i]-=1;
 16:     }
 17:     printf("%I64d\n",f[n]);
 18:     return 0;
 19: }
 20: 

1. 树形依赖背包——百度NOIP吧编程挑战赛"charge"
2. 核电站问题-递推动态规划
3. 数的划分-递推动态规划
4. 动态规划-走迷宫问题
5. 区间类动态规划-数字游戏
6. 树形动态规划-三色二叉树

2.贪心

1. 贪心-买彩票

3.数学问题

1. 数学问题-Black and White

  1: #include <stdio.h>
  2: #include <stdlib.h>
  3: #define maxn 400
  4: 
  5: int f[maxn][maxn];
  6: int t[maxn];
  7: struct ss
  8: {
  9:     int root,num;
 10: } a[maxn];
 11: int n,m;
 12: int w[maxn];
 13: 
 14: int cmp(const void*a,const void*b)
 15: {
 16:     ss c=*(ss*)a,d=*(ss*)b;
 17:     if (c.root<d.root) return -1;
 18:     if (c.root>d.root) return 1;
 19:     return 0;
 20: }
 21: 
 22: void dp(int x)
 23: {
 24:     for (int i=t[x];i<t[x+1];++i)
 25:     {
 26:         int k=a[i].num;
 27:         for (int j=0;j<=m;++j) f[k][j]=f[x][j]+w[k];
 28:         dp(k);
 29:         for (int j=1;j<=m;++j)
 30:             if (f[k][j-1]>f[x][j])
 31:                 f[x][j]=f[k][j-1];
 32:     }
 33: }
 34: 
 35: int main()
 36: {
 37:     scanf("%d%d",&n,&m);
 38:     for (int i=1;i<=n;++i)
 39:     {
 40:         scanf("%d%d",&a[i].root,&w[i]);
 41:         a[i].num=i;
 42:     }
 43:     a[0].root=-1;
 44:     qsort(a,n+1,sizeof(ss),cmp);
 45:     for (int i=1;i<=n;++i)
 46:         if (!t[a[i].root])
 47:             t[a[i].root]=i;
 48:     t[n+1]=n+1;
 49:     for (int i=n;i>=0;--i)
 50:         if (!t[i])
 51:             t[i]=t[i+1];
 52:     dp(0);
 53:     printf("%d\n",f[0][m]);
 54:     return 0;
 55: }
 56: 

相关内容见“【传送门】百度NOIP吧编程挑战赛相关帖子”

第三题是一道有依赖的背包问题。今天dev问到了，于是又回忆了一下。徐持衡大牛的集训队论文中关于泛化物品的并还是不太懂。但是对这种背包有点了自己的感悟。

这道题目对我来说有两个启发点：

1. 对多儿子的处理，用的是nlogn的预处理。
2. 树形的背包。

1.多儿子的处理

用结构体记录关系，a[i].root是第i个关系的父节点，a[i].num是第i个关系的子节点。将数组按root排序。然后用t[i]记录i这个点的儿子在a中的起始位置。

  1: struct ss
  2: {
  3:     int root,num;
  4: } a[maxn];
  5: int t[maxn];
  6: 
  7: void init()
  8: {
  9:     qsort(a,n,sizeof(ss),cmp);
 10:     for (int i=1;i<=n;++i)
 11:         if (!t[a[i].root])
 12:             t[a[i].root]=i;
 13:     t[n+1]=n+1;
 14:     for (int i=n;i>0;--i)
 15:         if (!t[i])
 16:             t[i]=t[i+1];
 17: }
 18: 

这样第i个点的子节点在a中的位置就是从t[i]到t[i+1]-1。

免去了链表的繁琐，效率还相当高。

2.树形的背包

主要思想就是对于i的节点s，f[s]强制赋值为f[i]，然后强制加入w[s],对s进行处理，再更新f[i]。

  1: void dp(int x)
  2: {
  3:     for (int i=t[x];i<t[x+1];++i)
  4:     {
  5:         int k=a[i].num;
  6:         for (int j=0;j<=V;++j) f[k][j]=f[x][j]+w[k];
  7:         dp(k);
  8:         for (int j=v[k];j<=V;++j)
  9:             if (f[k][j-v[k]]>f[x][j])
 10:                 f[x][j]=f[k][j-v[k]];
 11:     }
 12: }

3.一些习题

1. CTSC98-选课