The 8th Zhejiang Provincial Collegiate Programming Contest

 

浙大第八届省赛……

 

Solved	ID	Title	Ratio (AC/All)
Yes	A	Ordinal Numbers	51.24% (413/806)
Yes	B	Conic Section	29.45% (291/988)
	C	Old Labels	5.26% (6/114)
Yes	D	String Successor	15.50% (198/1277)
	E	Wall-nut Bowling	0.00% (0/13)
Yes	F	Kagome Kagome	55.55% (345/621)
	G	Palm Up and Palm Down	10.52% (4/38)
	H	BCD Code	15.90% (7/44)
	I	Lego Bricks	10.20% (5/49)
	J	Assignment	12.19% (10/82)
	K	Mistwald	10.97% (46/419)
Yes	L	Javabeans	46.88% (339/723)
Yes	M	Median	51.83% (381/735)

 

总体还算可以……2小时做完6道， 卡在 K 题了。 后面的3小时眼看排名不断下降……额

首先分析一下我们做出来的6道题目, 其他7道有待更新~~~

 

题目:  

A	Ordinal Numbers

 

解析: 给你一个数字,  转成 序数 + th , st , nd ,rd 

 

代码,没什么好说的,一遍过^_^ ! 秒杀！！！

 

//没什么好说的,直接按题目要求来, //处理一下特殊的后缀就可以了 #include <stdio.h> #include <stdlib.h> int main() { int N,M; scanf("%d",&N); while(N--) { scanf("%d",&M); int first=M%10; int second=(M/10)%10; if(second!=1) { if(first==1) printf("%dst/n",M); else if(first==2) printf("%dnd/n",M); else if(first==3) printf("%drd/n",M); else printf("%dth/n",M); } else { printf("%dth/n",M); } } return 0; }  

题目: 

B	Conic Section

 

 

但是看到这数学的图形就怕了,果断先放着! 不过后来看到很多人A了,所以就随便看了下,

没想到这么简单!! 没什么好说的,表示一遍过^_^，秒杀！！！

 

// 待定式： ax2+bxy+cy2+dx+ey+f=0 /* ** 因为题目要求: It's guaranteed that a2+c2>0, b=0, ** the conic section exists and it is non-degenerate. ** ①b=0 ，那就不用考虑b了，呵呵，题目有点…… ** ②即给出的式子,即使不是标准型,但是可以通过非退化转换成标准型,也是可以的 ** 相信学过线性代数的人都知道什么叫非退化吧??? */ // 四种类型 // circle x^2+y^2=a^2 // ellipse x^2/a^2+y^2/b^2=1 // parabola y^2=4ax // hyperbola x^2/a^2-y^2/b^2=1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { int t; double a,b,c,d,e,f; scanf("%d",&t); while(t--) { scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f); // 下面的解释,只要自己在纸上画一画,都应该理解吧 //circle 的情况, 只要 x^2 的系数等于 y^2 的系数，且都不为0 //d,e,f不管是多少，都可以通过非退化表示成圆方程 if(a!=0&&c!=0&&a==c) printf("circle/n"); //ellipse 的情况, 只要 x^2 的系数不等于 y^2 的系数,且都不为0 //并且都是正的就通过非退化表示成椭圆方程 else if(a!=0&&c!=0&&a!=c&&a*c>0) printf("ellipse/n"); //parabola 的情况, 只要 x^2 的系数或 y^2 的系数有一个等于0,一个不等于0 //且二次项系数为0的变量,其一次项系数必须不为0,那么就可以……hehe //PS:这里一定要注意喽！！！ // 不仅仅只是 y^2=4ax 的情况， x^2=4ay 也是可以通过非退化转换成标准型 y^2=4ax else if((a==0&&c!=0&&d!=0)||(a!=0&&c==0&&e!=0)) printf("parabola/n"); //hyperbola的情况, 只要 x^2 的系数 和 y^2 的系数 一正一负,且不为0就可以 // 通过非退化转换 else if(a!=0&&c!=0&&a!=c&&(a*c)<0) printf("hyperbola/n"); } return 0; }  

 

 

