10.31纪中DAY3_公牛和母牛 & 气象牛 & 轻轨 & 设计

noip2019…counting down three weeks

纪中day3
（头发日益稀少）

10.31纪中B组notes

• 公牛和母牛（USACO FEB09 Problem ‘bullcow’）
• 气象牛（USACO JAN09 Problem ‘baric’）
• 轻轨（USACO FEB09 Problem ‘shuttle’）
• 设计（USACO DEC05 GOLD）

仍旧是蒟蒻的悲惨一天o(╥﹏╥)o

keys & notes 部分来源于纪中题解

T1 公牛和母牛（USACO FEB09 Problem ‘bullcow’）

搜索原题找了半天…

题目描述

jzoj 1292 公牛和母牛
不像原题链接but也许可以将就看着…

FJ想N头牛（公牛或母牛）排成一排接受胡总的检阅，经研究发现公牛特别好斗，如果两头公牛离得太近就会发生冲突，通过观察两头公牛之间至少要有K(0<=K<=N)头母牛才能避免冲突。
FJ想请你帮忙计算一共有多少种放置方法，注意所有的公牛被认为是一样的，母牛也是，所以两种放置方法被认为不同当且仅当某些位置牛的种类不同。

Input
　　第一行：两个空格隔开的整数N（N<=100000）和K。

Output
　　输出一个整数表示方法总数，答案可能很大，
　　所以只需输出mod 5,000,011的值即可。

Sample Input
4 2

Sample Output
6
【样例说明】
以下为6种放置方法，‘B’表示公牛，‘C’表示母牛
CCCC
BCCC
CBCC
CCBC
CCCB
BCCB

notes&keys

The solution to this problem uses a technique called dynamicprogramming,
also known as DP.
Let fn be the number of ways we can have a sequence of n animals so that no two bulls have fewer than K cows between them. We first note that f0 = 1.
We then try to find a recurrence to compute fn in general by considering two cases for the first animal in the sequence:
• If it is a cow, then we have no restrictions on how we may place the other n - 1 animals, so we have fn - 1 ways to finish the sequence.
• If it is a bull, then the next K animals must be cows, but after that we have no more restrictions,so the number of ways to finish the sequence is fn - K - 1.
(Note that when n < 0, we define fn to be 1.)
Thus, combining our two cases together, we have the recurrence
fn = fn - 1 + fn - K - 1.
This gives us a simple solution:
——by Neal Wu

看得我人都傻了…
人家的标程代码…

#include <cstdio>
using namespace std;

FILE *fin = fopen ("bullcow.in", "r"), *fout = fopen ("bullcow.out", "w");

const int MAXN = 100005, MOD = 5000011;

int N, K, dp [MAXN];

int main ()
{
    fscanf (fin, "%d %d", &N, &K);

    for (int n = 0; n <= N; n++)
        if (n <= K)
            dp [n] = n + 1;	
            //距离过小，最多只能放一头公牛，n个位置n种放法，再加上全是母牛的一种
        else
            dp [n] = (dp [n - 1] + dp [n - K - 1]) % MOD;

    fprintf (fout, "%d\n", dp [N]);

    return 0;
}

用我这种蒟蒻听得懂的话解释一下
·法一：
··f [ i ] 表示i头牛的方案数，
··状态转移方程：
f [ i ] = f [ i - 1 ] + 1 ( i <= k + 1)
f [ i ] = f [ i - k ] + f [ i - k - 1 ] ( i > k + 1)
如果在 i 处放置了公牛那么前 k 个就不能放，所以是f [ i - k ]，
放母牛的话就累加之前的方案数f [ i - 1 ]

·法二：from巨佬
i 处放母牛：
f [ i ] = f [ i - 1 ]
（对前边儿无啥影响）
i 处放公牛：
f [ i ] = f [ i - k - 1 ]
（前边儿相隔k之内都不可以放公牛，再往前找一个位置才可能放公牛）

f [ i ] = f [ i - 1 ] + f [ i - k - 1 ]
若 i - k - 1 ＜ 0，初始化 f [ i - k - 1 ] = 1（？）

