【20200205】【jwh】CF 1268E Happy Cactus （还没A掉）

Sad Cactus…

题意

一棵n点m边仙人掌，每条边有1到m的互不相同的权
点u可以到达点v的条件是存在一条u到v的路径，路径上边权递增

做法

如果是树就直接按边权递减遂一合并就行，但是题中给的是仙人掌，这样可能会发生重复计数（因为在连接某条边之前，该边的两端点就可能到达同一个点）
需要按照300iq题解里提到的方法去重，具体做法是，如果端点a和b可以同时到达环上的另一个点p（可能为a和b），那么p可到达的部分就被重复计数了，要减去
（然而我过了一堆大样例后wa在了另一个大样例上）

代码（未AC，并且奇丑无比）

#include<bits/stdc++.h>

#define dbg(x) cerr<<#x<<" is "<<x<<endl

using namespace std;

typedef long long ll;

const int maxn = 5e5 + 9;

vector<int> to[maxn];
int u[maxn], v[maxn];
vector<int> ring[maxn];
int f[maxn];
int po[maxn];
int sece[maxn];
int n, m;

int gt(int ord, int from) {
    if (u[ord] == from)return v[ord];
    return u[ord];
}

void init() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u[i], &v[i]);
        to[u[i]].push_back(i);
        to[v[i]].push_back(i);
    }
}

int sta[maxn];
int top;
int vis[maxn];
int lb;

inline int nt(int len, int p) {
    return (p + 1) % len;
}

inline int bf(int len, int p) {
    return (p - 1 + len) % len;
}

int dep[maxn];

void dfs(int now, int fa) {
    vis[now] = -1;
    dep[now] = dep[fa] + 1;
    for (int o:to[now]) {
        int t = gt(o, now);
        if (t == fa)continue;
        sta[top++] = o;
        if (!vis[t]) {
            dfs(t, now);
        } else {
            int len = dep[now] - dep[t] + 1;
            int mn = o, mx = o, pmn = 0, pmx = 0;
            for (int i = 0; i < len; i++) {
                int pos = top - i - 1;
//                dbg(sta[pos]);
                ring[lb].push_back(sta[pos]);
                if (mn > sta[pos]) {
                    mn = sta[pos];
                    pmn = i;
                }
                if (mx < sta[pos]) {
                    mx = sta[pos];
                    pmx = i;
                }
            }
//            dbg(len);
//            dbg(mn);
//            dbg(mx);
//            dbg(pmn);
//            dbg(pmx);
            int fl = 0;
            for (int i = pmn; i != pmx; i = nt(len, i)) {
                if (ring[lb][i] > ring[lb][nt(len, i)]) {
                    fl = 1;
//                    dbg(i);
                    break;
                }
            }
            for (int i = pmx; i != pmn; i = bf(len, i)) {
                if (ring[lb][i] < ring[lb][bf(len, i)]) {
                    fl = 1;
//                    dbg(i);
//                    dbg(bf(len, i));
                    break;
                }
            }
            if (!fl) {
//                dbg(mn);
//                dbg(mx);
                sece[mn] = mx;
            }
            lb++;
        }
        top--;
    }
    vis[now] = 1;
}

int main() {
    init();
    memset(sece, -1, sizeof(sece));
    dfs(1, 0);
    for (int i = 1; i <= n; i++) {
        po[i] = 1;
    }
    for (int i = m - 1; i >= 0; i--) {
        if (sece[i] < 0) {
            f[i] = po[u[i]] = po[v[i]] = po[u[i]] + po[v[i]];
        } else {
//            dbg(i);
//            dbg(sece[i]);
            f[i] = po[u[i]] = po[v[i]] = po[u[i]] + po[v[i]] - f[sece[i]];
        }
    }
//    dbg(lb);
    for (int i = 1; i <= n; i++) {
        printf("%d ", po[i] - 1);
    }
    return 0;
}