题目:

D	String Successor

 

一道模拟题,当时的时候, 把题目看错了,献出了2次WA,(Add an additional alphanumeric to the left of the leftmost alphanumeric if necessary,就这句话。。误以为是前面没东西加了,就在最左边（就是开头位置）加上一个) ，其实是在最左边的数字字母前面加一个

 

//C++ 的 STL 水过…… #include <iostream> #include <cstdio> #include <algorithm> #include <vector> #include <string> #include <cstdlib> #include <map> #include <queue> #include <stack> #define inf 0x3f3f3f3f using namespace std; string str; int main() { int T; int num; int i,j; int mak; int flag; int k; cin>>T; while(T--) { cin>>str>>num; for(i=1;i<=num;i++){ int len=str.size(); //因为有可能长度会变 flag=1; //表示前面的数是否继续加 mak=0; //标记最左边的数字字母的类型 k=0; //标记最左边的数字字母的位置 //下面就是实现 for(j=len-1;j>=0&&flag;j--){ if(str[j]>='0'&&str[j]<='9') { str[j]+=flag; if(str[j]>'9') str[j]='0'; else flag=0; mak=1; k=j; } else if(str[j]>='a'&&str[j]<='z') { str[j]+=flag; if(str[j]>'z') str[j]='a'; else flag=0; mak=2; k=j; } else if(str[j]>='A'&&str[j]<='Z') { str[j]+=flag; if(str[j]>'Z') str[j]='A'; else flag=0; mak=3; k=j; } } //这里就是最前面没有数字字母可以增加了 //那么就要在最左边的数字字母前面加一个 // string 的insert 直接实现 if(flag) { if(mak==0) { str[len-1]++; } else if(mak==1) { string::iterator it; it=str.begin(); str.insert(it+k,'1'); } else if(mak==2) { string::iterator it; it=str.begin(); str.insert(it+k,'a'); } else if(mak==3) { string::iterator it; it=str.begin(); str.insert(it+k,'A'); } } cout<<str<<endl; } cout<<endl; } return 0; }  

 

 

 

题目： 

F	Kagome Kagome

 

氺题一道……一遍过，秒杀！！！

 

// 因为n个人是围成一个环的, // 所以只要看他前面的人是谁 除2 就知道他后面的人是谁了 #include <iostream> #include <cstdio> #include <algorithm> #include <vector> #include <string> #include <cstdlib> #include <map> #include <queue> #include <stack> #define inf 0x3f3f3f3f using namespace std; int main() { int T; int N; string front; int x; map<int,string>g; scanf("%d",&T); while(T--) { g.clear(); cin>>N>>front; string str; for(int i=1;i<=N;i++){ cin>>str; g[i]=str; if(str==front) x=i; } int n=N/2; x+=n; if(x>N) x-=N; cout<<g[x]<<endl; } return 0; }  

 

 

题目： 

L

Javabeans

 

氺题，一遍过！秒杀！！！

 

// 找规律, 看n 是正好大于 2^i 2的 i 次方 i+1 就是答案 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #include<ctype.h> #define INF 0x7fffffff int main() { int t,n,i; scanf("%d",&t); while(t--) { scanf("%d",&n); for(i=30;i>=0;i--) if(n>=(1<<i)) break; printf("%d/n",i+1); } return 0; }  

 

 

题目： 

M

Median

 

 

排序，输出中间那个数就可以了，如果中间有2个数，就 加起来除 2 

这题太水了，秒杀！！！

 

 

#include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #include<ctype.h> double a[1000]; int cmp(const void*a,const void*b) { return *(double *)a>*(double *)b?1:-1; } int main() { int t,n,i; scanf("%d",&t); while(t--) { scanf("%d",&n); for(i=0;i<n;i++) scanf("%lf",&a[i]); qsort(a,n,sizeof(a[0]),cmp); if(n%2) printf("%.3lf/n",a[(n)/2]); else printf("%.3lf/n",(a[n/2-1]+a[n/2])/2); } return 0; }  

 