附上法一神神奇奇的AC代码

#include <bits/stdc++.h>
using namespace std;
int n, k;
long long f[100003]; 

int main()
{
	scanf("%d%d", &n, &k);
	
	f[0] = 1;
	for(int i = 1; i <= n; ++i)
	{
		if(i > k + 1)
			f[i] = (f[i - k - 1] + f[i - 1]) % 5000011;
		else
			f[i] = (f[i - 1] + 1) % 5000011;
	}
	printf("%d",f[n]);
	return 0;
}

T2 气象牛（USACO JAN09 Problem ‘baric’）

搜索原题又双找了半天…

题目描述

jzoj 1293 气象牛
终于找到洛谷链接…p2993 气象测量 The Baric Bovine

为了研究农场的气候,Betsy帮助农夫John做了N(1 <= N <= 100)次气压测量并按顺序记录了结果M_1…M_N(1 <= M_i <= 1,000,000).
　　Betsy想找出一部分测量结果来总结整天的气压分布. 她想用K(1 <= K <= N)个数s_j
(1 <= s_1 < s_2 < … < s_K <= N)来概括所有测量结果. 她想限制如下的误差:
　　对于任何测量结果子集,每一个非此子集中的结果都会产生误差.总误差是所有测量结果的误差之和.更明确第说, 对于每一个和所有s_j都不同的i:
　　* 如果 i 小于 s_1, 误差是:2 * | M_i - M_(s_1) |
　　* 如果i在s_j和s_(j+1)之间,误差是:| 2 * M_i - Sum(s_j, s_(j+1)) |
　　注:Sum(x, y) = M_x + M_y; (M_x 和 M_y 之和)
　　* 如果i大于s_K,误差为:2 * | M_i - M_(s_K) |
　　Besty给了最大允许的误差E (1 <= E <= 1,000,000),找出最小的一部分结果使得误
差最多为E.

Input
　　第一行: 两个空格分离的数: N 和 E
　　第2…N+1行: 第i+1行包含一次测量记录:M_i

Output
　　第一行: 两个空格分开的数: 最少能达到误差小于等于E的测量数目和使用那个测量数目能达到的最小误差.

Sample Input
4 20
10
3
20
40

Sample Output
2 17
【样例说明】
　　选择第二和第四次测量结果能达到最小误差17. 第一次结果的误差是2*|10-3| = 14;第三次结果的误差是|2*20 - (3+40)|=3.

notes&keys

洛谷题解…（多棒呀~）

The problem can be solved by dynamic programming.
We turn this problem into the following:
partial the array into k+1 segments such that the total error is minimized.
（partial adj. 部分的; 不完全的; 热爱; 钟爱; 偏颇; 偏袒;）

The division points between consecutive （adj.连续不断的） segments correspond to the measurement and once we computed this information for all k, the answer can be extrated.
Given a single interval, the error can be computed by looping through the elements.
Of course, special cases are needed for the intervals starting at the begining or ending with the last entry.
Then to compute best[i,k] when k>2, consider the interval the last element is involved in.
If it’s at j, then the best value of the segment is best[j,k-1] along with the error of the interval [i,j] using 1 measurement (which we compute earlier).
There are O(N^2) states of the DP, with O(n) possible transitoins.
Along with the precomputation, the algorithm takes O(n^3).
——by Richard Peng

我又看的人都傻了…
万分不想改但还是拖到最后不改也得改了…
强迫症+拖延症晚期…

···以下为纪中巨佬讲解思路…

这不明！显是一道dp题目嘛~~~~~

···题意：
一坨数，求误差的两种方法已经给出（在两个标准点之间or在两头，求法不一样）
考虑在误差E范围之内，选取标准点数尽可能少
输出选取的最少点数和使用那个测量数目能达到的最小误差.

1. f [ i , j ]表示已经讨论至第i个点，且第i个点已经被选为关键点（标准点），
   已选择了j个关键点的误差情况
2. 枚举加上下一个点之后的误差情况，加上去，构成转移方程

以下部分来源洛谷题解 （就只有两篇…令蒟蒻头秃…）

