NOIP2014-5-24模拟赛

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的顺序来运送他的奶牛

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。

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

---

T1:贪心

对于牛i和牛i+1，不妨假设之后的牛D的和为x，

那么如果牛i后运输，吃掉的花为: 2*Ti+1*(x+Di)+2*Ti*x

如果牛i先运输，吃掉的花为:2*Ti*(x+Di+1)+2*Ti+1*x

化简得：Ti+1*Di和Ti*Di+1

即

牛i后运输⇔Ti+1*Di<Ti*Di+1⇔Di/Ti<Di+1/Ti+1

所以排序之后使得任何一对牛都满足上述关系式，不可能存在更优解

注意：开longlong啊，遇到乘法想longlong，要不然爆0真是泪流满面啊~~~

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 100005
#define ll long long
using namespace std;
struct Node{
    ll T,D;
    double p;
    Node(){
        T=D=0;
        p=0;
    }
}s[MAXN];
int n;
ll a[MAXN];
bool comp(const Node &p1,const Node &p2){
    return (p1.p<p2.p);
}
int main()
{
//    freopen("flower1.in","r",stdin);
//    freopen("my.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&s[i].T,&s[i].D);
        s[i].p=(double)s[i].D/s[i].T;
    }
    sort(s+1,s+n+1,comp);
    for(int i=1;i<=n;i++){
        a[i]=a[i-1]+s[i].D;
    }
    ll ans=0;
    for(int i=n;i>=1;i--){
        ans+=(s[i].T*2*a[i-1]);
    }
    printf("%lld
",ans);
    return 0;
}

---

T2:

朴素dp很好想，滚动后70分

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 100005
#define ll long long
using namespace std;
ll f[MAXN];
ll a[MAXN];
int n,K;
int main()
{
//    freopen("data.in","r",stdin);
    scanf("%d%d",&n,&K);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
    }
    for(int i=0;i<n;i++){
        ll temp=0;
        for(int k=min(i,K);k>=0;k--){
            if(k+1<=K){
                f[k+1]=max(f[k+1],f[k]+a[i+1]);
            }
            temp=max(temp,f[k]);
        }
        f[0]=max(f[0],temp);
    }
    ll ans=0;
    for(int i=0;i<=K;i++){
        ans=max(ans,f[i]);
    }
    printf("%lld
",ans);
    return 0;
}

正解是dp+单调队列

正难则反，求扔掉的牛的效率之和

然后f[i]表示

对于前i个牛，我们扔掉i，其余都是正常，

在这种情况下，所有扔掉的牛效率之和的最小值

那么f[i]=min{f[j]+a[i] | i-k-1<=j<=i-1}

实际上我们可以认为此方程中，i扔了，j扔了，i和j之间的都选

然后结果是∑a[i]-min{f[i-k]~f[i]}

这样状态的定义就具有了单调队列所需的“跳动性”，而不是普通dp的连贯性

一般dp连贯性固然好，但是优化时也应该学会打破常规，跳出去

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 100005
#define ll long long
using namespace std;
ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if('-'==ch)f=-1;ch=getchar();}
    while('0'<=ch&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
ll f[MAXN];
int n,k;
ll a[MAXN];
int deq[MAXN];
ll sum;
int main()
{
//    freopen("data.in","r",stdin);
    n=read();k=read();
    for(int i=1;i<=n;i++){
        a[i]=read();
        sum+=a[i];
    }
    int L=1,R=1;
    for(int i=1;i<=n;i++){
        f[i]=f[deq[L]]+a[i];
        while(L<=R&&f[deq[R]]>=f[i]){
            R--;
        }
        deq[++R]=i;
        if(i-k-1==deq[L]){
            L++;
        }
    }
    ll ans=f[n];
    for(int i=n-1;i>=n-k;i--){
        ans=min(ans,f[i]);
    }
    printf("%lld",sum-ans);
    return 0;
}

---

T3:

就是一个判断负环的问题，用dfs_SPFA即可

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 505
#define MAXM 3005
using namespace std;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if('-'==ch)f=-1;ch=getchar();}
    while('0'<=ch&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int first[MAXN],Next[MAXM*2],to[MAXM*2],Val[MAXM*2],cnt;
//double edge
int d[MAXN],b[MAXN];
int n,m,p;
void Add(int x,int y,int w){
    Next[++cnt]=first[x];first[x]=cnt;to[cnt]=y;Val[cnt]=w;
}
int SPFA(int x){
    //!!!
    if(b[x]){
        return 1;
    }
    b[x]=1;
    for(int e=first[x];e;e=Next[e]){
        int y=to[e],w=Val[e];
        if(d[y]>d[x]+w){
            d[y]=d[x]+w;
            if(SPFA(y)){
                return 1;
            }
        }
    }
    b[x]=0;
    return 0;
}
void solve(){
    memset(first,0,sizeof(first));
    memset(Next,0,sizeof(Next));
    memset(to,0,sizeof(to));
    memset(Val,0,sizeof(Val));
    memset(d,0,sizeof(d));
    memset(b,0,sizeof(b));
    cnt=0;
    n=read();m=read();p=read();
    for(int i=1;i<=m;i++){
        int x,y,w;
        x=read();y=read();w=read();
        Add(x,y,w);
        Add(y,x,w);
    }
    for(int i=1;i<=p;i++){
        int x,y,w;
        x=read();y=read();w=read();
        Add(x,y,-w);
    }
    for(int i=1;i<=n;i++){
        if(SPFA(i)){
            printf("YES
");
            return ;    
        }
    }
    printf("NO
");
}
int main()
{
//    freopen("wormhole.2.in","r",stdin);
    int T;
    T=read();
    for(int i=1;i<=T;i++){
        solve();
    }
    return 0;
}