9.21 noip模拟试题

 

Problem 1 护花(flower.cpp/c/pas)

【题目描述】

约翰留下他的N(N<=100000)只奶牛上山采木．他离开的时候，她们像往常一样悠闲地在草场里吃草．可是，当他回来的时候，他看到了一幕惨剧：牛们正躲在他的花园里，啃食着他心爱的美丽花朵！为了使接下来花朵的损失最小，约翰赶紧采取行动，把牛们送回牛棚． 牛们从1到N编号．第i只牛所在的位置距离牛棚Ti(1≤Ti≤2000000)分钟的路程，而在约翰开始送她回牛棚之前，她每分钟会啃食Di(1≤Di≤100)朵鲜花．无论多么努力，约翰一次只能送一只牛回棚．而运送第第i只牛事实上需要2Ti分钟，因为来回都需要时间．    写一个程序来决定约翰运送奶牛的顺序，使最终被吞食的花朵数量最小．

【输入格式】

第1行输入N，之后N行每行输入两个整数Ti和Di

【输出格式】

一个整数，表示最小数量的花朵被吞食

【样例输入】

6

3 1

2 5

2 3

3 2

4 1

1 6

【样例输出】

86

【样例解释】

 约翰用6，2，3，4，1，5的顺序来运送他的奶牛

 为啥网站上过了 cena就wa 有毒...

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 100010
using namespace std;
int n,ans,S;
struct node{
    int t,d;
}cow[maxn];
int init(){
    int x=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}
int cmp(const node &x,const node &y){
    return x.t*y.d<x.d*y.t;
}
int main()
{
    freopen("flower.in","r",stdin);
    freopen("flower.out","w",stdout);
    n=init();
    for(int i=1;i<=n;i++){
        cow[i].t=init();
        cow[i].d=init();
        S+=cow[i].d;
    }
    sort(cow+1,cow+1+n,cmp);
    for(int i=1;i<=n;i++){
        S-=cow[i].d;
        ans+=2*S*cow[i].t;
    }
    cout<<ans;
    return 0;
} 

Problem 2 修剪草坪(mowlawn.cpp/c/pas)

【题目描述】

在一年前赢得了小镇的最佳草坪比赛后，FJ变得很懒，再也没有修剪过草坪。现在，
新一轮的最佳草坪比赛又开始了，FJ希望能够再次夺冠。
然而，FJ的草坪非常脏乱，因此，FJ只能够让他的奶牛来完成这项工作。FJ有N
(1 <= N <= 100,000)只排成一排的奶牛，编号为1...N。每只奶牛的效率是不同的，
奶牛i的效率为E_i(0 <= E_i <= 1,000,000,000)。
靠近的奶牛们很熟悉，因此，如果FJ安排超过K（1<=K<=N）只连续的奶牛，那么，这些奶牛就会罢工
去开派对:)。因此，现在FJ需要你的帮助，计算FJ可以得到的最大效率，并且该方案中
没有连续的超过K只奶牛。

【输入格式】
* 第一行：空格隔开的两个整数N和K
* 第二到N+1行：第i+1行有一个整数E_i

【输出格式】
* 第一行：一个值，表示FJ可以得到的最大的效率值。

【样例输入】

5 2

1

2

3

4

5

输入解释：

FJ有5只奶牛，他们的效率为1，2，3，4，5。他们希望选取效率总和最大的奶牛，但是

他不能选取超过2只连续的奶牛

【样例输出】

12

FJ可以选择出了第三只以外的其他奶牛，总的效率为1+2+4+5=12。

 单调队列优化dp

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 100010
#define ll long long
using namespace std;
ll n,k,x,s[maxn],f[maxn],ans,q[maxn],head,tail;
ll init(){
    ll x=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}
ll max(ll a,ll b){
    return a>b?a:b;
}
void Insert(ll x){
    while(head<tail&&f[q[tail]-1]-s[q[tail]]<f[x-1]-s[x])
        tail--;
    q[++tail]=x;
}
int main()
{
    freopen("mowlawn.in","r",stdin);
    freopen("mowlawn.out","w",stdout);
    n=init();k=init();
    for(int i=1;i<=n;i++){
        x=init();s[i]=s[i-1]+x;
    }
    Insert(1);
    for(int i=1;i<=n;i++){
        if(i-q[head]>k)head++;
        ll p=q[head];
        f[i]=f[p-1]+s[i]-s[p];
        ans=max(ans,f[i]);
        Insert(i+1);
    }
    cout<<ans<<endl;
    return 0;    
}

