20210716 noip17
考场
终于有一场在晚上考了
T1 随便画了画就发现要求每个点的后继个数，想起来有 dfs 和 toposort 两种方法，感觉很稳
T2 裸的网络流有 70pts？！真香
一看 T3 就想起了 Mst，随便建个 MST 然后枚举非树边在树上搞搞就行了，画了画图发现可行（但心里对这个算法对正确性并不太肯定）。在树剖+线段树和 LCT 之间选择了 LCT，毕竟刚背了 LCT少个 \(\log\)
感觉这次题都比较可做，暴力分也很多，rk1 可能要 250+，决定冲 T3 的数据结构
19.00 就开始写了，绝望的发现 T1 不会做，先写了暴力 bitset，发现极限数据也跑得挺快，就是会 MLE。尝试 dfs 出一颗生成树，然后树上差分，画了画图发现不行。不管了
T2 飞快写完 ISAP，一遍过样例。部分分太香+着急写 T3 就没多想。又回头看 T1，仔细回想 受欢迎的牛 和 bitset 水过去的 连通数，悔不当初。（当时以为有 \(O(n)\) 在 DAG 上 DP 的方法）
19.40 终于开始写 T3，先后经历了 CE WA RE，20.50 过样例，想了想还是写了对拍，但只是把树上更新的部分换成了暴力跳 fa，只能拍出 LCT 有没有写挂，算法正确性无法保证（不会写其他暴力）。结果从 9.10 开始拍，LCT 和暴力轮流挂，直到快 9.30 才稳定拍上，最终只拍了一百多组。此时发现 T1 还有图退化成树的 20pts 没写，Rush 了 10min 写完了，在结束前 40s 提交。
ycx 说听到我一直在敲键盘。。。今天默板子是真爽
res
rk1 40+60+100
T1 树的分还是没拿到（默认了根是 \(1\)）
T2 挂了第 1 个点（由于存边的数组开了 \(N*N\)，因此 \(N\) 没敢开大，而第一个点恰好是 \(n=1,m=5\times10^4\)）
rk3 ycx 60+70+30
rk4 贾一丰 40+100+0
世界线
正解就是 bitset。。。
防止被卡空间要开成 bitset<N/2> siz[N];，然后每次只在 bitset 中转移一半点。
code
const int N = 6e4+1;
int n,m;
vector<int> to[N];
int nn;
LL ans;
bool vis[N];
bitset<30001> siz[N];
void dfs(int u,bool op) {
if( vis[u] ) return;
vis[u] = 1;
if( !op && u <= nn ) siz[u][u] = 1;
else if( op && u > nn ) siz[u][u-nn] = 1;
for(int v : to[u]) {
dfs(v,op);
siz[u] |= siz[v];
}
}
signed main() {
read(n,m); nn = n/2;
For(i,1,m) {
int x,y; read(x,y);
to[x].pb(y);
}
For(i,1,n) dfs(i,0);
For(i,1,n) ans += siz[i].count(), siz[i].reset();
mem(vis,0,n);
For(i,1,n) dfs(i,1);
For(i,1,n) ans += siz[i].count();
write(ans-n-m);
return ioclear();
}
时间机器
贪心。
按 \(low\) 从小到大考虑每个结点，每次在 \(l\le low\) 的电阻中匹配 \(high\le r\) 且 \(r\) 最小的，暴力是 \(O(nm)\) 的，可以用 set 或权值线段树优化这个查找的过程。
显然 set 中可能有重复元素，要开 multiset，但实测不开可过。hack：
Input:
1
2 2
1 2 1
1 2 1
1 2 1
1 2 1
Output:
Yes
code
const int N = 5e4+5;
int T,n,m;
struct Node {
int l,r,n;
} a[N],b[N];
bool operator < (const Node &x,const Node &y) { return x.l < y.l; }
struct Rest {
int r;
mutable int n;
Rest(int r=0,int n=0):r(r),n(n){}
};
bool operator < (const Rest &x,const Rest &y)
{ return x.r!=y.r ? x.r<y.r : x.n<y.n; }
multiset<Rest> s;
void solve() {
read(n,m);
For(i,1,n) read(a[i].l,a[i].r,a[i].n);
For(i,1,m) read(b[i].l,b[i].r,b[i].n);
sort(a+1,a+n+1), sort(b+1,b+m+1);
for(int i = 1, j = 1; i <= n; ++i) {
for(; j <= m && b[j].l <= a[i].l; ++j) s.insert(Rest(b[j].r,b[j].n));
while( a[i].n ) {
auto it = s.lower_bound(Rest(a[i].r,0));
if( it == s.end() ) { puts("No"); return; }
if( it->n > a[i].n ) { it->n -= a[i].n; break; }
a[i].n -= it->n, s.erase(it);
}
}
puts("Yes");
}
signed main() {
read(T);
while( T-- ) {
s.clear();
solve();
}
return 0;
}
weight
正确性：断开一条树边后形成两个连通块，考虑连接这两个连通块的边何时一定比其它边优
我的 LCT 常数爆炸，被树剖+线段树吊打。。。
考场 code
const int N = 7e4+5, M = 1e5+5, inf = 0x7fffffff;
int n,m,Type;
struct Edge {
int u,v,w,id;
} e[M];
int fa[N],ans[M];
bool vis[M];
int find(int x) { return fa[x]==x ? x : fa[x]=find(fa[x]); }
#define ls(x) t[x].ch[0]
#define rs(x) t[x].ch[1]
struct Node {
int fa,ch[2],val,mx,ans,tag;
bool rev;
} t[N+M];
class LCT {
private:
bool nrt(int u) { return ls(t[u].fa)==u || rs(t[u].fa)==u; }
void up(int u) { t[u].mx = max(max(t[ls(u)].mx,t[rs(u)].mx),t[u].val); }
void rev(int u) { swap(ls(u),rs(u)), t[u].rev ^= 1; }
void down(int u,int x)
{ t[u].ans = min(t[u].ans,x), t[u].tag = min(t[u].tag,x); }
void down(int u) {
if( t[u].rev ) {
rev(ls(u)), rev(rs(u));
t[u].rev = 0;
}
down(ls(u),t[u].tag), down(rs(u),t[u].tag), t[u].tag = inf;
}
bool which(int u) { return rs(t[u].fa) == u; }
void rotate(int x) {
int y = t[x].fa, z = t[y].fa, k = which(x), w = t[x].ch[!k];
if( nrt(y) ) t[z].ch[which(y)] = x;
t[y].ch[k] = w, t[x].ch[!k] = y;
if( w ) t[w].fa = y;
t[y].fa = x, t[x].fa = z;
up(y);
}
void splay(int u) {
static int stk[N+M];
int tp = 1, v = stk[1] = u;
while( nrt(v) ) stk[++tp] = v = t[v].fa;
while( tp ) down(stk[tp--]);
for(int fa; fa = t[u].fa, nrt(u); rotate(u))
if( nrt(fa) ) rotate(which(u)==which(fa)?fa:u);
up(u);
}
void access(int x) {
for(int u = x, v = 0; u; u = t[ v=u ].fa)
splay(u), rs(u) = v, up(u);
splay(x);
}
public:
void makert(int u) { access(u), rev(u); }
int findrt(int u) {
access(u);
while( ls(u) ) down(u), u = ls(u);
splay(u);
return u;
}
void link(int u,int v) { makert(u), splay(v), t[u].fa = v; }
void split(int u,int v) { makert(u), access(v); }
} lct;
signed main() {
// freopen("c.in","r",stdin);
// freopen("c.out","w",stdout);
read(n,m,Type);
For(i,1,n) fa[i] = i;
For(i,1,m) {
read(e[i].u,e[i].v,e[i].w), e[i].id = i;
fa[find(e[i].u)] = find(e[i].v);
}
sort(e+1,e+m+1,[](const Edge &x,const Edge &y){return x.w<y.w;});
t[0].mx = -inf;
For(i,1,n+m) t[i].val = -inf, t[i].tag = inf;
For(i,1,m) if( find(e[i].u) == find(1) ) {
if( lct.findrt(e[i].u) == lct.findrt(e[i].v) ) continue;
vis[i] = 1;
t[n+i].val = e[i].w, t[n+i].ans = inf;
lct.link(e[i].u,n+i), lct.link(e[i].v,n+i);
}
For(i,1,m) {
int u = e[i].u, v = e[i].v;
if( find(u) != find(1) || vis[i] ) continue;
lct.split(u,v);
ans[e[i].id] = t[v].mx-1, t[v].tag = e[i].w-1;
}
For(i,1,m) if( vis[i] ) lct.makert(n+i), ans[e[i].id] = t[n+i].ans;
For(i,1,m) write(ans[i]==inf ? -1 : ans[i], ' ');
return ioclear();
}
考场上写挂的地方：
nrt(u) 判断 u 是否是 splay 的根
access 时先 splay
findrt 时先 access
操作完记得 splay
存答案的数组要开到边数
