8.6 竞赛题目选讲

量力而行

8-10 抄书 (UVA 714)

把一个包含m个正整数的划分成k个(1<=k<=m<=500)非空的连续子序列，使得每个正整数恰好属于一个序列。设第i个序列的各数之和为S(i)，你的任务是让max{S(i)}最小，输出依次个数字最小的情况。

分析：我们现在将这m个整数分割成的区间的区间和的最大值设为x，根据这个x所能够最多分割出的区间个数我们记作P(x)，于是这个问题转化为求解的P(x)=k的最小解。

然后我们知道P(x)这个函数的值是随着x的增大而不严格递减的，也就是说我们可以通过求下界的二分查找法去得到我们的答案。

大致的思路如上，但是具体的细节还有很多需要补充的地方，比如在打印答案时，需要进行一个反向的贪心(注意进行贪心策略之前都需要数据满足贪心的条件)来确定分割的情况，细节和代码如下：

#include<iostream>
using namespace std;
typedef long long ll;
ll n,k,a[501],l=0,r=0;//l和r分别为二分的两个结点
//num(x)表示以x作为每个区间和的可允许的最大值,所得到的区间个数
int num(ll x){ll s=0,num_=1;//区间个数默认为1
//当确定新加的一个数会超过可允许的最大值时,就增加一个区间,此时新增加的区间默认已经放入新加的数 for (int i=0;i<n;i++) if (s+a[i]>x) {num_++; s=a[i];} else s+=a[i]; return num_;
}//如果有多解,要求是前面的区间和尽可能的小,所以应该选取的策略是从右往左倒着贪心
//这样可以保证后面的区间和尽可能地接近我们得到的每个区间和可允许的最大值
//当前面的数字出现不够按照贪心的策略分配的趋势,就直接将剩余的数字一一分配,保证第一个区间只有a[i]即可
void print_ans(ll x){ll s=0,num_=k; int is_sep[501]={0};//is_sep[i]表示第i个数字后面是否有分隔符 for (int i=n-1;i>=0;i--){//我开始没有注意到这个问题中贪心策略存在前提//就是说你每次进行贪心策略前剩余的数字个数需要满足剩余的区间里至少可以每个区间分配一个数字//num_表示剩余的区间个数,i+1表示剩余的数字个数,当剩余的区间个数大于剩余的数字个数时//就需要将当前的区间结束(不再添加新数,此时剩余区间个数和剩余数字个数相等),然后一一分配 if (num_>i+1) {is_sep[i]=1; num_--;}//一一分配 else if (a[i]+s>x) {is_sep[i]=1; num_--; s=a[i];}//和前面一致的反向贪心 else s+=a[i]; }for (int i=0;i<n;i++) { cout<<a[i]<<" "; if (is_sep[i]) cout<<"/ ";}
}//我这里原本是考虑将l直接定义为0,看了别人的题解意思是如果直接定义为0做二分的话会有一点点超时
int main(){ cin>>n>>k; for (int i=0;i<n;i++) {cin>>a[i]; l=max(l,a[i]); r+=a[i];}//注意这里的二分法,是在有多个解时,求下界的二分查找法,所以得到应该是最小的区间和 while (l<r){ll m=(l+r)/2; (num(m)>k)?l=m+1:r=m;       }print_ans(l); return 0;
}

8-11 全部相加 (UVA 10954)

给你n个数的一个集合S，每次从集合S中删除两个数，然后将这两个数的和放回集合，直到剩下最后一个数。每次操作的开销等于被删除的两个数字之和，求最小的总开销。

分析：这个就是求Huffman编码的过程，有若干个数每个数都有一个值(Huffman编码里面是频率)，然后将任意两个树相加合并成一颗新的树，越下层的结点被加的次数越多。于是我们模仿Huffman编码的建立进行编写就可以了，代码如下：