Problem 3 虫洞(wormhole.cpp/c/pas)

【题目描述】

John在他的农场中闲逛时发现了许多虫洞。虫洞可以看作一条十分奇特的有向边，并可以使你返回到过去的一个时刻（相对你进入虫洞之前）。John的每个农场有M条小路（无向边）连接着N （从1..N标号）块地，并有W个虫洞（有向边）。其中1<=N<=500,1<=M<=2500,1<=W<=200。 现在John想借助这些虫洞来回到过去（出发时刻之前），请你告诉他能办到吗。 John将向你提供F(1<=F<=5)个农场的地图。没有小路会耗费你超过10000秒的时间，当然也没有虫洞回帮你回到超过10000秒以前。

【输入格式】

* Line 1: 一个整数 F, 表示农场个数。

* Line 1 of each farm: 三个整数 N, M, W。

* Lines 2..M+1 of each farm: 三个数（S, E, T）。表示在标号为S的地与标号为E的地中间有一条用时T秒的小路。

* Lines M+2..M+W+1 of each farm: 三个数（S, E, T）。表示在标号为S的地与标号为E的地中间有一条可以使John到达T秒前的虫洞。

【输出格式】

* Lines 1..F: 如果John能在这个农场实现他的目标，输出"YES",否则输出"NO"。

【样例输入】

2

3 3 1

1 2 2

1 3 4

2 3 1

3 1 3

3 2 1

1 2 3

2 3 4

3 1 8

【样例输出】

NO

YES

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define maxn 510
#define maxm 6010
using namespace std;
int T,n,m,w,num,head[maxn],dis[maxn],cnt[maxn],falg,f[maxn];
queue<int>q;
struct node{
    int v,t,pre;
}e[maxm];
int init(){
    int x=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}
void Clear(){
    num=falg=0;
    while(!q.empty())q.pop();
    memset(head,0,sizeof(head));
    memset(cnt,0,sizeof(cnt));
    memset(dis,127/3,sizeof(dis));
    memset(f,0,sizeof(f));
}
void Add(int from,int to,int dis){
    num++;e[num].t=dis;
    e[num].v=to;
    e[num].pre=head[from];
    head[from]=num;
}
void SPFA(int s){
    dis[s]=0;f[s]=1;q.push(s);cnt[s]++;
    while(!q.empty()){
        int k=q.front();q.pop();f[k]=0;
        if(cnt[k]>n+5){
            falg=1;break;
        }
        for(int i=head[k];i;i=e[i].pre){
            int v=e[i].v;
            if(dis[v]>dis[k]+e[i].t){
                dis[v]=dis[k]+e[i].t;
                if(!f[v]){
                    f[v]=1;q.push(v);cnt[v]++;
                }
            }
        }
    }
}
int main()
{
    freopen("wormhole.in","r",stdin);
    freopen("wormhole.out","w",stdout);
    T=init();
    while(T--){
        Clear();
        n=init();m=init();w=init();
        int u,v,t;
        for(int i=1;i<=m;i++){
            u=init();v=init();t=init();
            Add(u,v,t);Add(v,u,t);
        }
        for(int i=1;i<=w;i++){
            u=init();v=init();t=init();
            Add(u,v,-t);
        }
        for(int i=1;i<=n;i++)
            if(cnt[i]==0){
                SPFA(i);
                if(falg)break;
            }
        if(falg)printf("YES
");
        else printf("NO
");
    }
}

 conclusion

/*
今天上午贡献给扫描线了
晚上考的 只做了前3个(好吧其实T4一看就够了)
T1 正当我冥思苦想的时候 一旁的gzz说出了正解
后来证明了一下很对的 然而不是自己想出来的....
以后找个没人的地方做题23333
T2单调队列优化dp
最近做过类似的 写了个暴力拍了拍 没啥问题
T3模型简化一下判负环

最后200分 T1没算 不知道自己在想一会能不能想出正解

T1这种贪心还是很套路的 单独的抽出两个来研究
保证这两个交换顺序不影响别的 然后通过这两个来搞出sort的规则
很套路的 就像国王游戏差不多
*/