过了一段时间，人们发现磁的强度是可以预测的，因为一段长时间的平静期和一段短时间的高峰期（被称为磁暴）交替出现。因此幼儿园对机器作出了更新。

新机器将会存储过去几个小时里面磁的强度，以及显示出那段时间里的最高强度。如果在过去的6小时内，强度都较低，则这段时间为平静期，小朋友可以到户外玩耍，否则将可能出现新的高峰期，小朋友也要待在房子里。

你的任务是编写新机器的主程序

已知 M （新机器每秒钟都要输出过去 M 秒内磁的强度的最大值）和每秒测得的磁的强度（范围在0至100000之间）。

输出新机器要显示的一个数列。第一个数字表示输入数据的第1～第M个数的最大值，第二个数字表示输入数据的第2～第M+1个数的最大值，......最后一个数字表示输入数据的最后M个数的最大值。

input：
第一行为M, 1 < M <= 14000。
以下为表示每秒测得的磁的强度的数列，一行一个，不超过25000个，以-1结束。

output：
输出新机器要显示的一个数列，一行一个数字。

input：
3
10
11
10
0
0
0
1
2
3
2
-1

output：
11
11
10
0
1
2
3
3

分析：
       我用的是线段树：以每个数与它前面个数组成一个线段，并且找出两两中最大的保存下来，这样再建立一个0--N个数的二叉树就OK了，那么只需找出I--I+M-1区间中的最大值即可。

【参考程序】：

例:
比如要算7位的。
1010230 算是一个。 1000198 不算，有3个连续的0了。 0001235 不算，这个是4位的。

input：
两个十进制整数N和K。
(2 <= K <= 10, 2 <= N)
(4 <= N+K <= 18)  (1009)
(4 <= N+K <= 180) (1012)
(4 <= N+K <= 1800)(1013)

output：
N位的K进制数中不包含两个连续的0的数的个数，用十进制表示。

分析：

因为两个0不能挨在一起，所以对于长度为i的符合要求的k进制数的个数只跟长度为i-1的符合要求的k进制的数有关。

由此可得：
长度为i的符合要求且第一位为0的k进制数个数为长度为i-1符合要求的首位不为0的k进制数的个数。
长度为i的符合要求且第一位不为0的k进制数的个数为i-1符合要求的k进制数（无论首位是不是0）乘以k-1的积

最后输出长队为n，首位不为0的符合要求的k进制数即可。

【参考程序】：

当然，你知道这样的情节是非常理想的。但实际上那个1号孩子也许会说: "这不是我干的！这是第K1号孩子干的！" (我们不知道这是真话还是谎言)。然后，妈妈走近第2号孩子并问了同样的问题……

一些孩子尝试说出真相，其他孩子按顺序说出一些情况。但有些孩子不同意把做错事的孩子泄露给妈妈：每个孩子都指出杯子是被另一个孩子砸破的——并行成一个循环。为此，妈妈非常苦恼。她绞尽脑汁地去回忆每一个孩子所告诉她的关于杯子的事情，并把每个孩子给她的证言写在一张纸上。现在，她马上着手调查这件事。首先，她决定去找出一些孩子之前所描述的“集体证言”。你要编写一个程序帮妈妈完成这件事。

input：
第一行包含一个正整数T (0 < T < 1001)为测试数据的总数目。每个测试数据由两行组成：第一行包含一个正整数 N (0 < N < 25001)为孩子的数目。第二行包含N 个由空格隔开的数，那是每一个孩子的证言。第I个数表示第I个孩子所指出打破杯子的那个孩子的编号。而0则表示这第I个孩子突然承认了错误。

output：
你应该用一行来回答一个测试点。它包括"YES", 如果这个孩子事件的结果看起来是不容辩驳的: 一个孩子承认他自己打破了那个杯子, 并且没有每个孩子都指出杯子是被另一个孩子砸破的——并行成一个循环这种情况.否则你就输出"NO"。

input：
4
4
2 0 2 2
4
2 0 2 1
5
2 3 4 1 3
3
0 3 2

output：
YES
YES
NO
NO

分析：此题本人用的是并查集：以第i个人说的那个人作为边插入集合中，一旦有一个人说的话形成了环（即在已有的集合一面），那么一定是NO，还有当有多个人承认时也是NO，其它的就是YES。

【参考程序】：

输入文件的第一行有两个浮点数。第一行为步行速度，第二个为乘地铁的速度，第二个总比第一个大。

接下来的就是地铁的描述。第一行为一整数 N ，它是地铁站的数量。假设N不超过 200。接下来的N行，每行包含两个浮点数 (第i-行为第 i-个地铁站的坐标)。接下来的描述表示哪两个站相连，每一连接用一对整数描述，也一就是说，连接的两个站的编号。用一对数0，0表示连接的终止。假设所有的连接都是直线。  

注意，转换交通工具只能在地铁的出入站口，并且不花时间。

最后为点 A 和 B 的坐标，一行一个。

output：
第一行为从点A到点B所需的最少时间，精确至小数点后 10-6位。第二行为旅行时利用的地铁站的描述。第一个为访问的地铁站的数量，后跟着一系列地铁站的编号。

