Codeforces 603E Pastoral Oddities

Posted 逢山开路 遇水架桥

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Codeforces 603E Pastoral Oddities相关的知识,希望对你有一定的参考价值。

传送门:http://codeforces.com/problemset/problem/603/E

【题目大意】

给出$n$个点,$m$个操作,每个操作加入一条$(u, v)$长度为$l$的边。

对于每次操作后,求出一个边集,使得每个点度数均为奇数,且边集的最大边最小。

$n \\leq 10^5, m \\leq 3 * 10^5$

【题解】

有结论:满足条件(每个点度数均为奇数),当且仅当每个连通块大小都是偶数(容易证明,从下往上,调整法)。

那么显然可以LCT维护连通性,连通块大小以及最大边位置,每次拉出最大边,加入即可。做法有点像水管局长那题。

复杂度$O((n+m)log(n+m))$,常数大……LCT太不优美了!!!

考虑一种优美的做法:

这个类似于动态维护生成树(生成森林),那么是否可以分治?

答案是可以的。一开始我们往整体二分的方向想,发现没有办法支持并查集的撤销,然后就gg了。实际上这道题有一个非常优美的分治做法!

【手动分割】

容易发现把-1看成inf,那么答案是不增的。

定义$solve(l, r, lo, hi)$表示目前处理的操作区间为$[l, r]$,答案区间为$[lo, hi]$。

那么考虑求出$mid = (l+r)/2$的时候的答案$ans[mid]$。

那么我们是不是可以根据$mid$和$ans[mid]$,划分成$solve(l, mid-1, ans[mid], hi)$和$solve(mid+1, r, lo, ans[mid])$来分治!!!

想到这里了,问题在于怎样求出$ans[mid]$以及划分区间需要进行的并查集操作。

这里的并查集容易发现,要使用按秩合并,不能路径压缩,因为要支持撤销。(支持撤销的并查集套路有很多,比如bzoj连通图、二分图那几题)

考虑求$ans[mid]$,我们画一张图,横坐标代表询问id,纵坐标代表length。

(字母要用光了QAQ)

我们目标是求出ans[mid]的这条线从而划分成BFQG和DEQH来分治,目前的区域为ABCD。

因为我们要求mid的答案,相当于求Q点的坐标。所以$[l,mid-1]$的边相当于已经加了。

考虑矩形DHYX,表示$[l, mid-1]$的边,权值范围小于$lo$,容易发现这个对于我们统计$mid$的答案是必须加入的,加入即可。

接下来按从小到大的顺序依次加入每一条权值在$[lo, hi]$的边,然后实时记录是否满足条件了,如果满足,那么我们就能求出$ans[mid]$。

求完$ans[mid]$要撤销并查集操作哦~

那么这步就做完了,下面就有两个问题了。

1. 找不到$ans[mid]$,那么说明$[l, mid]$都没有解,就能把DHYX的所有边加入并查集中了,然后递归寻找$solve(mid+1, r, lo, hi)$即可,记得撤销操作。

2. 找到了$ans[mid]$:

这个就非常兹磁了对吧,我们就可以分成两块做了。

考虑如果递归到$solve(mid+1, r, lo, ans[mid])$,那么同样的,DHYX的所有边也可以被加入并查集中了。

考虑如果递归到$solve(l, mid-1, ans[mid], hi)$,那么,STDE中的所有边也可以被加入并查集中了。

那么维护这个东西就行了。

容易发现,每条边最多被加入$O(logm)$次,每次复杂度为$O(logn)$,所以复杂度为$O(mlogmlogn)$,由于常数小,实测跑的飞快。

【手动分割-2】

真的跑的飞快吗?

第一次测:TLE on test 83(代码见下)

# include <vector>
# include <stdio.h>
# include <string.h>
# include <iostream>
# include <algorithm>
// # include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int M = 3e5 + 10, N = 1e5 + 10;
const int mod = 1e9+7;

int n, m, mx;

struct op {
    int a, b, l, sl;
}q[M];

vector<int> v[M], ps;

struct us {
    struct backup {
        int x, y, del;
    } st[N]; int stn;
    int fa[N], sz[N], cnt_odd;
    inline void set(int n) {
        cnt_odd = n; stn = 0;
        for (int i=1; i<=n; ++i) fa[i] = i, sz[i] = 1;
    }
    inline int getf(int x) {
        return fa[x] == x ? x : getf(fa[x]);
    }
    inline void un(int x, int y) {
        x = getf(x), y = getf(y);
        if(x == y) return ;
        if(sz[x] < sz[y]) swap(x, y);
        ++stn;
        if((sz[x] & 1) && (sz[y] & 1)) cnt_odd -= 2, st[stn].del = 2;
        else st[stn].del = 0;
        st[stn].x = x, st[stn].y = y;
        sz[x] += sz[y]; fa[y] = x;
    }
    inline void re() {
        backup s = st[stn--];
        cnt_odd += s.del;
        sz[s.x] -= sz[s.y]; fa[s.y] = s.y;
    }
    inline bool check() {
        return cnt_odd == 0;
    }
}S;