选的数越少，造成的误差就越大（和现实经验也相符）
继而发现，符合最优子结构，设要选i个数，肯定可以从选 i-1个数的情况中再取一个。
具体哪一个？DP来决策。

预处理一个s数组，s[i,j]表示在[i,j]这个区间下，只取i,j造成的误差。多处理一组s[0,i]和s[i,n+1]分别表示在这个区间中，0~i-1 和 i+1~n全都不取的误差。

顺着题目想，以取多少数为状态，那么可以设f[i,j]表示前j个数,一定取j的情况下，取了i个数造成的误差。

可以得到状态转移方程

f [ i , j ] : = min { f [ i - 1 , k ] + s [ k , j ] }
( f [ i , j ] <= e，i - 1 <= k < j )

法二：
····逆着题目想，以删了多少数为状态，设f[i,j]为前i个数，一定取i的情况下删了j个数造成的误差（风格和上面不大一样不过不影响啦）

但是这样更加复杂，因为在枚举k的过程中，s[k,i]的区间长度是在不断变化的，也就是这部分删去的数在不断变化，那么就不能用f[i-1,k]这么简单地来表示了

方程

f [ i , j ] : = min { f [ k, j - ( i - k - 1 ) ] + s [ k , i ] }
( f [ i , j ] <= e , i - j - 1 <= k <= i - 1 )

法三：（代码思路）
···先预处理
g[i][j]表示i-1点选和j+1点选，i~j这段区间的值
然后n^3dp
f[i][j]表示i点选了，总共选了j个的最小方案数

附上艰难踩点改完的AC代码…
部分灵感来自洛谷题解…

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll maxn = 110;
ll a[maxn], dp[maxn][maxn], z[maxn][maxn];
ll n, m;

int main()
{
	scanf("%lld%lld", &n, &m);
	for(ll i = 1; i <= n; ++i)
		scanf("%lld", a + i);
	for(ll i = 0; i <= n + 1; ++i)
		for(ll j = i + 1; j <= n + 1; ++j)
			for(ll k = i + 1; k <= j - 1; ++k)
			{
				if(i == 0)
					z[i + 1][j - 1] += abs(a[k] * 2 - a[j] - a[j]);
				else if(j == n + 1)
					z[i + 1][j - 1] += abs(a[k] * 2 - a[i] - a[i]);
				else
					z[i + 1][j - 1] += abs(a[k] * 2 - a[i] - a[j]);
			}
	memset(dp, 66, sizeof(dp));
	dp[0][0] = 0;
	for(ll i = 0; i <= n; ++i)
		for(ll j = 0; j <= n; ++j)
		{
			if(dp[i][j] <= m)
			{
				for(ll k = i + 1; k <= n + 1; ++k)
					dp[k][j + 1] = min(dp[k][j + 1], dp[i][j] + z[i + 1][k - 1]);
			}
			
		}
	for(ll i = 2; i <= n + 1; ++i)
	{
		if(dp[n + 1][i] <= m)
		{
			printf("%lld %lld", i - 1, dp[n + 1][i]);
			return 0;	//注意return 0的位置！！输出之后就return！！ 
		}
	
	}

}

T3 轻轨（USACO FEB09 Problem ‘shuttle’）

搜索原题又双叒找了半天…

题目描述

jzoj 1294 轻轨
在洛谷好不容易找到题…1607 庙会班车

有N（1<=N<=20,000）个站点的轻轨站，有一个容量为C（1<=C<=100）的列车起点在1号站点，终点在N号站点，有K(K<=50,000)组牛群，每组数量为M_i（1<=M_i<=N），行程起点和终点分别为S_i和E_i（1<=S_i<E_i<=N）
　　计算最多有多少头牛可以搭乘轻轨。

Input
　　第1行：3个空格隔开的整数K,N,C
　　第2到K+1行：描述每组奶牛的情况，每行3个空格隔开的整数S_i,E_i和M_i

Output
　　输出一个整数表示最多可以搭乘轻轨的牛的数量。

Sample Input
8 15 3
1 5 2
13 14 1
5 8 3
8 14 2
14 15 1
9 12 1
12 15 2
4 6 1

