2021牛客多校6

H-Hopping Rabbit（扫描线）

题目： 在一个二维平面上，有若干个大小异同的陷阱，有一个人，它的步幅为 $d$ ，它可以在这个无限平面中到处跑，问是否存在一个起点，它能以步幅为 $d$ 到处移动而不掉进陷阱。

思路： 因为步幅为 $d$ ，那么所有点都可以映射到一个 $d\ast d$ 的正方形中，那么可以将所有的陷阱映射到同一个 $d\ast d$ 的正方形中，然后要求的就变成在这个 $d\ast d$ 的矩阵中是否存在一个空点（没有陷阱映射到的点）。

一开始，想用二维树状数组，但是发现，二维区间修改后，你去查询时会非常得不方便，然后，我们就想用线段树套线段树，突然发现，根本不会，网上找板子，发现没有动态开点的写法，空间根本开不下，最后，突然发现扫描线可以求，只要在扫的过程中，发现有当前行的长度 $<d$，并且当前行的高度和下一行的高度不同（存在一个高），那么就记录当前行的高度$hh$，并跳出。最后将高度小于等于 $hh$ 的所有线段贡献，差分一下，求一个前缀和。得到的前缀和中，存在 $0$ 的位置就是空点的横坐标，加上记录的高度 $hh$ 就是答案。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
using namespace std;

const int N = 2e5 + 10;

ll x[N * 8];

struct Line {
    ll l, r, h;
    int mark;
    Line() {}
    Line(ll _l, ll _r, ll _h, int m) {
        l = _l; r = _r, h = _h; mark = m;
    }
    bool operator<(const Line& v) const {
        return h < v.h;
    }
}li[N * 8];

#define ls (rt << 1)
#define rs ((rt << 1) | 1)
struct SegTree{
    int l, r, cnt;
    ll len; //覆盖长度
}tr[N * 8];

void build(int l, int r, int rt) {
    tr[rt].l = l; tr[rt].r = r;
    tr[rt].cnt = 0;
    tr[rt].len = 0;
    if (l == r) {
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, ls);
    build(mid + 1, r, rs);
}

void pushup(int rt) {
    int l = tr[rt].l, r = tr[rt].r;
    if (tr[rt].cnt) tr[rt].len = x[r + 1] - x[l];
    else tr[rt].len = tr[ls].len + tr[rs].len;
}

void modify(ll st, ll ed, int rt, int v) {
    int l = tr[rt].l, r = tr[rt].r;
    if (x[r + 1] <= st || ed <= x[l])
        return;
    if (st <= x[l] && x[r + 1] <= ed) {
        tr[rt].cnt += v;
        pushup(rt);
        return;
    }
    modify(st, ed, ls, v);
    modify(st, ed, rs, v);
    pushup(rt);
}

int cnt = 0;
void addline(ll x1, ll y1, ll x2, ll y2) {
    ++cnt;
    x[2 * cnt - 1] = x1;
    x[2 * cnt] = x2;
    li[2 * cnt - 1] = Line(x1, x2, y1, 1);
    li[2 * cnt] = Line(x1, x2, y2, -1);
}

int main () {
    ll n, d;
    scanf("%lld%lld", &n, &d);
    cnt = 0;
    bool f = true;
    ll add = 1e9 * d;
    for (int i = 1; i <= n; i++) {
        ll x1, x2, y1, y2;
        scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);
        x1 += add;
        x2 += add;
        y1 += add;
        y2 += add;
        if (x2 - x1 >= d && y2 - y1 >= d) f = false;
        if (!f) continue;
        x1 = (x1) % d;
        x2 = (x2 - 1) % d + 1;
        y1 = (y1) % d;
        y2 = (y2 - 1) % d + 1;
//        cout << x1 << ", " << y1 << "    " << x2 << ", " << y2 << "\n";
        if (x1 < x2) {
            if (y1 < y2) {
                addline(x1, y1, x2, y2);
            }
            else if (y1 > y2) {
                addline(x1, y1, x2, d);
                addline(x1, 0, x2, y2);
            }
            else {
                addline(x1, 0, x2, d);
            }
        }
        else if (x1 > x2){
            if (y1 < y2) {
                addline(x1, y1, d, y2);
                addline(0, y1, x2, y2);
            }
            else if (y1 > y2) {
                addline(x1, y1, d, d);
                addline(0, 0, x2, y2);
                addline(0, y1, x2, d);
                addline(x1, 0, d, y2);
            }
            else {
                addline(x1, 0, d, d);
                addline(0, 0, x2, d);
            }
        }
        else {
            if (y1 < y2) {
                addline(0, y1, d, y2);
            }
            else if (y1 > y2) {
                addline(0, y1, d, d);
                addline(0, 0, d, y2);
            }
            else {
                f = false;
            }
        }
    }
    if (!f) {
        printf("NO\n");
        return 0;
    }
