各种OJ刷题记录6.27-7.6

最新推荐文章于 2020-01-06 01:03:21 发布

VIP文章 OIljt12138

最新推荐文章于 2020-01-06 01:03:21 发布

阅读量927

点赞数

分类专栏： bzoj OI

本文链接：https://blog.csdn.net/oiljt12138/article/details/73929041

版权

各种OJ刷题记录6.27-7.6

6175. 「美团 CodeM 初赛 Round B」黑白树

之前一道题的增强版…

考虑所有 $k_i$ 都相等，则可以从深度由深到浅贪心，如果还没有被覆盖就从这个节点覆盖上去。

但对于 $k_i$ 不同是有反例的：

http://blog.csdn.net/mengxiang000000/article/details/73718867

考虑先用一边dfs记录子树中覆盖当前节点最浅到哪里，计为 $low\_dep[nd]$ 。考虑到一个未被覆盖的节点 $nd$ 时，覆盖掉 $low\_dep[nd]..nd$ 中所有的节点，并 $cnt++$ 即可。

没太看懂神犇们的高端写法…只好大力树剖+树状数组维护了。

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;

struct node {
    int to, next;
} edge[MAXN];
int head[MAXN], top = 0;
inline void push(int i, int j)
{ edge[++top] = (node) {j, head[i]}, head[i] = top; }

int siz[MAXN], id[MAXN], ind[MAXN], id_in_ds = 0;
int c[MAXN];
int n;

int ki[MAXN];

int depth[MAXN], fa[MAXN][20];
int low_dep[MAXN];

int dfn[MAXN], dfn_top = 0;

inline int lowbit(int i)
{ return i&(-i); }
void modify(int i, int dt)
{
    for (; i <= n; i += lowbit(i))
        c[i] += dt;
}
void cover(int i, int j)
{ modify(i, 1), modify(j+1, -1); }
int dat(int i)
{
    int ans = 0;
    for (; i; i -= lowbit(i))
        ans += c[i];
    return ans;
}


int kth_ans(int nd, int k)
{
    if (k >= depth[nd]) k = depth[nd];
    for (register int i = 0; i < 20; i++)
        if (k&(1<<i))
            nd = fa[nd][i];
    return nd;
}

void dfs_init(int nd)
{
    siz[nd] = 1;
    for (register int i = 1; i < 20; i++)
        fa[nd][i] = fa[fa[nd][i-1]][i-1];
    low_dep[nd] = kth_ans(nd, ki[nd]-1);
    for (int i = head[nd]; i; i = edge[i].next) {
        depth[edge[i].to] = depth[nd]+1;
        dfs_init(edge[i].to), siz[nd] += siz[edge[i].to];
        if (depth[low_dep[edge[i].to]] < depth[low_dep[nd]])
            low_dep[nd] = low_dep[edge[i].to];
    }
    dfn[++dfn_top] = nd;
}

inline bool cmp(int a, int b)
{ return depth[a] > depth[b]; }

void dfs_build(int nd, int from)
{
    id[nd] = ++id_in_ds, ind[nd] = from;
    int hev = -1;
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (hev == -1 || siz[to] > siz[hev]) hev = to;
    }
    if (hev == -1) return;
    dfs_build(hev, from);
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to != hev) dfs_build(to, to);
    }
}

void cover_point(int nd, int pt)
{
    while (depth[ind[nd]] > depth[pt]) {
        cover(id[ind[nd]], id[nd]);
        nd = fa[ind[nd]][0];
    }
    if (depth[nd] >= depth[pt]) cover(id[pt], id[nd]);
}

int main()
{
    scanf("%d", &n);
    for (int i = 2; i <= n; i++) 
        scanf("%d", &fa[i][0]), push(fa[i][0], i);
    for (int i = 1; i <= n; i++) scanf("%d", &ki[i]);
    dfs_init(1);
    dfs_build(1, 1);
    int cnt = 0;
    for (int i = 1; i <= n; i++) {
        int pt = dfn[i];
        if (dat(id[pt]) != 0) continue;
        int anc = low_dep[pt];
        cover_point(pt, anc), cnt++;
    }
    printf("%d\n", cnt);
    return 0;
}

loj#112. 三维偏序

填坑…

不知道为什么印象特别深刻去年一次NOIP模拟赛建出二维数点模型，然后Too Naive，并不会做…一直向转化成逆序对…学习了一个偏序那套理论才知道Too Simple..

经典题，一维排序，二维归并，三维树状数组。

注意check一下相同的情况。

#include <bits/stdc++.h>
using namespace std;

inline int read()
{
    int a = 0, c;
    do c = getchar(); while(!isdigit(c));
    while (isdigit(c)) {
        a = a*10+c-'0';
        c = getchar();
    }
    return a;
}

const int MAXN = 100005;
struct pt {
    int x, y, z, id;
} pts[MAXN], tmp[MAXN];

int n, k;

inline bool cmp_x(const pt &a, const pt &b)
{ return a.x < b.x; }
inline bool cmp_y(const pt &a, const pt &b)
{ return a.y < b.y; }

int ans[MAXN];

int c[MAXN*2];

inline int lowbit(int i)
{ return i&(-i); }
void modify(int i, int dt)
{
    for (; i <= k; i += lowbit(i))
        c[i] += dt;
}
int sum(int i)
{
    int ans = 0;
    for (; i; i -= lowbit(i))
        ans += c[i];
    return ans;
}

