各种OJ刷题记录6.27-7.6
6175. 「美团 CodeM 初赛 Round B」黑白树
之前一道题的增强版…
考虑所有 ki 都相等,则可以从深度由深到浅贪心,如果还没有被覆盖就从这个节点覆盖上去。
但对于 ki 不同是有反例的:
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→T ,一个观测点 j 观测到的条件是:
也就是 depth[S]=depth[j]+W[j] 。因而一个向上的路径的贡献就是其路径上 depth+W 为定值的点。可以在 S 打一个
#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