#include<iostream>
#include<queue>
using namespace std;//这里不建立二叉树,而是通过优先队列每次取当前最小的两个数
int main(){int n,x,ans=0; cin>>n; priority_queue<int,vector<int>,greater<int> >q;for (int i=0;i<n;i++) {cin>>x; q.push(x);}for (int i=0;i<n-1;i++){//取当前最小的两个数出来 int a=q.top(); q.pop(); int b=q.top(); q.pop();ans+=a+b; q.push(a+b);//将和构成一个新数放入队列中 }cout<<ans; return 0;
}

8-12 奇怪的气球膨胀 (UVA 12627)

一开始有一个红气球。每小时后,一个红气球会变成3个红气球和一个蓝气球,而一个蓝气球会变成4个蓝气球。我们需要得到的是k个小时后，第A-B行一共有多少个红气球。

分析：来，我问一下大家，有谁能在下面这个图看得出来气球的排列是怎么随着时间变化的。

(我真的没有自己调色，他真的原本就是这样的，这谁他妈搞得清是怎么变化的啊)

然后在我依旧还没有确定过四级的英语阅读下，大概体会了一下意思。就是说从第i-1到第i个小时，气球从2^i-1*2^i-1的规模扩展到2ⁱ*2ⁱ的规模，2^i-2*2^i-2中的每一个小方格扩展成2*2的四个方格，扩展的方法就和体面所叙述的相同。

于是我们可以简单的了解到，k小时的情况由4个k-1小时的情况拼接起来，于是我们可以通过k-1时的情况来推测k情况的值。

设f(k,i)表示k小时之后最上面i行的红气球总数(i<=0时，f(k,i)=0)，于是所求的答案为f(k,b)-f(k,a-1)。

那么如何递归求解f(k,i)呢？我们需要知道第k个小时的前i行红气球总数分别由什么组成，如果i<2^k-1，k小时的情况由4个k-1小时的情况拼接起来(这句话不准确，准确来说应该是除了右下角的四分之一个大方格全都是蓝色的气球，其他的和k-1的情况的方格是完全一样的)，也就是说i<=2^k-1，k小时的前i行就相当于两个k-1小时的大方格并排合并在了一起的前i行的方格个数，于是有f(k,i)=2*f(k-1,i)。

同理，当i>2^k-1时前i行的红气球个数，除了有2倍的k-1小时情况所有的红气球个数，还有下面一个大方格中，前i-2^k-1行的红气球个数，于是有f(k,i)=f(k-1,i)+2*3^k-1(第k个小时红气球的总个数就是3^k)。

总结一下，i<=2^k-1时，f(k,i)=2*f(k-1,i)；i>2^k-1时，f(k,i)=f(k-1,i)+2*3^k-1。f(k,i)表示k小时之后最上面i行的红气球总数(i<=0时，f(k,i)=0)，求解f(k,b)-f(k,a-1)。

代码比较简单，就不着重去写了。

8-13 环形跑道 (UVA 11093)

环形跑道上有n个加油站，编号为1~n。第i个加油站可以加油pi加仑。从加油站i开到下一站需要qi加仑汽油。你可以选择一个加油站作为起点，起始油箱为空(但可以立即加油)。你的任务是选择一个起点，使得可以走完一圈后回到起点。假定油箱中的油量没有上限。如果无解，输出Not possible，否则输出可以作为起点的最小加油站编号。

(这里有一个条件没有翻译清楚，就是这个走完一圈的意义就是按照环形序列的顺序走完一圈)。

分析：这道题看一下数据范围就知道O(n²)的方法都过不了，我们现在考虑从1号加油站出发开始模拟，到第k个加油站不能继续下去(如果模拟直接成功直接输出答案就好了)，也就是说满足一下条件：

p1>=q1
p1+p2>=q1+q2
p1+p2+p3>=q1+q2+q3
······
p1+p2···+p(k-1)>=q1+q2···+q(k-1)
p1+p2···+pk<q1+q2···+qk

我们将第k个不等式与上面的式子进行减肥就可以得到以下的条件：

p2···+pk<q2···+qk
p3···+pk<q3···+qk
·······
p(k-1)+pk<q(k-1)+qk
pk<qk

一共有k-1个式子，我们对第i个式子进行分析，就可以发现我们可以根据第i个式子推测出我们无法从第i+1个加油站出发，因为此时一定会在第k个加油站停下。

于是有1-k的加油站都不能作为起点，我们继续以k+1作为起点继续往下遍历即可。难的在思路上，代码同样比较简单，就不着重介绍了。

8-14 与非门电路 (UVA 1607)

题面请点击这里

分析：已经过分到样例都不给了，然后我去了UVA的网站上面找了这道题结果发现看了原题的题面之后还是看不懂，于是就先放在这里吧。

8-15 Shuffle的播放记录 (UVA 12174)

音乐播放器有一个所谓乱序播放功能，假设一共有s首歌，一开始会给这些歌随机排序，全部播放完毕后再随机排序，继续播放，以此类推。注：当s首歌播完前不会重新排序，所以播放记录里每s首歌都是1~s的排列

分析：这个题是我自己的问题了，我真的读不懂这道题是什么意思。。。

8-16 不无聊的序列 (UVA 1608)

如果一个序列的任意连续子序列都至少有一个元素唯一，则称这个序列“不无聊”，否则称这个序列“无聊”。给定T个序列，求是否“无聊”。

分析：这道题洛谷上依旧没有给出题面和样例，但所幸这道题介绍的还算比较清晰。数据应该挺大的，应该不能用类似于前缀和的方法去处理。于是考虑分治：如果一个序列中不存在任何一个元素唯一，那么这个序列肯定是无聊的，对于一个长度大于1的序列，我们寻找这个序列中唯一的元素，然后以这个元素作为界限分成两个序列分别判断是否无聊。

这里寻找唯一的元素存在两个技巧，第一就是如果单一地从左到右或者从右到左进行查找，可能会出现比较极端的情况，于是我们同时从两边进行一个双向的查找来避免极端的情况。

同时这里判断在区间内是否唯一，也可以用上一章节唯一的雪花那个问题中的第二个解法进行简化(为了防止大家忘了，我把代码复制了过来)。

#include<cstdio>
#include<map>
using namespace std;
const int maxn=100005;
int n,a[maxn],last[maxn];//last[i]表示下标为i的元素在序列中上一个相同元素的下标
map<int,int>value_cur;//cur表示value在序列中最后出现的位置
int main(){scanf("%d",&n);for (int i=0;i<n;i++){scanf("%d",&a[i]);//更新last的值,如果之前从来没有出现过,last的值为-1 (!value_cur.count(a[i]))?last[i]=-1:last[i]=value_cur[a[i]];value_cur[a[i]]=i;//更新元素值出现的最后位置 } int l=0,r=0,ans=0;//前面的部分是差不多的 while (r<n){ while (r<n&&last[r]<l) r++;//这里大家仔细想一下和前面是一样的 ans=max(ans,r-l); l++; } printf("%d",ans); return 0;
}

就是找一个位置的元素左边最近的相同的元素，在这个问题中，我们可以同时找左边最近的相同的元素和右边最近的相同的元素具体操作如下：

int main(){cin>>n;//last[i]=-1和next[i]=0x3f分别表示第i个元素左边和右边没有相同元素memset(next,0x3f,sizeof(next)); memset(last,0,sizeof(last));for (int i=0;i<n;i++){cin>>a[i];//m.find(a[i])!=m.end()表示这个元素在前面遍历过的序列中已经出现过一次了//当重复的元素在后面的遍历中又出现了一次会影响前一次出现元素的next值和当前元素的last值//当前元素的last值就变为当前序列中该元素值最后出现的位置(m.find(a[i])->second)//前一次出现元素的next值就会变为当前出现元素出现的位置 //需要注意的是,我们每次新添加一个元素,这个元素的右边一定不存在和它相同的元素 if (m.find(a[i])!=m.end()){last[i]=m.find(a[i])->second;next[m.find(a[i])->second]=i;} else last[i]=-1; m[a[i]]=i;} return 0;
}

分治法如下和通过last和next的值确定是否唯一的方法如下：

//分治法(中途相遇法)
bool is_boring(int l,int r){ if (l>=r) return true; int i=l,j=r;while(i<=j){//为了避免教坏的情况,比如从最左(右)开始找,唯一元素在最右(左)//我们这里使用中途相遇法,从两边同时开始找该区间代表的序列中唯一的元素//这里唯一的元素需要满足的是,该元素前(后)一个相同的位置小于区间的最左(右)端//找到了唯一元素之后,该序列的"无聊性"就可以分割为两段子序列的"无聊性" if(last[i]<l&&next[i]>r) return is_boring(l,i-1)&&is_boring(i+1,r);if(last[j]<l&&next[j]>r) return is_boring(l,j-1)&&is_boring(j+1,r); i++; j--;} return false;
}

完整代码如下：

#include<iostream>
#include<cstring>
#include<map>
using namespace std;
const int maxn=200005;//last[i]和next[i]分别表示第i个元素左边和右边最近相同元素的位置
int n,a[maxn],last[maxn],next[maxn];
map<int,int>m;//m表示某个值在目前序列中最后出现的位置
//分治法(中途相遇法)
bool is_boring(int l,int r){ if (l>=r) return true; int i=l,j=r;while(i<=j){//为了避免教坏的情况,比如从最左(右)开始找,唯一元素在最右(左)//我们这里使用中途相遇法,从两边同时开始找该区间代表的序列中唯一的元素//这里唯一的元素需要满足的是,该元素前(后)一个相同的位置小于区间的最左(右)端//找到了唯一元素之后,该序列的"无聊性"就可以分割为两段子序列的"无聊性" if(last[i]<l&&next[i]>r) return is_boring(l,i-1)&&is_boring(i+1,r);if(last[j]<l&&next[j]>r) return is_boring(l,j-1)&&is_boring(j+1,r); i++; j--;} return false;
}
int main(){cin>>n;//last[i]=-1和next[i]=0x3f分别表示第i个元素左边和右边没有相同元素memset(next,0x3f,sizeof(next)); memset(last,0,sizeof(last));for (int i=0;i<n;i++){cin>>a[i];//m.find(a[i])!=m.end()表示这个元素在前面遍历过的序列中已经出现过一次了//当重复的元素在后面的遍历中又出现了一次会影响前一次出现元素的next值和当前元素的last值//当前元素的last值就变为当前序列中该元素值最后出现的位置(m.find(a[i])->second)//前一次出现元素的next值就会变为当前出现元素出现的位置 //需要注意的是,我们每次新添加一个元素,这个元素的右边一定不存在和它相同的元素 if (m.find(a[i])!=m.end()){last[i]=m.find(a[i])->second;next[m.find(a[i])->second]=i;} else last[i]=-1; m[a[i]]=i;}if(is_boring(0,n-1)) cout<<"non-"; cout<<"boring"<<endl; return 0;
}

8-17 不公平竞赛 (UVA 1609)

n支队伍(n是2的整数幂)打淘汰赛，每轮都是两两配对，胜者进入下一轮。每支队伍的实力固定(“实力固定”是指：例如，队伍1曾经胜过队伍2，则二者在今后的交锋中队伍1总获胜)，并且已知每两支队伍之间的一场比赛结果。

你喜欢1号队，虽然它不一定是最强的，但是它可以直接打败其他至少一半的队伍，并且对于每支1号队不能直接打败的队伍T，总是存在一支1号队能直接打败的队伍S使得S能直接打败T。问是否存在一种比赛安排，使得1号队夺冠？

分析：这准确来说并不是一道编程题，而是一道关于数学的问题。书上提供了这样一种策略。

首先将除了1号队以外的队伍进行标记，白色的队伍为1无法打败的队伍，黑色的队伍为至少可以打败一支黑色的队伍但不能打败1号队的队伍，灰色的队伍表示1号队可以打败的队伍(这个队伍可以是黑色，但一定不能是白色)。

阶段一：尽量“消灭”白色队，就是对于一个白色队，安排一个能够打败他但是还没有安排对手的黑色队。依次配对后，可能还会剩余一些白色和黑色的队伍没有进行配对。

阶段二：给1号队挑选一个灰色的队伍击败，这个一定能够选到，因为1号队至少能够击败一半的队伍，也就是说灰色的队伍的数量一定比白色的要多，不可能在阶段一全部被消耗掉。

阶段三：将剩下的白色队伍任意配对，无论输赢。如果剩余的白色队伍个数为偶数，那就一一配对，如果是奇数的话，多余的一只白色队伍和剩余的灰色队伍随意配对。

三个阶段下来，白色队至少消灭了一半，并且队伍总数减少了一半，也就是说在人数少了一半的第二轮，仍满足第一个条件(1号队至少能够击败一半的队伍)。

至于第二个条件(对于每支1号队不能直接打败的队伍T，总是存在一支1号队能直接打败的队伍S使得S能直接打败T)，我们仔细观察阶段一的配对，阶段一的配对是拿黑色队和白色队两两配对，根据题目给的条件，我们可以知道对于任意一支白色队，一定至少存在一支黑色队可以击败他且能被1号队击败。那为什么还可能有剩余呢？因为对于不同的白色队，可以击败它的黑色队可能是一支队，也就是说可能有若干支黑色队能够击败很多的白色队。如果此时阶段一选中的黑色队，不能满足条件2，也就是说一定在外面至少存在一支黑色队可以击败阶段一之外的白色队。那么在阶段一尽量“消灭”白色队时，为什么不将这些黑色队和白色队两两配对呢？于是就产生矛盾了。

说明根据以上策略，队伍减少了一半的情况下，依旧可以满足两个条件。我们可以将问题简化到只剩下两只队伍，由于阶段2，1号队一定是其中之一，再根据条件一，1号队一定能够击败至少1支队伍，也就是队首，于是一号队在这种策略下就可以夺冠了。

8-18 洞穴 (UVA 1442)

一个洞穴的宽度为n个片段组成，已知位置[i,i+1]处的地面高度pi和顶的高度si，要求在这个洞穴里储存尽量多的燃料，使得在任何位置燃料都不会碰到顶(但可以无限接近)。

分析：需要注意的是，这里的所有燃料都需要静止存放。这个题比较简单只需要从左到右和从右到左扫描一遍确定一段区间两边可有的最高水位即可。

8-19 贩卖土地 (UVA 12265)

输入一个n*m的矩阵，.代表的格子是空地，#代表沼泽。对于每一个空地格子，求出以它为右下角的空矩阵的最大周长，最后统计每个周长出现了多少次。

分析：首先可以确定的是，我们的思路是按照从上到下的顺序处理每一行，在每一行中从左到右的处理的每个格子。对于一个固定的右下角我们可以再确定一个左上角来得到一个矩形，那么问题就转化为怎么得到这个左上角。

我找了一遍发现网上没有书上那个例子于是我决定强行手打一下(请歌颂我)：

XXXXOXX
XXXXOXX
XOXOOXX
XOXOOOX
XOOOOOX
OOOOOOX
OOOOOOO

为了方便大家看的比较清楚，这里的X表示沼泽地，O表示空地，最底下的一行为我们当前固定的一行，接下来我们依次求解最下面一行每个空地格子作为右下角对应最优矩形左上角的格子：

第一个格子：

X
X
X
X
X
1
O

这个答案很显然，左上角的格子一定是我们标记为1的位置(标记有数字的格子即是可能为答案的格子)。

第二个格子：

XX
XX
X2
XO
XO
1O
OO

这个答案也较为显然，对于前一列而言1是最有可能为答案的格子，对于当前第二列2是最有可能为答案的格子，比较后左上角的格子为标记为2的位置。

第三个格子：

XXX
XXX
XPX
XPX
X2O
1OO
OOO

这里和前面就有了一定的区别，大家发现没有标记为3的格子，因为标记为3的格子(每次当前列的格子是确定的，一定为当前列最高的格子)的高度仅为3，此时第二列的格子的高度就受到了限制，最高只能达到和3一样的高度，但对于同样的高度，显然第二列比第三列的格子作为左上角的格子更有优势，于是3就没有被标记上数字。左上角的格子还是标记为2的格子，P表示空地但是不能够作为左上角的格子。

第四个格子：

XXXX
XXXX
XPX3
XPXO
X2OO
1OOO
OOOO

由于这里3位置的格子的列数减去2位置的格子的列数小于等于3的高度减去2的高度，所以3位置可以被标记上数字(这句话就是判定何时对最优解进行更替的关键)，但我们不对最优解进行更新，因为同样的周长下，高度低的优先考虑(防止被消去)。于是左上角的格子还是标记为2的格子。

第五个格子：

XXXX4
XXXXO
XPX3O
XPXOO
X2OOO
1OOOO
OOOOO

由于这里4位置的格子的列数减去2位置格子的列数小于4位置格子的高度减去2位置格子的高度，于是最优解从2转变为4。

第六个格子：

XXXXPX
XXXXPX
XPXPPX
XPXOOO
X2OOOO
1OOOOO
OOOOOO

第六个格子的高度直接砍去了第五个格子的最优解4，最优解回到2的位置。

第七个格子：

XXXXPXX
XXXXPXX
XPXPPXX
XPXPPPX
XPPPPPX
PPPPPPX
1OOOOOO

直接全部削没了。

根据上面的模拟过程，我们知道首先需要将当前行每一列向上的最大延伸高度给求出(这个延伸高度我们可以通过上一行对应列的最大延伸高度+1或者直接变为0得到)。

接下来根据当前列的最大延伸高度删除前面标记有数字的方格，因为观察可以发现，所有标记为数字的格子的高度一定随着列数的增大而严格递增，也就是说前面数字的格子的高度一定不可以大于当前行的格子高度。并且编号大的格子比起编号小的格子需要满足，编号大的格子的列数减去编号小的格子的列数小于编号大的格子的高度减去编号小的格子的高度(因为有编号的格子都是满足可能为最优解的格子，编号大的格子的高度比编号小的格子的高度要大，就是更容易被“砍去”，如果不满足前面的条件那么只要那个编号小的格子还存在，这个编号大的格子一定没有成为最优解的机会，并且这个编号大的格子更容易被“砍去”，也就是说这个编号大的格子添加进“编号点集”没有任何的意义)。

得到当前的最优解，计算出答案用计数排序的方法统计就可以了。

代码如下(大致思路和上面没区别，不过还是有一些细节)：

#include<cstdio>
#include<algorithm>
using namespace std;//ans->计数排序,h数组表示某格子向上的最大衍生高度,size表示每行单调栈的长度
int n,m,max_ans=0,ans[2021]={0},h[1010]={0},size;//max_ans表示最大长方形的周长
struct node{ int h,c;//c为列数,h为高度都默认为0 node(int _h=0,int _c=0){h=_h; c=_c;}
}s[1010];//单调栈,里面的h和h-c的值都随c的增大而增大排列,s[size]表示最优解
char p[1010][1010];
int main(){scanf("%d%d",&n,&m); for(int i=0;i<n;i++) scanf("%s",p[i]);for (int i=0;i<n;i++){size=0;//首先更新每一行每一列格子的最大衍生高度//,如果是#,那高度显然为0,如果是.就在上一行同列的基础下+1 for (int j=0;j<m;j++) h[j]=(p[i][j]=='.')?h[j]+1:0;for (int j=0;j<m;j++){node v(h[j],j);//当前列最上方的格子 while(size&&s[size].h>=h[j]) v.c=s[size--].c;//去除所有h大于等于当前格的标记有数字的方格//由于对于相同的高度,越左列的格子越有优势,所以相当于将当前列最上方的格子向左移 //保持h单调性的基础下,确定是否保持h-c的单调性//编号大的格子与编号小的格子的列数差小于编号大的格子与编号小的格子的高度差 if(v.h&&(!size||(v.h-v.c)>(s[size].h-s[size].c))) s[++size]=v;if (p[i][j]=='.') {int len=j-s[size].c+s[size].h+1;//最优解周长的一半ans[len]++; max_ans=max(max_ans,len); } }  } for(int i=1;i<=max_ans;i++) if(ans[i]) printf("%d x %d\n",ans[i],i*2); return 0;
}

感谢lrj，感谢题解。