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

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

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

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

然后开始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())||1)
    {
        if(c>='0'&&c<='9')
        {
            break;
        }
    }
    n=c-'0';
    while((c=getchar())||1)
    {
        if(c>='0'&&c<='9')
        {
            n=n*10+c-'0';
        }
        else
        {
            return(n);
        }
    }
}
int dp[5001][5001];
int ints[5001],sums[5001];
inline int he(int l,int r)
{
    if(l==0)
    {
        return(sums[r]);
    }
    return(sums[r]-sums[l-1]);
}
signed main()
{
//    freopen("tower.in","r",stdin);
//    freopen("tower.out","w",stdout);
    memset(dp,128,sizeof(dp));
    int n=get();
    for(register int i=1;i<=n;i++)
    {
        ints[i]=get();
        sums[i]=sums[i-1]+ints[i];
    }
    for(register int i=1;i<=n;i++)
    {
        dp[i][1]=1;
    }
    for(register int j=2;j<=n;j++)
    {
        int mx=-1234567890,k=j;
        for(register int i=j;i<=n;i++)
        {
            while(k>1&&he(k-1,j-1)<=he(j,i))
            {
                k--;
                mx=max(mx,dp[j-1][k]);
            }
            if(k<j)
            {
                dp[i][j]=mx+1;
            }
        }
    }
    int maxn=0;
    for(register int i=1;i<=n;i++)
    {
        maxn=max(maxn,dp[n][i]);
    }
    cout<<n-maxn<<endl;
    fclose(stdin);
    fclose(stdout);
    return(0);
}

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[105];
struct kc{
    int fi[105],nl[105],sl;
}y[10005];
int n,t,s,dp[200005][105],mnl;
int main()
{
//    freopen("wrk.in","r",stdin);
//    freopen("wrk.out","w",stdout);
    scanf("%d%d%d",&t,&s,&n);
    for(rii=1;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=1;i<=105;i++)
    {
        gz[i]=inf;
    }
    for(rii=1;i<=n;i++)
    {
        int ltt,kkk;
        scanf("%d%d",&ltt,&kkk);
        gz[ltt]=min(gz[ltt],kkk);
    }
    int cnt=0;
    for(rii=0;i<=10000;i++)
    {
        for(rij=0;j<=100;j++)
        {
            dp[i][j]=-inf;
        }
    }
    dp[0][1]=0;
    for(rii=0;i<=t-1;i++)
    {
        int minx=inf;
        int maxn=0;
        for(rij=1;j<=mnl;j++)
        {
            if(i!=0)
            {
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
            }
            minx=min(minx,gz[j]);
            if(minx==inf)
            {
                continue;
            }
            dp[i+minx][j]=max(dp[i+minx][j],dp[i][j]+1);
            maxn=max(maxn,dp[i][j]);
        }
        for(rij=1;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=0;
    for(rii=1;i<=100;i++)
    {
        ans=max(dp[t][i],ans);
    }
    cout<<ans;
    return 0;
}
    

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个树洞

我们就可以枚举长度

判断此时是否成立即可