2018/7/19 考试（tower，work，holes）

noip模拟赛，挺良心的题，考的贼烂（膜一下@来日方长大佬（sdfz rank1））

不多说了，看题吧

1.tower

题面：

铁塔(tower.pas/c/cpp)

题目描述

Rainbow和Freda要在PoeticIsland市的一座山脚下盖房子定居了......
盖房子需要钢材，幸运的是，这里有排成一行的n座废弃的铁塔，从左到右编号为1~n，其中第i座的高度为h[i]。
Rainbow和Freda想盖一座上面小下面大的城堡，并且城堡的层数尽可能多。
因此，他们要把这些铁塔分成尽量多组，每组内的铁塔编号必须是连续的，并且从左到右各组内铁塔的高度之和单调不减。
最后，他们会用每组铁塔所提供的钢材构成一层城堡。
但是Rainbow和Freda简直弱爆了有木有，于是请你帮忙计算一下最多能分成多少组呢？

输入格式：

第一行一个整数n。第二行n个整数，第i个整数表示h[i]。

输出格式：

输出一个整数，表示(n-最多能分成的组数)。

思路：

正解是DP，我手打了一个贪心，20分。。。。。

贪心可以被证明是错的，（2,2,1,3,3，自己看一下），爆搜也会超时

怎么办呢？

我们要求的其实就是将原序列划分为多个子串

且每一个子串长度和连续不降

所以我们可以用前缀和预处理一下

然后开始DP

我们要保证在最后面的合起来的数尽可能的小

所以维护3个数组

dp数组，前缀和数组和最大值数组

线性转移即可

代码（感谢颜神）：

#include<iostream>

#include<cstdio>

#include<cstring>

#define int long long

using namespace std;

inline int get()

{

    int n;

    char c;

    while((c=getchar())||)

    {

        if(c>=''&&c<='')

        {

            break;

        }

    }

    n=c-'';

    while((c=getchar())||)

    {

        if(c>=''&&c<='')

        {

            n=n*+c-'';

        }

        else

        {

            return(n);

        }

    }

}

int dp[][];

int ints[],sums[];

inline int he(int l,int r)

{

    if(l==)

    {

        return(sums[r]);

    }

    return(sums[r]-sums[l-]);

}

signed main()

{

//    freopen("tower.in","r",stdin);

//    freopen("tower.out","w",stdout);

    memset(dp,,sizeof(dp));

    int n=get();

    for(register int i=;i<=n;i++)

    {

        ints[i]=get();

        sums[i]=sums[i-]+ints[i];

    }

    for(register int i=;i<=n;i++)

    {

        dp[i][]=;

    }

    for(register int j=;j<=n;j++)

    {

        int mx=-,k=j;

        for(register int i=j;i<=n;i++)

        {

            while(k>&&he(k-,j-)<=he(j,i))

            {

                k--;

                mx=max(mx,dp[j-][k]);

            }

            if(k<j)

            {

                dp[i][j]=mx+;

            }

        }

    }

    int maxn=;

    for(register int i=;i<=n;i++)

    {

        maxn=max(maxn,dp[n][i]);

    }

    cout<<n-maxn<<endl;

    fclose(stdin);

    fclose(stdout);

    return();

}

T2:work

题面：

工作计划(work.pas/c/cpp)

题目描述：

Mark 在无意中了解到了Elf的身世。
在和James商量过之后，好心的他们打算送Elf返回故乡。
然而，去往Gliese的飞船票价高的惊人，他们暂时还付不起这笔费用。
经过一番考虑，Mark打算去额外做一些工作来获得收入。
经过一番调查，Mark发现有N个工作可以做。
做第i件工作所需要的时间为Di，同时也需要一个能力值Ci才可以去做。
每件工作都可以在任意时间开始，也可以做任意多次。
所有的工作给付的报酬都是一致的。
同时，有S个课程可以参加，我们认为今天是第0天，第i个课程在第Mi天开始，持续时间为Li天，课程结束之后能力值会变为Ai。
现在Mark 的能力值为1。
Mark 只能做工作到第T天（因为那是飞船起飞的日子）。
他想知道期限内他最多可以做多少件工作，好决定未来的打算。
于是他找到了applepi。でも、applepiは彼女と一緒に楽しむことが大切だ，（本人翻译：但是applepi和他的女朋友在一起享受是很重要的）所以这个任务就交给你了。

输入格式：

