题目
思路
这是好题啊。我绞尽脑汁才得到的这个做法。不知道是不是已广为流传了 😭
首先转化一下题意。这个 f G ( a , b ) f_G(a,b) fG(a,b) 的求法，想必大家是很熟悉了。求出 1 1 1 到 a a a 的长度为奇数的最短路，与长度为偶数的最短路。为啥要奇偶性分类呢？因为一条边可以走多次，那么在一条边上 “反复横跳” 一次，就会让路径长度增大 2 2 2 。
那么，比最短路更短的，显然不可能；不短于最短路的，通过 “反复横跳” 总能实现。所以题目的意思就是保证最短路不变。
怎么表示奇长度和偶长度呢？可以对每个点建立一个虚点。或者说，其实是 2 n 2n 2n 个 “虚点”，每个点代表一个 d p \tt dp dp 状态 f ( x , 0 / 1 ) f(x,0/1) f(x,0/1) 表示到达 x x x 的 偶数 / / / 奇数 长度的最短路。将原图的边 ⟨ x , y ⟩ \langle x,y\rangle ⟨x,y⟩ 变成 ⟨ x , y ′ ⟩ \langle x,y'\rangle ⟨x,y′⟩ 和 ⟨ y , x ′ ⟩ \langle y,x'\rangle ⟨y,x′⟩ 就好了。
跑一次最短路即可。得到一个最短路图。那么每个点在新图上，都必须选择一个前驱节点，才能保证 d i s dis dis 不变。（由于已经建立虚点，只需要保证到每个点的最短路都不变，不再有奇偶性的考虑。）
考虑到一个简单的事实：如果一条边不是用来满足 d i s dis dis 的关系的，那完全可以删掉。所以，每个点 只选择一个前驱——多选无益。同层点的连边就更是无用了！
是不是每个前驱都可以选择呢？其实并不是。但是 至少有一个合法的前驱，那就是原图的最短路图中的那个。所以说，我们 可以决定某些点的前驱，剩下的点就直接选择这个合法前驱即可。毕竟这个前驱也是必然选的。
你可能认为，答案不就是点数 − - − 1 1 1 么？因为除去 1 1 1 不选择前驱，其他点都选择了一个。那你就太天真了！别忘了我们有虚点。边 ⟨ x , y ⟩ \langle x,y\rangle ⟨x,y⟩ 和 ⟨ x ′ , y ′ ⟩ \langle x',y'\rangle ⟨x′,y′⟩ 本质上是同一条边！
称形如
⟨
x
,
y
⟩
\langle x,y\rangle
⟨x,y⟩ 和
⟨
x
′
,
y
′
⟩
\langle x',y'\rangle
⟨x′,y′⟩ 的一对边互为 “对称边” 。当然
⟨
x
,
y
′
⟩
\langle x,y'\rangle
⟨x,y′⟩ 和
⟨
x
′
,
y
⟩
\langle x',y\rangle
⟨x′,y⟩ 也是一样。那么答案应当是
∣
V
∣
−
1
−
∣
E
s
y
m
m
e
t
r
y
∣
|V|-1-|E_{symmetry}|
∣V∣−1−∣Esymmetry∣
即，点数减一再减去 “对称边” 数量。由于
∣
V
∣
−
1
|V|-1
∣V∣−1 是固定的，我们 只需要最大化 “对称边” 的数量。
不妨设 x , x ′ x,x' x,x′ 在最短路图中的 d i s dis dis 分别是 l , r l,r l,r（下简记为 [ l x , r x ] [l_x,r_x] [lx,rx] ）。由于 x , x ′ x,x' x,x′ 究竟谁是虚点并不重要，规定 l < r l<r l<r（即 x ′ x' x′ 的 d i s dis dis 大于 x x x 的）。显然 r − l r-l r−l 为奇数，这是定义决定的。
不妨 钦定 “对称边”。比如，我们假定
⟨
x
,
y
⟩
\langle x,y\rangle
⟨x,y⟩ 是作为对称边出现了的。那么
y
′
y'
y′ 在最短路图中的
d
i
s
dis
dis 与
x
′
x'
x′ 相邻，
y
y
y 与
x
x
x 也相邻。即
l
y
=
l
x
±
1
,
r
y
=
r
x
±
1
l_y=l_x\pm 1,\;r_y=r_x\pm 1
ly=lx±1,ry=rx±1
否则就没有连边了嘛！这四类情况本质上只有两种：包含与相交。
- 包含型：如果 l y = l x + 1 , r y = l x − 1 l_y=l_x+1,\;r_y=l_x-1 ly=lx+1,ry=lx−1，那我们可以让 p r e ( y ) = x , p r e ( x ′ ) = y ′ pre(y)=x,\;pre(x')=y' pre(y)=x,pre(x′)=y′ 使得此处出现一个对称边。即：可以同时钦定 y , x ′ y,x' y,x′ 的前驱，出现一条对称边。
- 相交型：如果 l y = l x − 1 , r y = r x − 1 l_y=l_x-1,\;r_y=r_x-1 ly=lx−1,ry=rx−1，那我们可以让 p r e ( x ) = y , p r e ( x ′ ) = y ′ pre(x)=y,\;pre(x')=y' pre(x)=y,pre(x′)=y′ 使得此处出现一个对称边。即：可以同时钦定 x , x ′ x,x' x,x′ 的前驱，出现一条对称边。
显然每个 y y y 对 x x x 的要求是不一样的。也就是说 x x x 只能满足某个 y y y 的要求。也就是说，相当于一个匹配。那么 “可以同时钦定二者，出现一条对称边” 就直接连边就好。
问题变为了一般图的最大匹配？好像并不是一般图。注意到上面两种连边方式都是带 ′ ' ′ 的向不带 ′ ' ′ 的连边。所以 这是一个二分图。
考试的时候，我以为到这里就结束了，就开始敲 d i n i c \tt dinic dinic，最终拿到了 5 5 5 分的高分。这是为什么呢？
原来有一个害人精
r
x
=
l
x
+
1
r_x=l_x+1
rx=lx+1 的情况。这时候，
l
y
,
r
y
l_y,r_y
ly,ry 的大小关系有了微妙的变化，并且 包含型 消失了。它消失了不要紧，重要的是，如果
l
x
=
l
y
=
r
x
−
1
=
r
y
−
1
l_x=l_y=r_x-1=r_y-1
lx=ly=rx−1=ry−1 的话，需要连边
x
′
,
y
′
x',y'
x′,y′，这导致它不再是一个二分图了！虽说这不是导致我拿五分的原因。
所以我们再想想这个图。枚举了所有四种情况，你会发现， x x x 的连边只有两条，一个是 ⟨ x , x ′ ⟩ \langle x,x'\rangle ⟨x,x′⟩，另一个是 ⟨ x , y ′ ⟩ \langle x,y'\rangle ⟨x,y′⟩（满足 r y = r x + 1 r_y=r_x+1 ry=rx+1 且 l y = l x − 1 l_y=l_x-1 ly=lx−1）。类似的， x ′ x' x′ 的连边也只有两条。你会发现， x ′ x' x′ 只走向更小的区间， x x x 只走向更大的区间。而且二者走向的区间只有一种（可能多个，但是必定是同一种）。
这是什么呀？这是 一条链！由于同种区间的连边情况相同，可以 “缩点”，让点权为其数量。缩点后，这样一个东西是一条单链：从 x x x 走到区间更大的 y ′ y' y′，然后走到 y y y，然后走到更大的 z ′ z' z′，以此类推。
一条链怎么求最大匹配？当然是直接贪心啦！从某一端开始，尽可能多的匹配。正确性容易证明：若某个端点的点权没用尽，那么倒数第二个必须用尽；将它的匹配撤销，改成与链首匹配，不会更劣。
再回看刚刚那个 x ′ x' x′ 与 y ′ y' y′ 的连边。其实就是自环嘛！最终剩下的点权是 s s s，则可以自己与自己匹配 ⌊ s 2 ⌋ \lfloor{s\over 2}\rfloor ⌊2s⌋ 嘛！
这张图是一个 “洋葱链森林”（为什么叫洋葱链呢？因为它总体上是链，但顶端很多自环，像一个洋葱），因为有父子关系的区间恰好满足 l + r l+r l+r 为定值。求出所有 l , r l,r l,r 后，按照 l + r l+r l+r 分类即可。
分析一下复杂度。第一部分，建虚点，求最短路，这是 O ( n ) \mathcal O(n) O(n) 的。第二部分，按照 l + r l+r l+r 分类后，“建树”（我们已经知道了匹配规则，可以不用真正地建立树），这当然也是 O ( n ) \mathcal O(n) O(n) 的——虽然我们有对 r − l r-l r−l 排序的过程（方便找父子关系），但是我们可以在分类前就先桶排解决。总复杂度自然是线性的。
还不懂就只能看代码了。由于这个做法是自己 y y yy yy 的，没得到验证，打代码的时候还是挺小心翼翼的，注释也有在写。
代码
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
typedef pair<int,int> PII;
inline int readint(){
int a = 0; char c = getchar(), f = 1;
for(; c<'0'||c>'9'; c=getchar())
if(c == '-') f = -f;
for(; '0'<=c&&c<='9'; c=getchar())
a = (a<<3)+(a<<1)+(c^48);
return a*f;
}
const int MaxN = 100005;
const int MaxM = 200005;
/** man-made queue */
namespace queue{
int q[MaxN<<1];
typedef int* iterator;
iterator begin(){ return q; }
}
/** in order to get dis(dep) */
namespace Graph{
struct Edge{
int to, nxt; Edge(){}
Edge(int T,int N){
to = T, nxt = N;
}
};
Edge e[MaxM<<2];
int cntEdge, head[MaxN<<1];
void addEdge(int a,int b){
e[cntEdge] = Edge(b,head[a]);
head[a] = cntEdge ++;
e[cntEdge] = Edge(a,head[b]);
head[b] = cntEdge ++;
}
int dep[MaxN<<1];
void input(int n,int m){
for(int i=1; i<=2*n; ++i)
dep[i] = head[i] = -1;
cntEdge = 0; // several cases
for(int i=1,a,b; i<=m; ++i){
a = readint(), b = readint();
addEdge(a,b+n), addEdge(a+n,b);
}
}
void scan(){
queue::iterator fro = queue::begin();
queue::iterator bac = queue::begin();
*(bac ++) = 1; dep[1] = 0;
for(; fro!=bac; ++fro)
for(int i=head[*fro]; ~i; i=e[i].nxt)
if(dep[e[i].to] == -1){
dep[e[i].to] = dep[*fro]+1;
*(bac ++) = e[i].to;
}
}
}
int n, m;
void input(){
n = readint(), m = readint();
Graph::input(n,m), Graph::scan();
}
int ans; // maximum matches
# define DDQ vector<PII>::iterator
/** @return the remain value on FIRST node */
int eliminateChain(const DDQ &bg,const DDQ &ed){
int used = 0;
for(DDQ i=ed; i!=bg; --i){
used = min(i->second-used,(i-1)->second); // match all
ans += used; // accumulate
}
return bg->second-used;
}
# undef DDQ
bool vis[MaxN<<1]; // if there exist [l-1,r-1] (indexed by r-l+1)
vector<int> tree[MaxN<<1]; // classify by l+r
vector<PII> len_cnt; // first:len second:cnt(val)
vector<int> trash; // to clear array vis
int getOnion(){
using Graph::dep; // for convenient
int tot = 0; // useful nodes
for(int i=1; i<=n; ++i){
int l = dep[i], r = dep[i+n];
if(l > r) swap(l,r); // s.t. l < r
if(l != -1) // useful nodes
tree[l+r].push_back(r-l+1);
tot += (l != -1) + (r != -1);
}
ans = 0; // several test cases
trash.clear(); // good habit
memset(vis+1,0,n<<1);
for(int i=1; i<=2*n; i+=2){
len_cnt.clear();
vector<int> &v = tree[i];
sort(v.begin(),v.end());
int len = v.size();
for(int p=0,j=p; p!=len; p=j){
while(j != len && v[j] == v[p])
++ j; // [p,i) keep the same
/* two nodes: x and x' */ ;
len_cnt.push_back(make_pair(v[p],j-p));
len_cnt.push_back(make_pair(v[p],j-p));
}
len = len_cnt.size(); // v is useless now
for(int p=0,j=p; p!=len; p=++j){
while(j+1 != len)
if(j&1){ // become longer
if(len_cnt[j+1].first == len_cnt[j].first+2)
++ j; else break;
}
else{ // inner edge
if(vis[len_cnt[j].first])
++ j; else break;
}
int rest = eliminateChain(len_cnt.begin()+p,len_cnt.begin()+j);
if(!p && len_cnt[0].first == 2)
ans += (rest>>1); // self-loop
}
while(!trash.empty()){
vis[trash.back()] = false;
trash.pop_back();
}
while(!len_cnt.empty()){
trash.push_back(len_cnt.back().first);
len_cnt.pop_back();
vis[trash.back()] = true;
}
}
return tot-1-ans;
}
void solve(){
for(int i=1; i<=2*n; i+=2)
tree[i].clear();
printf("%d\n",getOnion());
}
int main(){
for(int T=readint(); T; --T)
input(), solve();
return 0;
}
后记
先吐槽一下：虽然肝这道题耗费了很多时间，但是真的挺爽的……然而教练显然很不爽。
再贴一个正经题解的连接，你会发现：它的 h ( x ) h(x) h(x) 定义不就是我的 [ l x , r x ] [l_x,r_x] [lx,rx] 吗？殊途同归啊！让人想起了 脱二十钛1 的名言：
A C \tt AC AC 的代码都是一样的， W A / R E / T L E / M L E \tt WA/RE/TLE/MLE WA/RE/TLE/MLE 的代码各有各的「超级高水平」操作。（看 C B A \rm CBA CBA 的应该懂）
鹅国著名作家，代表作有《栈争 & \& & 和平》。 ↩︎
113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