Sample Output
10
【样例说明】
　　轻轨从1号站搭2头牛到5号站，搭3头牛从5好站到8号站，2头牛从8号站到14号站，1头牛从9号站到12号站，1头牛从13号站到14号站，1头牛从14号站到15号站。

notes&keys

Clearly, any brute-force solution is going to be too slow,
and something more subtle is required.
Dynamic programming looks more promising,
but it seems that there are too many variables to keep track of
(we would need to keep a history of how many seats were available at what times).
How about just a greedy algorithm, taking more and more cows until no more will fit on the shuttle?
The obvious objection is that it matters which cows are taken - taking a cow from stop 3 to stop 5 is obviously better than taking a cow from stop 1 to stop 10.
So what about prioritising the groups?
Let’s say that Bessy is going from A to B (A < B) and Claire is going from C to D (C < D).
Obviously if A > C and B < D then Bessie should have higher priority.
It’s not clear what to do when the routes are not nested like this, but let’s see what happens if we prioritise cows by their target stop.
First, try it out on the sample test case. You’ll find that it gets the right answer.
At this point you should try to prove that this algorithm is correct.
This is an important step for any greedy algorithm, because in many cases what looks correct can and will be foiled by carefully constructed test cases.
In this case the proof is quite subtle, and will be left as an exercise for the reader.
Finally, we must find a way to quickly determine whether each cow can be added to the driving plan.
A simple approach is just to keep track of how many free seats there are on each leg of the journey (a leg being a hop from one stop to the next).
This is unfortunately a little too slow, so some optimisations are required.
A first optimisation is to keep track of the maximum number of groups that can start a journey at each given position and continue to the current point;
this makes each query (for the number of cows to take from each group) O(1).
Some further implementation tricks reduce the total cost of updates to O(Klog K + NC) rather than O(Klog K + N).
——Bruce Merry

我又双叒傻了…
附上巨佬的AC代码

/*
PROG: shuttle
LANG: C++
*/

#include <fstream>
#include <algorithm>
#include <queue>
#include <map>

using namespace std;

struct group
{
    int M;
    int S;
    int E;

    bool operator<(const group &b) const
    {
        return S < b.S;
    }
};

int main()
{
    ifstream in("shuttle.in");
    ofstream out("shuttle.out");
    int K, N, C;
    int ans = 0;

    in >> K >> N >> C;
    vector groups(K);
    for (int i = 0; i < K; i++)
        in >> groups[i].S >> groups[i].E >> groups[i].M;

    sort(groups.begin(), groups.end());

    map<int, int> off;      // number getting off at time t
    int total = 0;          // number on shuttle
    for (int i = 0; i < K; i++)
    {
        int pos = groups[i].S;
        map<int, int>::iterator p = off.begin();
        while (p != off.end() && p->first <= pos)
        {
            ans += p->second;
            total -= p->second;
            off.erase(p++);
        }

        off[groups[i].E] += groups[i].M;
        total += groups[i].M;
        p = off.end();
        --p;
        while (total > C)
        {
            if (total - p->second >= C)
            {
                total -= p->second;
                off.erase(p--);
            }
            else
            {
                p->second -= total - C;
                total = C;
            }
        }
    }
    ans += total;
    out << ans << "\n";
    return 0;
}

蒟蒻的思路与理解
部分来自某不知名大佬

！ 贪心！

like洛谷“凌乱的yyy”线段覆盖题
运用类似的贪心思路

1. 按右端点排序
2. 枚举k（哪拨牛上车）
   j <= c 且k的牛数>0（没上完车）
3. 枚举sit（若sit <= cow下车时间（？））
   则该牛可以坐在sit，更新sit标记，k的cow数-1，ans++
4. 往下枚举…

类似该思路的一段AC代码