void solve(int l, int r, int L, int R)
{
    if (l >= r) return;
    L = pts[l].x, R = pts[r].x;
    if (L == R) {
        sort(pts+l, pts+r+1, cmp_y);
        int lp = l, rp = l;
        while (lp <= r) {
            while (rp+1 <= r && pts[rp+1].y == pts[lp].y) rp++;
            for (int i = lp; i <= rp; i++) 
                    modify(pts[i].z, 1);
            for (int i = lp; i <= rp; i++)
                ans[pts[i].id] += sum(pts[i].z)-1;
            lp = rp = rp+1;
        }
        for (int i = l; i <= r; i++) modify(pts[i].z, -1);
        return;
    }
    int MID = (L+R)>>1;
    int lp = l, rp = r;
    for (int i = l; i <= r; i++) {
        if (pts[i].x <= MID) tmp[lp++] = pts[i];
        else tmp[rp--] = pts[i];
    }
    int mid = lp-1;
    for (int i = l; i <= r; i++)
        pts[i] = tmp[i];
    solve(l, mid, L, MID), solve(mid+1, r, MID+1, R);
    lp = l, rp = mid+1;
    int tmp_l = l;
    while (lp <= mid && rp <= r) {
        if (pts[lp].y <= pts[rp].y) {
            modify(pts[lp].z, 1);
            tmp[tmp_l++] = pts[lp++];
        } else {
            ans[pts[rp].id] += sum(pts[rp].z);
            tmp[tmp_l++] = pts[rp++];
        }
    }
    while (lp <= mid) {
        modify(pts[lp].z, 1);
        tmp[tmp_l++] = pts[lp++];
    }
    while (rp <= r) {
        ans[pts[rp].id] += sum(pts[rp].z);
        tmp[tmp_l++] = pts[rp++];
    }
    for (int i = l; i <= mid; i++) modify(pts[i].z, -1);
    for (int i = l; i <= r; i++) pts[i] = tmp[i];
}

int d[MAXN];
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
        pts[i].x = read(), pts[i].y = read(), pts[i].z = read(), pts[i].id = i;
    sort(pts+1, pts+n+1, cmp_x);
    solve(1, n, 1, k);
    for (int i = 1; i <= n; i++)
        d[ans[i]]++;
    for (int i = 0; i < n; i++)
        printf("%d\n", d[i]);
    return 0;
}

NOIP2016 天天爱跑步

填一下这个坑….

考虑向上的路径 $S\rightarrow T$ ，一个观测点 $j$ 观测到的条件是：

d e p t h [S] - d e p t h [j] = W [j], j \in {S \to T}

$depth[S]-depth[j] = W[j] , j \in \{S\rightarrow T\}$

也就是 $depth[S] = depth[j]+W[j]$ 。因而一个向上的路径的贡献就是其路径上 $depth+W$ 为定值的点。可以在 $S$ 打一个 $(depth[S], 1)$ 标记， $T$ 打一个 $(depth[S], -1)$ 标记。反过来看，对于一个观测点，查询的其实就是子树中所有 $(depth[j]+W[j], 1)$ 标记个数减去 $(depth[j]+W[j], -1)$ 标记个数。这可以用 $dfs$ 序+可持久化数组来维护，后者可以使用可持久化线段树或者可持久化平衡树实现(rope也可以)，复杂度 $O(n\lg n)$ ，理论能拿到95分，然而在Cogs只80…后面还是RE…



#include <bits/stdc++.h>
#include <ext/rope>

using namespace __gnu_cxx;
using namespace std;

const int MAXN = 300005;

struct node {
    int to, next;
} edge[MAXN*2];
int head[MAXN], top = 0;
inline void push(int i, int j)
{ edge[++top] = (node){j, head[i]}, head[i] = top; }

int depth[MAXN], W[MAXN];

int u[MAXN*2], v[MAXN*2], id[MAXN*2];
int n, m;
int lca[MAXN], vis[MAXN];
int fa[MAXN], father[MAXN], ans[MAXN];
inline int findf(int nd)
{ return fa[nd]?fa[nd]=findf(fa[nd]):nd; }

inline int read()
{
    int a = 0, c;
    do c = getchar(); while(!isdigit(c));
    while (isdigit(c)) {
        a = a*10+c-'0';
        c = getchar();
    }
    return a;
}

vector<int> pt[MAXN];

struct tag {
    int dat;
    int tp;
};
vector<tag> tag_up[MAXN], tag_down[MAXN];

void dfs_init(int nd, int f)
{
    vis[nd] = 1, father[nd] = f;
    for (vector<int>::iterator i = pt[nd].begin(); i != pt[nd].end(); ++i)
        if (vis[v[*i]]) {
            lca[id[*i]] = findf(v[*i]);
        }
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to == f) continue;
        depth[to] = depth[nd]+1, dfs_init(to, nd);
    }
    fa[nd] = f;
}

void put_tag()
{
    for (int i = 1; i <= m; i++) {
        int c = lca[i], s = u[i], t = v[i];
        if (c == t) {
            tag_up[s].push_back((tag){depth[s], 1});
            tag_up[father[c]].push_back((tag){depth[s], -1});
        } else if (c == s) {
            tag_down[t].push_back((tag){-depth[s], 1});
            tag_down[father[c]].push_back((tag){-depth[s], -1});
        } else {
            tag_up[s].push_back((tag){depth[s], 1});
            tag_up[father[c]].push_back((tag){depth[s], -1});
            int beg = depth[s]-depth[c];
            tag_down[t].push_back((tag){beg-depth[c], 1});
            tag_down[c].push_back((tag){beg-depth[c], -1});
        }
    }
}

int dfn[MAXN], dfn_top = 0, out[MAXN];

struct my_array {
    rope<int> *arr[MAXN];
    int range_l, range_r, lev;
    void build()
    {
        arr[0] = new rope<int>;
        lev = 0;
        for