input：
1 100
4
0 0
1 0
9 0
9 9
1 2
1 3
2 4
0 0
10 10
10 0

output：
2.6346295
4 4 2 1 3

【参考程序】：

给出所有报告会的时间安排表，要求你求出最多能够参加多少场报告会。

input：
第一行为报告会的总数N， 1 <= N <= 100000。接下来有N行，每一行有两个整数 T_s 和 T_e ，一空格隔开 (1 <= T_s < T_e <= 30000)，报告会的开始时间和结束时间，单位为分钟。

output：
你应该输出能够参加的报告会的最大数目。不能参加同时举行的报告会，并且两场报告会之间至少要有一分钟的时间差。比如，如果一场报告会的结束时间在15，那么能够参加的下一场报告会的开始时间应该在16或更后的时间。

input：
5
3 4
1 5
6 7
4 5
1 3

output：
3

【参考程序】：

【参考程序】：

给定机场和航线还有他们开始所在的机场，问谁会赢得游戏。假设两个人都用最优策略。

input：
第1行两个整数N和K。N为机场数(N<=1000)，K是他们一开始所在机场的编号(1 <= K<= N)。
接下来n-1行每行两个整数，表示一条航线连接的两个机场。每个机场最多连20条航线。

output：
如果先走的那个人赢，输出 "First player wins flying to airport L"，
L是先走的人第一次飞向的机场编号。如果有多个L输出最小的一个。
如果先走的人输，输出"First player loses"。

input：
4 3
3 2
3 1
1 4

output：
First player wins flying to airport 2

输出最大的子矩阵的和.

input：
4
0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2

output：
15

【参考程序】：

【参考程序】：

7
1
1
1
1
1
1
1
1 3
2 3
6 4
7 4
4 5
3 5
0 0

f[i,1]表示邀请i的最大值          f[i,2]表示不邀请i的最大值

f[i,1]=sigma(f[i.sons,2])              f[i,2]=sigma(max{f[i.sons,1],f[i.sons,2]})

   2   5
\ /
3   4
\ /
1

当一棵树太多枝条时，采摘苹果是不方便的，这就是为什么有些枝要剪掉的原因。现在我们关心的是，剪枝时，如何令到损
失的苹果最少。给定苹果树上每条枝的苹果数目，及必须保留的树枝的数目。你的任务是计算剪枝后，能保留多少苹果。

input：

首行为N，Q (1 <= Q <= N, 1 < N <= 100), N为一棵树上的根和枝的编号总数，Q为要保留的树枝的数目。以下N-1行
为每条树枝的描述，用3个空格隔开的整数表示，前2个数为树枝两端的编号,第三个数为该枝上的苹果数。假设每条枝上的苹
果数不超过3000个。

output:
输出能保留的苹果数。（剪枝时，千万不要连根拔起哦）。

分析：
这道题,可以马上看出是树形Dp,f[i,j]表示以i为根的子树(还包括 [i与 i的父亲] 这条边)内,保存j条
边最多可以有多少苹果,显然f[i,j]=max(f[left[i],k]+f[right[i],j-k-1])+apple[i];

【参考程序】：

#include<iostream>
using namespace std;
struct node
{
    int lc,rc;
    int s;
} tree[101];
    //i-j相连的数量。//i为节点留j条枝的最优值。
int apple[101][101],f[101][101];
bool v[101];//访问标志。
int n,q;
void dfs(int k)
{
    v[k]=false;
    for (int i=1;i<=n;i++)
        if (v[i] && apple[k][i]!=-1)
        {//没有访问且与父亲相连。
            if (tree[k].lc==0) tree[k].lc=i;
            else tree[k].rc=i;//任意的，这里谁左右没关系，其实只是为了建树。
            tree[i].s=apple[k][i];//孩子继承父亲，为后面dp搜素做准备。
            dfs(i);
        }
}
int dp_max(int t,int k)
{
    if (f[t][k]!=-1) return f[t][k];//因为是自底向上dp，前面的必定最优。
    if (t==0 || k==0)
    {//分的枝条已经没有或已经是叶子节点。
        f[t][k]=0;return 0;
    }
    f[t][k]=0;
    for (int i=0;i<=k-1;i++)
    {//枚举左右孩子各取多少枝条所达到的最优值。
        int ls=dp_max(tree[t].lc,i);
        int rs=dp_max(tree[t].rc,k-1-i);
        if (f[t][k]<ls+rs) f[t][k]=ls+rs;
    }
    f[t][k]+=tree[t].s;//返回时父亲也要算。
    return f[t][k];
}
int main()
{
    scanf("%d%d",&n,&q);
    memset(apple,-1,sizeof(apple));
    int a,b,c;
    for (int i=2;i<=n;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        apple[a][b]=c;apple[b][a]=c;
    }
    memset(v,true,sizeof(v));
    memset(tree,0,sizeof(tree));
    dfs(1);
    memset(f,-1,sizeof(f));
    int ans=dp_max(1,q+1);
    printf("%d\n",ans);
    return 0;
}

输入：一个数Q，0<=Q<=10^9 输出：你所找到的整数。如果它不存在，那么输出-1；

input：
10

output：
25

【参考程序】：