#include<cstdio>
#include<algorithm>
using namespace std;
int k,n,c,car[50001],mi,ans;//car[i]表示经过第i个站时车上有多少牛
struct node{
    int s,e,v;
}cow[50001];
bool cmp(node a,node b) {return a.e<b.e;}
int main()
{
    scanf("%d%d%d",&k,&n,&c);
    for (int i=1;i<=k;i++)
        scanf("%d%d%d",&cow[i].s,&cow[i].e,&cow[i].v);
    sort(cow+1,cow+k+1,cmp);
    for (int i=1;i<=k;i++)
    {
        mi=2147483647;//int中最大值（？ 
        if (car[cow[i].s]>=c) continue;//如果当前车上的牛不能再多出空位了就跳过 
        for (int j=cow[i].s;j<cow[i].e;j++)
        {
            mi=min(c-car[j],mi);//我们当前坐的牛被这段路上car上的牛的数量约束 
            if (!mi) break;
        }
        if (mi>=cow[i].v)//如果剩下的位置比我们当前需要的位置多
        {
            for (int j=cow[i].s;j<cow[i].e;j++)
                car[j]+=cow[i].v;//我们就可以让car坐上cow.v头牛 
            ans+=cow[i].v;
        }
        else
        {
            for (int j=cow[i].s;j<cow[i].e;j++)
                car[j]+=mi;//否则我们最多坐mi头牛
            ans+=mi; 
        }
    }
    printf("%d",ans);
}

代码来自某不知名巨佬

T4 设计（USACO DEC05 GOLD）

搜索原题又双叒找了半天…然鹅没找到…

题目描述

jzoj 1295 设计
终于找到了洛谷链接…p4878 布局（加强版（？））
（洛谷最后三组hack卡图的连通性，
需要从0跑一遍spfa后， 再从1跑一遍spfa算具体最短数值）

和人一样，牛也喜欢站得离朋友较近的位置。-_-
FJ有N(2<=N<=1,000)头牛，编号为1…N,
现在要设计一个顺序让他们站成一排给他们喂食。
奶牛们按照编号顺序依次站立，允许有多只牛站在同一位置
（也就是说，牛i和牛j(i<j)的站立位置s_i,s_ j 一定满足s_i<=s_ j,如果s_i=s_ j,
那么编号为i到j之间的牛也一定站在s_i处）。
　　有一些牛相互喜欢，希望两人的距离在某个范围内，同样也有一些牛相互不喜欢，希望两人的距离大于等于某个距离，题目中给出ML(1<=ML<=10,000)个限制描述相互喜欢的情况，给出MD(1<=MD<=10,000)个限制描述相互不喜欢的情况。
　　你的任务是计算，如果存在某种方案满足上述要求，输出1号牛和N号牛之间最大距离。

Input
　　第1行：3个空格隔开的整数N,ML,MD。
　　第2到ML+1行：每行包含3个空格隔开的整数A,B和D，满足1<=A<B<=N,表示牛A和牛B之间的距离不得超过D(1<=D<=1,000,000)。
　　第ML+2到ML+MD+1行：每行包含3个空格隔开的整数A,B和D，满足1<=A<B<=N,表示牛A和牛B之间的距离至少为D(1<=D<=1,000,000)。

Output
　　如果不存在这样的方案，输出-1，如果牛1和牛N之间的距离可以任意，输出-2，否则输出最大的距离。

Sample Input
4 2 1
1 3 10
2 4 20
2 3 3

Sample Output
27
【样例说明】
　　最佳方案是1到4号牛依次放置于位置0，7，10，27

notes&keys

洛谷题解…

这个算法的时间复杂度是(N^3)，太慢了吧！ 纵观以上的方案，我们可以使用Warshall’s算法(?=floyd算法).实际上我们可以使用最短路实现。
题目中的限制条件可以改写为 Y<=X+c(对于相对的奶牛x,y和常量 c)
如果是不喜欢(TuT)的情况，c应该是个负数。
如果我们有这些限制 Y<=X+c 和 Z<=Y+d，那么我们可以得到一个新的限制
Z<=X+(c+d)，并且这可以和原来的限制合并在一起。
我们最终的目标 是编号为1&N 的牛的限制(即cown<=cow1+c).
所以我们应该去寻找 能产生这个式子的最小公式——也就是求最短路。
由于这里会有负权边，我们不能使用Dijkstra 求最短路╮(￣▽￣)╭。
于是我们使用能应对负权边的Bellman-Ford算法，时间复杂度为 O(N*(ML+MD))。
应对两种特殊情况的话:-
1:如果有负环的话，那么就是无解了 (Bellman-Ford有一种自动检测机制)（输出-1），
-2:如果最短路径为∞，那么这 就是可以无限拓展（输出-2）。
——by xkc