//    for (int i = 1; i <= 2 * cnt; i++) {
//        printf("%lld %lld %lld\n", li[i].l, li[i].r, li[i].h);
//    }
    sort(li + 1, li + 1 + 2 * cnt);
    sort(x + 1, x + 1 + 2 * cnt);
    int tot = unique(x + 1, x + 1 + 2 * cnt) - x - 1;
    build(1, tot - 1, 1);
    int hh = -1;
    li[2 * cnt + 1] = Line(0, d, d, 1); // 剩余部分还有空间
    li[0] = Line(0, d, 0, 0);           // 开始部分空出
    for (int i = 0; i <= 2 * cnt; i++) {
        modify(li[i].l, li[i].r, 1, li[i].mark);
        ll len = tr[1].len;
        ll h = li[i + 1].h - li[i].h;
//        cout << len << " " << h << "\n";
        if (len < d && h > 0) {
            hh = li[i].h;
            break;
        }
    }
    if (hh == -1) {
        printf("NO\n");
    }
    else {
        vector<ll> a(d + 5, 0);
        for (int i = 1; i <= 2 * cnt; i++) {
            if (li[i].h <= hh) {
                a[li[i].l] += li[i].mark;
                a[li[i].r] -= li[i].mark;
            }
        }
        for (int i = 1; i < d; i++)
            a[i] += a[i - 1];
        bool ok = false;
        int xx;
        for (int i = 0; i < d && !ok; i++) {
            if (a[i] == 0) ok = true, xx = i;
        }
        if (ok) {
            printf("YES\n");
            printf("%d %d\n", xx, hh);
        }
        else printf("NO\n");
    }

    return 0;
}

J-Defend Your Country（tarjan，割点）

题目： 给定一个无向连通图，每个点有一个点权，对于一个连通块的贡献：$(-1{)}^{\text{连通块的点数}}\times \sum a[i]$，现在你可以删除若干条边，使得最后各个连通块的贡献和最大。

思路：

因为给定的图是一个连通图，若当前的点数为偶数，直接输出权值之和。

若点数是奇数，找到一个点并删去，那么删去该点所有的边后，得到的结果为 $sum-2\times w_i$

需要注意的是，如果该点是割点，要判断，该点删除后，得到的连通分量是否都是偶数。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 2e6 + 10;
const int M = 2e6 + 10;

int n, m;
int a[N];
ll sum, ans;

struct edge{
    int v;
    int nxt;
}es[M];
int head[N], tot;
int dfn[N], low[N], sz[N], dfs_cnt;
int cut[N]; // 标记是否是割点
void init(int _n) {
    tot = 0;
    dfs_cnt = 0;
    sum = 0;
    ans = 0;
    for (int i = 0; i <= _n; i++) {
        head[i] = -1;
        dfn[i] = low[i] = 0;
        sz[i] = 0;
        cut[i] = 0;
    }
}

void add_edge(int u, int v) {
    tot++;
    es[tot].v = v;
    es[tot].nxt = head[u];
    head[u] = tot;
}

void tarjan(int u, int fa, int root) {
    dfn[u] = ++dfs_cnt;
    low[u] = dfs_cnt;
    sz[u] = 1;
    int child = 0;
    bool ok = true;
    for (int i = head[u]; i != -1; i = es[i].nxt) {
        int v = es[i].v;
        if (v == fa) continue;
        if (dfn[v]) {
            low[u] = min(low[u], dfn[v]);
        }
        else {
            tarjan(v, u, root);
            low[u] = min(low[u], low[v]);
            sz[u] += sz[v];
//            if ((sz[v] & 1) && low[v] >= dfn[u]) ok = false;
            if (low[v] >= dfn[u] && (u != root || ++child > 1)) {
                cut[u] = 1;
                if (sz[v] & 1) ok = false;
                // 因为已经特判过了（总结点个数是奇数）,去掉节点u，
                // 子节点联通分量大小如果都是偶数，
                // 那么割点 u 前的连通分量大小肯定也是偶数
            }
        }
    }
    if (ok) ans = max(ans, sum - 2LL * a[u]);
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n, &m);
        init(n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            sum += 1LL * a[i];
        }
        for (int i = 1; i <= m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            add_edge(u, v);
            add_edge(v, u);
        }
        if (n & 1) {
            tarjan(1, 0, 1);
            printf("%lld\n", ans);
        }
        else {
            printf("%lld\n", sum);
        }
    }
    return 0;
}