其他7道，更新中………………

下面是出题人的题解：

 

C	Old Labels

 

 C  Old Labels

         刚见到这个题时，我读得不太懂。事实上是这样的，给定一棵有根树。建立一个trie树。（每个节点有标号从0开始标，同一个节点的孩子标号不能相同）。这样从根到每个叶子都有一条路径，每个路径可以理解为一个字符串（或者说就是vector<int>），把这些字符串都排好序，形成一个字符串的有序集合。求一种标号方式，使得这个字符串集合的字典序最小。字符串集合的字典序定义为两个排好序的字符串集合中从小到大对每个字符串以字典序比大小，直到比出来为止。

         做法就是递归地做，假设以某节点的所有孩子为根的子树都已经标好了（这些子树的根没标号），那么这个节点连接孩子时应该怎么标号？显然，较“小”的孩子标号比较小，于是问题转变为对它所有孩子为根节点的子树排序。其实就是对树排序。一棵树其实就是一堆路径（字符串）的集合，即从它的根（虽然还没标号）到其全部叶子的那些路径，都由小到大排好序。但这时，比较两棵树不是用普通的字典序了，因为假设一棵树A包含了树B的全部的字符串，而A比B包含的字符串更多，而A,B的根具有共同的父亲C,则C应该给A的根更小的标号。也就是说，在没比出来的情况下，先结束的树（路径比较少的）应该排在后面。其实就是相当于给每棵树附加了一个字典序无穷大的串，再按字典序比较。然后就可以直接做了。

         最初我用vector<vector<int>  >保存了一棵树的全部路径。然后当它父亲给孩子标号的时候，在每条路径前面加一个标号，并把全部孩子的路径都存到父亲节点的vector<vector<int> >下。对孩子排序实际上就是对其存放的vector<vector<int> >排序，这样做是最直接暴力的,但验证时MLE了……其实在一个孩子的所有路径加上前面的那个标号并存入父亲的vector<vector<int> >的时候，这个孩子本身的那个vector<vector<int> >已经没用了，于是我在这时把孩子的那些vector都清空。结果是可以通过的，但是比较慢。

         后来我没有保存路径。假设现在要计算节点x, 节点x的孩子在二维数组con[x][]里面。则我现在需要对con[x][0]..con[x][d[x]-1]排序。（d[x]是节点x的度）。其实排序就用algorithm库里的sort函数即可。问题就是那个cmp函数怎么写。（就像每个问题最关键的gao()函数怎么写一样^_^） 这个cmp比较复杂，而且因为没保存路径，所以是递归的……其实也是相当的暴力。比较两棵树a,b那么我就沿着a递归地枚举a的所有路径（从根到叶子），然后a那边标号怎么走b那边沿同样沿着标号这样走。如果在走路的过程中，一方已经结束了（路径短），则路径短的那方小（这个就是字符串的字典序）。如果路径始终都一样，但是一方的路径多，则路径多的那一方小（前已叙述过）。

         如此我们就对x的所有孩子排好序了。然后顺着给每个孩子标号0..d[x]-1就可以了。最后，从根再遍历一次全树，记录下来所有路径就行了。路径条数等于树叶个数。

 

 

 

E	Wall-nut Bowling

 

E  Wall-nut Bowling

         我认为最难的题。Vls在这次出的3道题中，两道计算几何，一道dp。这题和另外那个dp都算得上难题了。题目背景很有趣，植物大战僵尸，但假设僵尸不动。用坚果打僵尸，撞到上下边界以45度角反射，撞到僵尸也会45度反射，僵尸可以看作点。因为题目规模很大，直接模拟反射来反射去的很麻烦。所以一个好办法是，把反射轨道上的点连起来。这样通过不断next，找到所有被击中的点。思路是如此的简单，但是做起来是如此的麻烦。

