模拟26A 题解

A. marshland

考试时想到了网络流，然而不会建图，就死了。

正解是最大费用可行流。

比较容易想到的是将每个点拆为两个点，

s连没有危险值的入点，

没有危险值的入点连有危险值的入点，入点出点之间限流有费用，

出点再连没有危险值的出点，这些出点连向t。

不断跑spfa，通过有流量的边，记录下前趋。

将前趋的边的流量改变，EK算法。

B. party

因为只有单向边，达成尽快到齐的条件是，终点为c个点的lca。

m的范围比较小，于是可以用bitset维护。

比较容易想到了在倍增求lca的同时维护bitset，取并集。

然而空间刚好卡到600多MB，时间也死了。

树链剖分。

空间返回到O(n*m)级别，比倍增少一个log。

问题转化为每个人从自己所有集合中选择相同数量的最多元素，要求互不相同。

网络流+二分可行。

源点向每个人建流量为mid的边，每个人向它包含元素建流量为1的边，每个元素向汇点建流量为1的边。

左部点流满就表示可行。

如果将每个人拆为若干个点，问题其实是求二分图完美匹配。

于是想到霍尔定理（？？？）：

一个二分图 G 存在完美匹配, 当且仅当 X 中的任意 k 个点都至少与 Y 中的 k 个点邻接.

二分答案，枚举$2^{c*mid}$显然是可行的，然而复杂度真的死了。

考虑不同的左部点只有c个，枚举$2^c$，

1表示考虑这个人。

将答案与 所有考虑的人的bitset并集中1的个数除以考虑的人数 取min。

总复杂度为$O(\frac{qlog^2nm}{32})$。

考虑到没有修改操作，直接维护每个点到重链顶的bitset，可以将复杂度降低一个$logn$。

推荐$unsigned long long$手写$bitset$，

主要是可以将$O(n)$的$count$函数通过预处理变成$O(\frac{n}{32})$，

或者继续循环展开将所有操作改为$O(1)$。

 struct bitset{
     #define lowbit(x) (x&-x)
     unsigned long long bit[];
     inline void reset(){
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
         bit[]=;
     }
     inline friend void operator |=(bitset &a,const bitset &b){
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
         a.bit[]|=b.bit[];
     }
     inline friend bitset operator |(const bitset &a,const bitset &b){
         bitset ans;
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         ans.bit[]=a.bit[]|b.bit[];
         return ans;
     }
     inline void set(const int x){
         bit[x>>]|=(unsigned long long)<<(x&);
     }
     inline int count(){
         register int cnt=;
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         cnt+=ct[bit[]&]+ct[(bit[]>>)&]+ct[(bit[]>>)&]+ct[(bit[]>>)&];
         return cnt;
     }
 };

C. platform

后缀数组。

然而完全忘记了怎么打。

没改到，鸽了。