int ans[M];

inline void solve(int l, int r, int lo, int hi) {
    if(l > r) return ;
    // now doing intervals [l, r], the answer is in [lo, hi]
    // find the answer of mid = (l+r)/2
    int mid = l+r>>1, ans_mid = -1, lst = S.stn;
    // add in edges that in interval [l, mid], and satisfy length < lo
    for (int i=l; i<=mid; ++i) 
        if(q[i].sl < lo) S.un(q[i].a, q[i].b);
    // add in edges from [lo] to [hi], and find the answer of mid
    for (int i=lo; i<=hi; ++i) {
        for (int j=0; j<v[i].size(); ++j) 
            if(v[i][j] <= mid) S.un(q[v[i][j]].a, q[v[i][j]].b);
        // if satisfy the condition
        if(S.check()) { ans_mid = i; break; }
    }
    while(S.stn > lst) S.re();
    if(ans_mid == -1) {
        // cannot find the answer of mid
        for (int i=l; i<=mid; ++i) ans[i] = -1;
        // add in edges that in interval [l, mid], and satisfy length < lo
        for (int i=l; i<=mid; ++i)
            if(q[i].sl < lo) S.un(q[i].a, q[i].b);
        solve(mid+1, r, lo, hi);
        while(S.stn > lst) S.re();
        return ;
    }
    // set the answer of mid to ans_mid
    // so to interval [l, mid], the answer is [ans_mid, hi];
    //    to interval [mid+1, r], the answer is [lo, ans_mid].
    ans[mid] = ans_mid;
    // for the right side [mid+1, r], we can add in edges that in [l, mid], and satisfy length < lo.
    for (int i=l; i<=mid; ++i) 
        if(q[i].sl < lo) S.un(q[i].a, q[i].b);
    solve(mid+1, r, lo, ans_mid);
    while(S.stn > lst) S.re();
    // for the left side [l, mid], we can add in edges that satisfy length < ans_mid, and in [1, l)
    for (int i=lo; i<ans_mid; ++i)
        for (int j=0; j<v[i].size(); ++j)
            if(v[i][j] < l) S.un(q[v[i][j]].a, q[v[i][j]].b);
    solve(l, mid-1, ans_mid, hi);
    while(S.stn > lst) S.re();
}
    
            
    

int main() {
    cin >> n >> m; S.set(n); 
    if(n & 1) {
        while(m --) puts("-1");
        return 0;
    }
    for (int i=1; i<=m; ++i) { 
        scanf("%d%d%d", &q[i].a, &q[i].b, &q[i].l); 
        ps.push_back(q[i].l);
    }
    sort(ps.begin(), ps.end());
    ps.erase(unique(ps.begin(), ps.end()), ps.end());
    
    for (int i=1; i<=m; ++i) {
        q[i].sl = lower_bound(ps.begin(), ps.end(), q[i].l) - ps.begin() + 1;
        v[q[i].sl].push_back(i);
    }
    
    solve(1, m, 1, ps.size());
    
    for (int i=1; i<=m; ++i) {
        if(ans[i] == -1) puts("-1");
        else printf("%d\\n", ps[ans[i]-1]);
    }
    return 0;
}
 
View Code

感受了下原因,这是一个$n = 8, m = 2.6 * 10^5$的非常稠密图。我之前的写法是离散,用vector维护每种值有多少,然后会出现的问题是$ans[mid]$可能很长时间不动,那么访问$ans[mid]$里所有的值是近似$O(m)$复杂度,所以肯定爆炸了啊!

有两种解决方法,一种加入id,表示是$ans[mid]$中的第$id$个节点达到答案;一种是用排序后的边的下标来替代值,那么$lo$和$hi$就变成了边的下标。

我设排序前数组为q,排序后为p。

然后我还傻逼WA了一次,因为我直接把q[i].l和p[lo].l比大小,小于就加入,如果有q[i].l=p[lo].l,就很难分清楚要不要加入了,这个的解决办法是对于q加入一个id表示在p中的位置,那么就兹磁比大小了。

现在跑的飞快了!