定义坐标系，就按题目说的吧x水平向右,y竖直向下，另外可以把坐标(x,y)都减小1，让它们从0开始。同时把n也减少1，这样y的范围是[0..n]。关键一点是轨道上的点，无论怎么反射在上边界（或者说下边界）的截距是对n*2 取模是相同的。这样可以用n*2的数组把“截距”相同的点都存好。

按x从大到小处理。要使得某个点的下一个点恰好能知道。很麻烦，在上下边界的点y=0,y=n的next点是唯一的，所以它们比较好连。而普通的点，可能朝上，也可能朝下。我的做法是建立两个“假点”，一个在上边界，一个在下边界，当“碰到”上边界的“假点”时，实际上它的next应该是下边界对应的那个“假点”的next(因为根本碰不到上边界的假点，直接反到下边界去了)，同理，“碰到”下边界的假点时，next值应该是上边界对应的八个假点的next。所有点都用双向链表连起来。代码太长了，就不全贴了。有兴趣的可以找我要代码，不过，还是建议自己写，很锻炼的……我只贴一下我建立链表的代码，这个也不短了。

                --a[i].first;

                            --a[i].second;

                            b[numb].prev=0;

                            b[numb].next=line[y=a[i].second];

                            b[numb].num=i-j;

                            b[numb].y=y;

                            if (line[y]) {

                                     line[y]->prev=&b[numb];

                            }

                            line[y]=&b[numb];

                            if (a[i].second==0) {

                                     uplist[numu].prev=uplist[numu].other=0;

                                     uplist[numu].next=list[x=a[i].first%M];

                                     uplist[numu].at=&b[numb];

                                     if (list[x]) {

                                               list[x]->prev=&uplist[numu];

                                     }

                                     b[numb].up=b[numb].down=list[x]=&uplist[numu];

                                     ++numu; 

                            }

                            else if (a[i].second==n) {

                                     downlist[numd].prev=downlist[numd].other=0;

                                     downlist[numd].next=list[x=(a[i].first+n)%M];  //截距

                                     downlist[numd].at=&b[numb];

                                     if (list[x]) {

                                               list[x]->prev=&downlist[numd];

                                     }

                                     b[numb].up=b[numb].down=list[x]=&downlist[numd];

                                     ++numd;

                            }

                            else {

                                     ux=a[i].first+a[i].second;   //上假点的截距

                                     dx=n-a[i].second+a[i].first;  //下假点的截距

                                     uplist[numu].prev=downlist[numd].prev=0;

                                     uplist[numu].next=list[x=(dx+n)%M];

                                     if (list[x]) {

                                               list[x]->prev=&uplist[numu];

                                     }

                                     downlist[numd].next=list[ux%=M];

                                     if (list[ux]) {

                                               list[ux]->prev=&downlist[numd];

                                     }

                                     b[numb].up=list[ux]=&uplist[numu];

                                     b[numb].down=list[x]=&downlist[numd];

                                     uplist[numu].other=&downlist[numd];

                                     downlist[numd].other=&uplist[numu];

                                     uplist[numu].at=downlist[numd].at=&b[numb];

                                     ++numu;

                                     ++numd;

                            }

                            ++numb;

         其中a[i].first,a[i].second就是(x,y)。

b是node型数组,是真正存放僵尸的点。uplist,downlist是save型的数组，存放这个点开始往上或下弹到哪里，这两个数组里的点都是边界点，但是上下边界与list的名称无关。list是一个长度为2*n,存放截距模（2*n）后相同的点的指针数组, line是长度为(n+1)的指针数组，存放水平线的点，它们的类型分别为,node*,save*。类型定义如下：

struct node {

         node *prev,*next,*other; 

//other是专门给假点使用的，为删除一个假点时把对应的假点也删除

         save *at;    //存放真正在b数组的的哪里

};

 

struct save {

int y;

save *prev,*next;

int num;       //僵尸数目

node *up,*down;

};