第一行包含三个空格分隔的整数T,S,N。
之后S 行，每行三个整数M,L,A，描述一个课程。
之后N 行，每行两个整数C,D，描述一件工作。

输出格式：

一个整数，表示Mark 最多可以做多少件工作。

思路：

标配DP，切了1个半小时

我们首先去重，确保每个能力值对应的是当前能力值能做到最大的工作效率（比如说能力都是3，一个要3天另一个要4天，我只存3天）

然后我们开始dp

dp数组我开两维，一维代表时间，另一维代表能力

dp[i][j]表示在i这个位置，能力值为j时的最大收益

如果这个位置我们做工作，那么我们工作结束时的最大收益就可以由当前+1转移而来

如果这个位置我们学习，那么我们到学习结束时的最大收益就是当前的最大收益

当然，我们一开始要将数组赋值为负无穷

这样不可能的情况可以被自动排除

代码：

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

#define rii register int i

#define rij register int j

#define inf 1<<30

using namespace std;

int gz[];

struct kc{

    int fi[],nl[],sl;

}y[];

int n,t,s,dp[][],mnl;

int main()

{

//    freopen("wrk.in","r",stdin);

//    freopen("wrk.out","w",stdout);

    scanf("%d%d%d",&t,&s,&n);

    for(rii=;i<=s;i++)

    {

        int ltt,kkk,lzn;

        scanf("%d%d%d",&ltt,&kkk,&lzn);

        y[ltt].sl++;

        y[ltt].fi[y[ltt].sl]=kkk+ltt;

        y[ltt].nl[y[ltt].sl]=lzn;

        mnl=max(mnl,lzn);

    }

    for(rii=;i<=;i++)

    {

        gz[i]=inf;

    }

    for(rii=;i<=n;i++)

    {

        int ltt,kkk;

        scanf("%d%d",&ltt,&kkk);

        gz[ltt]=min(gz[ltt],kkk);

    }

    int cnt=;

    for(rii=;i<=;i++)

    {

        for(rij=;j<=;j++)

        {

            dp[i][j]=-inf;

        }

    }

    dp[][]=;

    for(rii=;i<=t-;i++)

    {

        int minx=inf;

        int maxn=;

        for(rij=;j<=mnl;j++)

        {

            if(i!=)

            {

                dp[i][j]=max(dp[i][j],dp[i-][j]);

            }

            minx=min(minx,gz[j]);

            if(minx==inf)

            {

                continue;

            }

            dp[i+minx][j]=max(dp[i+minx][j],dp[i][j]+);

            maxn=max(maxn,dp[i][j]);

        }

        for(rij=;j<=y[i].sl;j++)

        {

            dp[y[i].fi[j]][y[i].nl[j]]=max(dp[y[i].fi[j]][y[i].nl[j]],maxn);

        }

    }

    int ans=;

    for(rii=;i<=;i++)

    {

        ans=max(dp[t][i],ans);

    }

    cout<<ans;

    return ;

}

3.holes

题面

树洞(holes.pas/c/cpp)

题目描述

在一片栖息地上有N棵树，每棵树下住着一只兔子，有M条路径连接这些树。更特殊地是，只有一棵树有3条或更多的路径与它相连，其它的树只有1条或2条路径与其相连。
换句话讲，这些树和树之间的路径构成一张N个点、M条边的无向连通图，而度数大于2的点至多有1个。
近年以来，栖息地频繁收到人类的侵扰。
兔子们联合起来召开了一场会议，决定在其中K棵树上建造树洞。
当危险来临时，每只兔子均会同时前往距离它最近的树洞躲避，路程中花费的时间在数值上等于距离。
为了在最短的时间内让所有兔子脱离危险，请你安排一种建造树洞的方式，使最后一只到达树洞的兔子所花费的时间尽量少。

输入格式

第一行有3个整数N，M，K，分别表示树（兔子）的个数、路径数、计划建造的树洞数。
接下来M行每行三个整数x,y，表示第x棵树和第y棵树之间有一条路径相连。1<=x,y<=N，x≠y，任意两棵树之间至多只有1条路径。

输出格式

一个整数，表示在最优方案下，最后一只到达树洞的兔子所花费的时间。

思路：

一眼看出是一道树上二分

发现只剩下30分钟了，来不及写

于是50pts暴力走人

怎么二分呢？

我们知道他有k个树洞

我们就可以枚举长度

判断此时是否成立即可