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=;
         p=;
     }
 }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=;i<=n;i++){
         scanf("%d%d",&s[i].T,&s[i].D);
         s[i].p=(double)s[i].D/s[i].T;
     }
     sort(s+,s+n+,comp);
     for(int i=;i<=n;i++){
         a[i]=a[i-]+s[i].D;
     }
     ll ans=;
     for(int i=n;i>=;i--){
         ans+=(s[i].T**a[i-]);
     }
     printf("%lld\n",ans);
     return ;
 }

Code1

---

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=;i<=n;i++){
         scanf("%lld",&a[i]);
     }
     for(int i=;i<n;i++){
         ll temp=;
         for(int k=min(i,K);k>=;k--){
             if(k+<=K){
                 f[k+]=max(f[k+],f[k]+a[i+]);
             }
             temp=max(temp,f[k]);
         }
         f[]=max(f[],temp);
     }
     ll ans=;
     for(int i=;i<=K;i++){
         ans=max(ans,f[i]);
     }
     printf("%lld\n",ans);
     return ;
 }

Code2-1

正解是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=,f=;char ch=getchar();
     while(ch<''||ch>''){if('-'==ch)f=-;ch=getchar();}
     while(''<=ch&&ch<=''){x=x*+ch-'';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=;i<=n;i++){
         a[i]=read();
         sum+=a[i];
     }
     int L=,R=;
     for(int i=;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-==deq[L]){
             L++;
         }
     }
     ll ans=f[n];
     for(int i=n-;i>=n-k;i--){
         ans=min(ans,f[i]);
     }
     printf("%lld",sum-ans);
     return ;
 }

Code2-2

---

T3:

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

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

Code3