list, uplist, downlist只是工具而已，是帮助b建立连接的,list的数组下标含义在上边界x=0的截距。M是2*n。line[y]记录的是水平线上的点，这样坚果碰到通过line数组找到第一个打到的点，然后根据up,down找到弹到的点，再不断next,就完成了一条轨道。要达到的就是这样的效果——通过next可以方便找到轨道上下一个点。

然后就是每次把num为0的节点删除，这个相对简单点，就是双向链表删除元素。但要注意删除“假点”时，要删除两个（上下边界相对应的假点），而且要把next指向的那两个链表对调（other的next接到this后面, this->next接到other 后面），还有line数组里也要删，总之同时维护若干个链表真麻烦！

 

 

 

 

G	Palm Up and Palm Down

 

         又一道比较麻烦的dp题。题目意思比较有趣，手心手背，在我们那个年代叫做“黑白黑”……召唤80后的回忆。然后少部分的人留下，要是一样多的话，谁也不能走，再继续，直到剩下两个人，他们玩石头、剪子、布，输得那个人悲剧。现在给定每个人出“黑 白”还有石头、剪子、布的比率，求游戏期望进行多少轮，以及最后剩的那一个悲剧的人最可能是哪些人，以及他悲剧的概率。

         显然的2ⁿ表示状态。对一个状态x来讲，我们用num[x]表示x的二进制表示中1的个数，用allblack[x]表示这些人全部出黑的概率，类似定义allwhite[x]，这两个东西可以打表算出。e[x]表示轮数期望。

如果num[x]<=1 则 e[x]=0

如果num[x]=2,只剩两个人，则期望是一个人赢另外一个人概率的倒数。这个就根据石头、剪子、布的概率很容易算出来……

num[x]>2

则 A=sigma(allwhite[i]*allblack[j])*e[x] 其中i|j=x, i&j=0 ,num[i]=num[j] 即把x中的为1的bit分为个数相同的两部分，显然只有num[x]为偶数时才做得到，否则A为0.

   B=sigma(allwhite[i]*allblack[j])*e[(num[i]<num[j])?i:j] 其中i|j=x ,i&j=0,num[i]!=num[j]即把x中的位1的bit分为个数不同的两部分。

则有e[x]=A+B+1

其实看一下e[x]-A，的系数恰好是B中的系数和。（也就是说A，B的那些系数和为1），所以e[x]-A=bitsigma(allwhite[i]*allblack[j])*e[x]=t*e[x]  其中i|j=x i&j=0 num[i]!=num[j] （其中t为B中的系数和）

所以我们对于x，枚举i，然后j=x^i，这样有了i，j，就可以累加出B，并顺便算出其系数和t，然后(B+1)/t即可以得到e[x]。

         我们是由小到大循环x的，所以再计算e[x]时，e[i],e[j]都已经计算好了。只是要注意无穷大的处理。无穷大一种是t为0，一种是有些期望是无穷大，并且系数非0。

         类似的，我们可以计算出每个状态出现的概率。设为p。     

         从p[2ⁿ]=1, 我们可以逆推。对于p[x]，会影响小于x的状态，而那些状态恰好是上面计算的i和j。

         同样，如果num[x]=2概率要自己算出剩下悲剧那个人的概率，并且累加到num[i]=1的状态上。

         num[x]>2时，同样把x中位1的bit分成两部分。类似上面描述，只不过是逆推，对所有i|j=x i&j=0 num[i]!=num[j]的状态，要在p[(num[i]<num[j])?i:j]上累加上allblack[i]*allwhtie[j]/tot[x]*p[x]

其中tot[x]是在前面算x状态的轮数期望时计算的那个t值。（可以保存起来）。

         这样我们在用一个“大”的状态x，更新了它所有影响的“小”的状态。

         最后num[]=1的n个状态为所求，找到概率最大的人就好了。

         顺便说一下对每个x，如何枚举状态i，直接循环从0到x的话，复杂度会很高，成了2²ⁿ,事实上很多状态i是没用的，因为要保证i中的位1的bit是x的真子集。所以可以for (i=(x-1)&x;i;i=(i-1)&x), 这样可以保证真子集的条件。而复杂度跟x中1的个数有关。总体复杂度是 sigma(c(y,n)*2y) y从0到n，这个正好是3=(1+2)的n次方的2项展开式。所以总体复杂度是3ⁿ,对于n=13来讲4¹³比3¹³大很多。

 

 

 