补充讲解：

巨佬博客讲解差分约束系统

纪中提供

定理:

典型的差分约束系统。

约束可转化为dis[x]-dis[y]>=c或dis[x]-dis[y]<=c
这就可以跑最短路了，把一个不等式成一个-1就能变号了。”

如果A和B距离至多为D则建边A->B权值为D，
距离至少为D则建边B->A权值为-D。
然后最短路。

补充:
为什么负环要输出-1?我们举一些反例。

这个图明显不对,2无法向3连向一条边,好的,下一个。

换成数轴:

是不是违反了j>=i定理。(画了一个无向图,sorry)

来再看一个:
这仍然是一个负环,我们仍然用数轴驳斥:

明显的是违背了小学数学。

什么时候输出-2?
1~n没有关系,n可以无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限无限放大。

另不知名巨佬讲解

设两牛为x， y

    喜欢: 从 x 到 y 小于等于 d,  即 x - y ≤ d

    不喜欢: 从 x 到 y 大于等于 d 即 x - y ≥ d

整理得到：
x - y ≤ d
y - x ≤ - d

然后邻接表存修改过的边，
（若为喜欢则将x， y， d加入图中， 若不喜欢则将x， y， -d加入）
SPFA求最短路

1. 输出-1：存在负权回路
2. 输出-2：为初始化的值（？）， 没有影响的

附上改了半天终于AC的代码…
部分灵感来源某不知名大佬…
spfa模板啥的一定要背！！

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1015;
const int maxm = 23333;	//注意数组大小！！ 
struct node
{
	int next, to, v;
}e[maxm];

int pre[maxn], dis[maxn], zz[maxn], rest[maxn];
int fro[1 << 20], cal, n;

void build(int x, int y, int z)
{
	e[++cal].next = pre[x];
	e[cal].to = y;
	e[cal].v = z;
	pre[x] = cal;
}

void spfa(int ss)
{
	memset(dis, 0x77f, sizeof(dis));
	memset(rest, 0, sizeof(rest));
	
	memset(fro, 0, sizeof(fro));
	int z = 1, w = 1;
	fro[1] = ss, dis[ss] = 0;
	for(int p = fro[z]; z <= w; p = fro[++z], zz[p] = 0)
		for(int a = pre[p], b = e[a].to; a; a = e[a].next, b = e[a].to)
			if(dis[b] > dis[p] + e[a].v)
			{
				dis[b] = dis[p] + e[a].v;
				if(!zz[b])
					fro[++w] = b, zz[b] = 1;
				if(++rest[b] > n)
					printf("-1\n"), exit(0);
			 } 
}

int main()
{
	int t, c, x, y, z;
	scanf("%d%d%d", &n, &t, &c);
	for(int a = 1; a <= n; ++a)
		build(0, a, 0);
	for(int a = 1; a <= t; ++a)
	{
		scanf("%d%d%d", &x, &y, &z);
		build(x, y, z);
	}
	for(int a = 1; a <= c; ++a)
	{
		scanf("%d%d%d", &x, &y, &z);
		build(y, x, -z);
	}
	spfa(0);
	spfa(1);
	if(dis[n] == dis[0])
		printf("%d\n", -2);	//cout比printf慢！！ 
	else
		printf("%d\n", dis[n]);

	return 0;
}

今天的题目着实令人头秃…
爆肝肝到21:55…
感觉有些部分还是值得推敲…（那么问题来了贾岛当年到底想用“推”还是“敲”？！）
今日比赛后边儿一个多小时实在是写不出来题了…还爆肝肝了洛谷几道往年noip真题啧
*总结起来就是秃头的头秃 元气满满的 爆肝到肝爆 十分充实的一天…(￣︶￣)

纪中DAY3…finished！