# include <stdio.h>
# include <string.h>
# include <iostream>
# include <algorithm>
// # include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int M = 3e5 + 10, N = 1e5 + 10;
const int mod = 1e9+7;

int n, m;

struct op {
    int a, b, l, id;
    friend bool operator < (op a, op b) {
        return a.l < b.l;
    }
}q[M], p[M];

struct us {
    struct backup {
        int x, y, del;
    } st[N]; int stn;
    int fa[N], sz[N], cnt_odd;
    inline void set(int n) {
        cnt_odd = n; stn = 0;
        for (int i=1; i<=n; ++i) fa[i] = i, sz[i] = 1;
    }
    inline int getf(int x) {
        return fa[x] == x ? x : getf(fa[x]);
    }
    inline void un(int x, int y) {
        x = getf(x), y = getf(y);
        if(x == y) return ;
        if(sz[x] < sz[y]) swap(x, y);
        ++stn;
        if((sz[x] & 1) && (sz[y] & 1)) cnt_odd -= 2, st[stn].del = 2;
        else st[stn].del = 0;
        st[stn].x = x, st[stn].y = y;
        sz[x] += sz[y]; fa[y] = x;
    }
    inline void re() {
        backup s = st[stn--];
        cnt_odd += s.del;
        sz[s.x] -= sz[s.y]; fa[s.y] = s.y;
    }
    inline bool check() {
        return cnt_odd == 0;
    }
}S;

int ans[M];

inline void solve(int l, int r, int lo, int hi) {
    if(l > r) return ;
    // CAUTION!!! [lo, hi] cannot be real number, it must be the index of the array!!!
    // now doing intervals [l, r], the answer is in [lo, hi]
    // find the answer of mid = (l+r)/2
    int mid = l+r>>1, ans_mid = -1, lst = S.stn;
    // add in edges that in interval [l, mid], and satisfy length < lo (that is, number < lo
    for (int i=l; i<=mid; ++i) 
        if(q[i].id < lo) S.un(q[i].a, q[i].b);
    // add in edges from [lo] to [hi], and find the answer of mid
    for (int i=lo; i<=hi; ++i) {
        if(p[i].id <= mid) S.un(p[i].a, p[i].b);
        // if satisfy the condition
        if(S.check()) { ans_mid = i; break; }
    }
    while(S.stn > lst) S.re();
    if(ans_mid == -1) {
        // cannot find the answer of mid
        for (int i=l; i<=mid; ++i) ans[i] = -1;
        // add in edges that in interval [l, mid], and satisfy length < lo
        for (int i=l; i<=mid; ++i)
            if(q[i].id < lo) S.un(q[i].a, q[i].b);
        solve(mid+1, r, lo, hi);
        while(S.stn > lst) S.re();
        return ;
    }
    // set the answer of mid to ans_mid
    // so to interval [l, mid], the answer is [ans_mid, hi];
    //    to interval [mid+1, r], the answer is [lo, ans_mid].
    ans[mid] = p[ans_mid].l;
    // for the right side [mid+1, r], we can add in edges that in [l, mid], and satisfy length < lo.
    for (int i=l; i<=mid; ++i) 
        if(q[i].id < lo) S.un(q[i].a, q[i].b);
    solve(mid+1, r, lo, ans_mid);
    while(S.stn > lst) S.re();
    // for the left side [l, mid], we can add in edges that satisfy length < ans_mid, and in [1, l)
    for (int i=lo; i<ans_mid; ++i)
        if(p[i].id < l) S.un(p[i].a, p[i].b);
    solve(l, mid-1, ans_mid, hi);
    while(S.stn > lst) S.re();
}
    
            
    

int main() {
    cin >> n >> m; S.set(n); 
    if(n & 1) {
        while(m --) puts("-1");
        return 0;
    }
    for (int i=1; i<=m; ++i) {
        scanf("%d%d%d", &q[i].a, &q[i].b, &q[i].l);
        p[i] = q[i]; p[i].id = i;
    }
    
    sort(p+1, p+m+1);    
    
    for (int i=1; i<=m; ++i) q[p[i].id].id = i;
    
    solve(1, m, 1, m);
    
    for (int i=1; i<=m; ++i) printf("%d\\n", ans[i]);
    
    return 0;
}
 
View Code

 

以上是关于Codeforces 603E Pastoral Oddities的主要内容,如果未能解决你的问题,请参考以下文章

[Codeforces 603E]Pastoral Oddities(LCT)

Codeforces603E - Pastoral Oddities

603E

做题cf603E——线段树分治

CF603EPastoral Oddities cdq分治+并查集

迅雷路由器的功能配置