NOIP模拟 6.30

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

按D/T排序，证明相邻的交换过来不会比原来更优即可。

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 inline void read(long long &x)
 {
     x = ;char ch = getchar();char c = ch;
     while(ch > '' || ch < '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '',ch = getchar();
     if(c == '-')x = -x;
 }
 const long long MAXN =  + ;
 const int INF = 0x3f3f3f3f;

 long long n,T[MAXN],D[MAXN],cnt[MAXN];

 bool cmp(long long a, long long b)
 {
     return D[a] * T[b] > D[b] * T[a];
 }

 long long ans;
 long long sum;

 int main()
 {
     read(n);
     for(register long long i = ;i <= n;++ i)
     {
         read(T[i]);read(D[i]);
         cnt[i] = i;
         sum += D[i];
     }
     std::sort(cnt + , cnt +  + n, cmp);
     for(register long long i = ;i <= n;++ i)
     {
         sum -= D[cnt[i]];
         ans += ((long long)(sum * T[cnt[i]]) << );
     }
     printf("%lld", ans);
     return ;
 }

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。

f[i]表示1..i只奶牛不选第i只的最小损耗

初始状态f[0] = 0

转移f[i] = min{f[j]} + e[i],其中（i - j - 1 <= k）

维护一个单调递增队列，从队首取最小元素，新元素加到队尾并维持单调性，每次取队首元素时检查是否合法(即i - j - 1 <= k)

此题开longlong，注意INF的取值，所以以后尽量手写一层，不要用INF

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 inline void read(long long &x)
 {
     x = ;char ch = getchar();char c = ch;
     while(ch > '' || ch < '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '',ch = getchar();
     if(c == '-')x = -x;
 }
 const long long INF = 0x3f3f3f3f3f3f3f3f;
 const int MAXN =  + ;
 inline long long max(long a, long b){return a > b ? a : b;}
 inline long long min(long a, long b){return a < b ? a : b;}

 long long n,k,e[MAXN];
 long long ans;

 long long q1[MAXN << ], q2[MAXN << ],head, tail;
 long long f[MAXN]; 

 int main()
 {
     read(n);read(k);
     for(register long long i = ;i <= n;++ i)
         read(e[i]),ans += e[i];

     head = tail = ;//队列表示的范围：[head,tail]
     q1[] = q2[] = ;
     for(register int i = ;i <= n;++ i)
     {
         while(i - q2[head] -  > k)head ++;
         f[i] = e[i] + q1[head];
         while(q1[tail] >= f[i] && head <= tail)tail--;
         q1[++ tail] = f[i];
         q2[tail] = i;
     }
     long long tmp = INF;
 //最好改为tmp = f[n - k];
     for(register int i = n - k;i <= n;++ i)
     {
         tmp = min(tmp, f[i]);
     }
     printf("%lld", ans - tmp);
     return ;
 }

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

此虫洞非彼虫洞，明显简单一大截。

SPFA找负环即可，题意描述不够明确。

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 inline void read(int &x)
 {
     x = ;char ch = getchar();char c = ch;
     while(ch > '' || ch < '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '',ch = getchar();
     if(c == '-')x = -x;
 }
 inline int max(int a, int b){return a > b ? a : b;}
 inline int min(int a, int b){return a < b ? a : b;}
 inline void swap(int &a, int &b){int tmp = a;a = b;b = tmp;} 

 const int INF = 0x3f3f3f3f;
 const int MAXN =  + ;
 const int MAXE =  + ;
 const int MAXW =  + ;

 int t;
 int n,m,w;

 struct Edge
 {
     int u,v,w,next;
 }edge[(MAXE << ) + MAXW];
 int head[MAXN],cnt;

 inline void insert(int a, int b, int c)
 {
     edge[++cnt] = Edge{a,b,c,head[a]};
     head[a] = cnt;
 }

 std::queue<int> q;
 int b[MAXN], d[MAXN], cot[MAXN];

 inline int SPFA(int s)
 {
     memset(b, , sizeof(b));
     memset(d, 0x3f, sizeof(d));
     memset(cot, , sizeof(cot));
     q.push(s);
     d[s] = ;
     b[s] = true;
     cot[s] ++;
     register int u,v;
     while(!q.empty())
     {
         u = q.front();
         q.pop();
         b[u] = false;
         for(register int pos = head[u];pos;pos = edge[pos].next)
         {
             v = edge[pos].v;
             if(d[v] > d[u] + edge[pos].w)
             {
                 d[v] = d[u] + edge[pos].w;
                 if(!b[v])
                 {
                     b[v] = true;
                     q.push(v);
                     cot[v] ++;
                     if(cot[v] >= n)return ;
                 }
             }
         }
     }
     return ;
 } 

 int main()
 {
     read(t);
     register int tmp1,tmp2,tmp3;
     for(;t;--t)
     {
         read(n);read(m);read(w);
         memset(edge, , sizeof(edge));
         memset(head, , sizeof(head));
         cnt = ;
         for(register int i = ;i <= m;++ i)
         {
             read(tmp1);read(tmp2);read(tmp3);
             insert(tmp1, tmp2, tmp3);
             insert(tmp2, tmp1, tmp3);
         }
         for(register int i = ;i <= w;i ++)
         {
             read(tmp1);read(tmp2);read(tmp3);
             insert(tmp1, tmp2, - * tmp3);
         }
         if(!SPFA())
         {
             printf("YES\n");
         }
         else
         {
             printf("NO\n");
         }
     }
     return ;
 }

T4暴力模拟没意思。。。不上了