H

BCD Code

 

H  BCD Code

就是要求区间[A,B]之间，把组成一个数的全部数字都用四位二进制数表示出来（含首0），问不出现某些固定0-1模式的数有多少个。比较难的题，可以建立经典的AC自动机。当然本题的特殊性是模式串长不超过20，而且都是0和1，所以也可以不用AC自动机。需要表示的是现在产生的串的后缀是哪个模式的最长前缀。也就是一个(x,y)表示现在产生的串的后缀（前面那些位都没用）是第x个模式串的前y位。而且要求y尽可能大，如果y值相同的时候，位保证唯一性，可以取比较小的x。然后初始是空串，可以认为是第0个模式串的前0位。从(0,0)开始进行bfs，对当前串末尾分别加0、加1，看看能否转到其他状态，对于转换到的状态的判断就是枚举，然后判断，因为全是0,1，而且不超过20位，所以可以用位运算直接取出一个模式的连续某些bit。这样到最后产生了一个状态之间的转换图。（从某个状态经过0到哪里，经过1到哪里），状态总个数不超过21×100=2100个。这是偷懒的做法。其实这样写的代码也未必短多少。正规的做法，还是先建立trie，然后算fail指针，建立起AC自动机。

但最后都是建立状态转换图，从当前状态经过0跳到哪里，经过1跳到哪里。只不过不用自动机的话是直接枚举出状态转换，而又利用了题目本身的性质，可以使用位运算。而用AC自动机则是通过fail指针计算的。

然后就是动态规划了。一种直接的思路是计算所有小于x的合法数的个数f(x)，结果是f(B)-f(A-1)。那么可以定义动态规划的状态，dp[n][state][cmp], 第一维表示当前产生的数的十进制的位数，第2个表示当前的状态，对应于状态图的节点，第三个是当前产生的数与x的前n十进制位组成的串的字典序的大小（有三种情况，大于，小于，等于）。然后状态转换也不复杂。循环n，从n开始枚举一位数字（注意不能有首0），然后从state利用状态图看看是否合法，计算出新的state’。（一个数字对应4位2进制数，把state添加一个数字对应了状态机的4步状态转换，把这个打表存起来是一个提速的办法，即存一个[state][10]的数组，记录下state经过一个数字最终转换到的新的state），再根据以前的cmp和新加的这位数字计算出新的cmp’，然后累加上来，即dp[n+1][state’][cmp’]+=dp[n][state][cmp]。

最后注意，当n小于x的十进制位数时，无论cmp位什么结果，都要累加进最终结果。而当n刚好等于x的十进制位数时，这时第三维的字典序就是实际数和x大小顺序，所以只能把字典序不大于x的那些结果累加进来，这也是状态表示中第三维存在的意义。

还有一个稍微麻烦一点但是更快一点的办法就是多加一维数组表示状态，把状态改为dp[n][state][cmpa][cmpb]，最后两维记录当前产生的n位数与A的前n位的字典序关系，以及与B的前n位字典序之间的关系。也是同样的办法计算、累加。这样做状态转换麻烦点，但是只dp一次就可以累加出最后结果，所以比前一种dp快一点。而之前的方法需要dp两次求差值。

关于AC自动机，网上有很多资料，讲得很详细，其实就是个trie树加上fail指针。就是KMP算法在多串上的推广。关于AC自动机，我又在zoj上找了两个题：

Zoj 3430可以用这个解决，当然直接暴力也是可以过的……

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3430

还有一个难一点的题 zoj3190

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3190

感兴趣的可以试试看。

 

 

 

I	Lego Bricks

 

