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 = 0;char ch = getchar();char c = ch;
    while(ch > '9' || ch < '0')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0',ch = getchar();
    if(c == '-')x = -x; 
}
const long long MAXN = 1000000 + 10;
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 = 1;i <= n;++ i)
    {
        read(T[i]);read(D[i]);
        cnt[i] = i;
        sum += D[i];
    }
    std::sort(cnt + 1, cnt + 1 + n, cmp);
    for(register long long i = 1;i <= n;++ i)
    {
        sum -= D[cnt[i]];
        ans += ((long long)(sum * T[cnt[i]]) << 1);
    }
    printf("%lld", 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。

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 = 0;char ch = getchar();char c = ch;
    while(ch > '9' || ch < '0')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0',ch = getchar();
    if(c == '-')x = -x; 
} 
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1000000 + 10;
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 << 1], q2[MAXN << 1],head, tail;
long long f[MAXN]; 

int main()
{
    read(n);read(k);
    for(register long long i = 1;i <= n;++ i)
        read(e[i]),ans += e[i];
    
    head = tail = 1;//队列表示的范围：[head,tail] 
    q1[1] = q2[1] = 0;
    for(register int i = 1;i <= n;++ i)
    {
        while(i - q2[head] - 1 > 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 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

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

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

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
inline void read(int &x)
{
    x = 0;char ch = getchar();char c = ch;
    while(ch > '9' || ch < '0')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0',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 = 5000 + 10;
const int MAXE = 25000 + 10;
const int MAXW = 2000 + 10;

int t; 
int n,m,w;

struct Edge
{
    int u,v,w,next;
}edge[(MAXE << 1) + 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, 0, sizeof(b));
    memset(d, 0x3f, sizeof(d));
    memset(cot, 0, sizeof(cot));
    q.push(s);
    d[s] = 0;
    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 0;
                }
            }
        }
    }
    return 1;
} 

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

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