I   Lego Bricks

         给定一些圆盘和线段，问能否使线段都稳定。Vls的计算几何题向来是很难的，关键看对于稳定的理解……把线段从中间截断成两段。那么看每条小线段是否稳定。小线段稳定如果：（1） 它和一条已经稳定的线段有公共点。 或者（2） 它和某一个圆盘有公共点。（圆盘的意思是圆形的区域而不仅仅是边界）。 如果两条小线段都满足稳定条件，整条线段是稳定的。就这么不断地扩散，稳定线段不断增多，如果能否使得所有线段都稳定。复杂度O(n²)。

 

 

 

J	Assignment

 

J  Assignment

         很有趣的题。就是网络流。边容量给定，网络容量给定，有两个人A,B, A先给定一个最大流，并且保证每条边流量必须为整数，B给每条边设定单位流量的费用，所有边的单位流量总费用之和不超过一个阈值p。边过了流量就要支付单价乘以流量那么多的费用（1） 如果A希望总费用尽可能低，而B希望总费用尽可能高，则最后总费用是多少。（2）反过来A希望总费用尽可能高，而B希望总费用尽可能低，那么最后总费用又是多少。

         对于(1)，B只要把P全部分给流量最大的边即可让总费用最大。所以A的目的是让这个最大流里流量最大的边的流量尽可能小。所以我们可以二分，如果二分到一个值x，刚好使得所有边的容量上界定为x时（当然还要满足自身容量），最大流减小了。则(x+1)就是流量最大边的最小可能流量值了。所以结果是(x+1)*p。

         对于（2），B只要把P全部分给流量最小的边即可让总费用最小。所以A的目的是让这个最大流里面流量最小的边的流量尽可能大。同样的二分，如果二分一个值y，刚好使得所有边的容量下界定为y时，最大流减小。则(y-1)就是流量最小的边的最大可能流量值了。所以结果就是(y-1)*p。

         注意（2）是一个有上下界的最大流问题。而且由于时间限制，本题需要一个比较快速的网络流。另外，最后结果是乘积形式，可能超过了int，所以要使用long long。

 

 

 

 

K

Mistwald

 

K  Mistwald

         题目意思是给定一个有向图（最多25个节点，每个节点的出度最多为4），给定起点和终点，然后从起点开始走，走到终点就停止，否则一直往下走，问能不能P步到达终点。也就是说从起点出发，走一条长度为P的路径，路径中间点不能经过终点（但可以反复经过其他点）。如果从起点出发P步后，不能到达终点，就是False，如果可以到达终点也可以到其他别的点，就是Maybe，如果P步后只能到达终点（到别的点没有长度为P的路径），则是Yes。

         显然的矩阵乘法。图的临接矩阵A的 p次方A^p中为1的元素(i,j)表示节点i到节点j有一条长度为p的路径（经历的节点可能重复）。要理解矩阵的含义，两个矩阵相乘如果(x,y)元素为1，而(y,z)元素为1,则结果(x,z)元素为1，这表明通过y把x和z连起来了。而题目要求经过终点就不能走了，所以在做矩阵乘法时，需要把（x,n-1） (n-1,y)这样决定的(x,y)去掉。（n-1表示终点）。做乘法时，中间点小心一点就好了。矩阵乘法和floyd在本质上是一样的……

         矩阵的P次方运用的是经典的log(P)的算法。最后看一下结果矩阵的首行（0行）里面有几个1，以及(0,n-1)是不是1，来决定结果。

         一般矩阵的乘法要n³的复杂度。这个矩阵规模很小，n只有25，而且矩阵元素是0或者1，所以我们可以把每行用一个整数表示，每列也用一个整数表示,元素值按bit压缩至int里。实际上就是用两个数组，一个表示行向量r，一个表示列向量c，然后在做乘法时可以用位运算，r[i]&c[j]来决定结果矩阵(i,j)位置是0还是1，当然结果矩阵也要同时保存行向量和列向量，另外还是要去掉中间点为终点的转换。这样复杂度就只有n²了。