[练习记录]优化基础技巧
二分系列
对于凸函数的二分
略。
分数规划
[USACO18OPEN]Talent Show G
这类带限制的分数规划直接按其限制\(dp\)即可。
[USACO18OPEN]Talent Show G
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
#define N 255
#define M 1005
int n;
int w[N],t[N];
int W;
struct P{
int wi;
double key;
}e[N];
bool operator < (P a,P b){
return a.key > b.key;
}
double f[N][M];
inline bool check(double mid){
for(int i = 1;i <= n;++i)
e[i].wi = w[i],e[i].key = 1.0 * t[i] - mid * w[i];
std::sort(e + 1,e + n + 1);
int noww = 0;
double nowt = 0;
int k = 0;
for(int i = 1;i <= n;++i)
if(e[i].key > 0){
noww += e[i].wi;
nowt += e[i].key;
}else{
k = i;
break;
}
// std::cout<<mid<<std::endl;
// std::cout<<noww<<" "<<nowt<<std::endl;
if(noww >= W)
return 1;
std::memset(f,-0x7f,sizeof(f));
f[k - 1][0] = 0;
for(int i = k;i <= n;++i)
for(int j = 1;j <= W;++j){
f[i][j] = f[i - 1][j];
f[i][j] = std::max(f[i][j],f[i - 1][std::max(0,j - e[i].wi)] + e[i].key);
}
for(int j = W - 1;j >= 1;--j)
f[n][j] = std::max(f[n][j],f[n][j + 1]);
// std::cout<<mid<<std::endl;
// std::cout<<noww<<" "<<nowt<<" "<<std::endl;
return (f[n][W - noww] + nowt) >= 0;
}
int main(){
scanf("%d%d",&n,&W);
for(int i = 1;i <= n;++i)
scanf("%d%d",&w[i],&t[i]);
double l = 0.0,r = 1000.0;
double ans = 0;
#define mid ((l + r) * .5)
for(int i = 1;i <= 500;++i){
if(check(mid))
ans = mid,l = mid;
else
r = mid;
}
// std::cout<<check(1.06)<<std::endl;
std::cout<<(int)(1000 * ans)<<std::endl;
}
[JSOI2016]最佳团体
树上\(dp\)处理检查。
[JSOI2016]最佳团体
#include<algorithm>
#include<cstdio>
#define FIO "team"
using namespace std;
int n,k,tot,s[2510],p[2510],r[2510],head[2510],nxt[2510],to[2510],size[2510];
double L,R=3.0,mid,eps=1e-5,f[2510][2510],F[2510];
void add(int x)
{
nxt[++tot]=head[r[x]],head[r[x]]=tot,to[tot]=x;
}
void dfs(int x)
{
size[x]=1,f[x][1]=p[x]-s[x]*mid;
for(int i=head[x];i;i=nxt[i]){
dfs(to[i]);
for(int j=1;j<=size[x]+size[to[i]];j++) F[j]=-1e9;
for(int j=1;j<=size[x];j++) for(int k=0;k<=size[to[i]];k++) F[j+k]=max(F[j+k],f[x][j]+f[to[i]][k]);
for(int j=1;j<=size[x]+size[to[i]];j++) f[x][j]=F[j];
size[x]+=size[to[i]];
}
}
int pd()
{
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) f[i][j]=-1e9;
dfs(0);
return f[0][k+1]<=0;
}
int main()
{
//freopen(FIO".in","r",stdin);
//freopen(FIO".out","w",stdout);
scanf("%d%d",&k,&n);
for(int i=1;i<=n;i++) scanf("%d%d%d",&s[i],&p[i],&r[i]),add(i);
while(L+eps<R){
mid=(L+R)/2.0;
if(pd()) R=mid;
else L=mid+eps;
}
printf("%.3lf",L);
}
[SDOI2017]新生舞会
发现我们二分之后。
变成了选取\(n\)对不交集合，权值最大。
费用流经典问题，要注意的是实数二分不用跑太多次，不然会喜提和暴力哥一样的成绩。
[SDOI2017]新生舞会
#include<bits/stdc++.h>
#define ll long long
#define N 210
int a[N][N];
int b[N][N];
int n;
struct P{
int to,next,v;
double c;
}e[N * N * 2];
int s,t;
int cnt = 1,head[N << 1];
inline void add(int x,int y,int v,double c){
e[++cnt].to = y;
e[cnt].next = head[x];
e[cnt].v = v;
e[cnt].c = c;
head[x] = cnt;
}
bool vis[N];
double minc[N];
int minv[N],pre[N];
std::queue<int>QWQ;
inline bool spfa(){
for(int i = 1;i <= (n << 1) + 2;++i)
minc[i] = minv[i] = 0x3f3f3f3f,vis[i] = 0,pre[i] = 0;
QWQ.push(s);
vis[s] = 1;
minc[s] = 0;
while(!QWQ.empty()){
int u = QWQ.front();
// std::cout<<u<<" "<<pre[u]<<" "<<e[pre[u] ^ 1].to<<std::endl;
QWQ.pop();
vis[u] = 0;
for(int i = head[u];i;i = e[i].next){
ll v = e[i].to;
// std::cout<<"->"<<v<<std::endl;
if(e[i].v && minc[v] > minc[u] + e[i].c){
minv[v] = std::min(minv[u],e[i].v);
minc[v] = minc[u] + e[i].c;
pre[v] = i;
if(!vis[v])
vis[v] = 1,QWQ.push(v);
}
}
}
return minc[t] != 0x3f3f3f3f;
}
int ansv;
double ansc;
inline void EK(){
ansv = 0;
ansc = 0;
while(spfa()){
ansv += minv[t];
ansc += minc[t] * minv[t];
int now = t;
while(now != s){
e[pre[now]].v -= minv[t];
e[pre[now] ^ 1].v += minv[t];
now = e[pre[now] ^ 1].to;
}
}
}
inline bool check(double mid){
cnt = 1;
for(int i = 1;i <= (n << 1) + 10;++i)
head[i] = 0;
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j){
double k = a[i][j] * 1.0 - b[i][j] * mid;
add(i,j + n,1,-k);
add(j + n,i,0,k);
}
for(int i = 1;i <= n;++i)
add(s,i,1,0),add(i,s,0,0);
for(int i = n + 1;i <= n << 1;++i)
add(i,t,1,0),add(t,i,0,0);
EK();
return ansc <= 0;
}
int main(){
scanf("%d",&n);
s = n * 2 + 1;
t = n * 2 + 2;
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j)
scanf("%d",&a[i][j]);
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j)
scanf("%d",&b[i][j]);
double l = 0.0,r = 1e6;
double ans = 0;
#define mid ((l + r) * .5)
for(int i = 1;i <= 80;++i){
// std::cout<<l<<" "<<r<<std::endl;
if(check(mid))
ans = mid,l = mid;
else
r = mid;
}
printf("%.6f",ans);
}
凸优化
CF739E Gosha is hunting
被卡精度了./fn
考虑我们先做一个硬的三维\(f_{i,j,k}\)其转移显然。
此时我们可以发现固定后两维的一维，其对另一维是下凸函数，然后我们优化一维为凸优化，复杂度\(O(n^2log)\)
CF739E Gosha is hunting
#include<bits/stdc++.h>
#define ll long long
#define N 2005
int n,a,b;
double p[N],q[N];
struct P{double exp;int cnt;P(){exp = cnt = 0;}};//期望，使用第一种求的数量。
P f[N][N];
inline P cmax(P a,P b){
return a.exp < b.exp ? b : a;
}
inline void check(double mid){
for(int i = 1;i <= n;++i)
for(int j = 0;j <= std::min(i,b);++j){
f[i][j].exp = 0;
f[i][j].cnt = 0;
f[i][j] = f[i - 1][j];
P to;//转移
if(j > 0){
to.exp = f[i - 1][j - 1].exp + q[i],to.cnt = f[i - 1][j - 1].cnt;
// std::cout<<"case2 "<<to.exp<<" "<<to.cnt<<std::endl;
f[i][j] = cmax(f[i][j],to);
to.exp = f[i - 1][j - 1].exp + q[i] + p[i] - mid - p[i] * q[i],to.cnt = f[i - 1][j - 1].cnt + 1;
// std::cout<<"case3 "<<to.exp<<" "<<to.cnt<<std::endl;
f[i][j] = cmax(f[i][j],to);
}
to.exp = f[i - 1][j].exp + p[i] - mid,to.cnt = f[i - 1][j].cnt + 1;
// std::cout<<"case1 "<<to.exp<<" "<<to.cnt<<std::endl;
f[i][j] = cmax(f[i][j],to);
// std::cout<<i<<" "<<j<<" "<<f[i][j].exp<<" "<<f[i][j].cnt<<std::endl;
}
}
int main(){
scanf("%d%d%d",&n,&a,&b);
for(int i = 1;i <= n;++i)
scanf("%lf",&p[i]);
for(int i = 1;i <= n;++i)
scanf("%lf",&q[i]);
// for(int i = 1;i <= n;++i)
// std::cout<<p[i]<<" "<<q[i]<<std::endl;
double l = 0.0,r = 1;
#define mid ((l + r) * .5)
// check(0.375);
double fans = 0;
for(int i = 1;i <= 200;++i){
// std::cout<<l<<" "<<r<<std::endl;
check(mid);
// std::cout<<"!"<<mid<<" "<<f[n][b].exp<<" "<<f[n][b].cnt<<" "<<f[n][b].exp + f[n][b].cnt * mid<<std::endl;
if(f[n][b].cnt > a)
l = mid;
else
fans = std::max(f[n][b].exp + f[n][b].cnt * mid,fans),r = mid;
}
printf("%.12lf",fans);
}
[八省联考 2018] 林克卡特树
简要题意：在树上选取\(k + 1\)条链的权值总和最大。
该类树上选链的可以使用\(dp\),我们设\(f_{u,j,0/1/2}\)为\(u\)中有\(j\)条完整链，\(0\)表示\(u\)，\(0\)在子树背包合并时的点中表示其没被占据，子树背包合并结束时其意义改变为经过\(u\)的那条链在内部消化，或者\(u\)没被用，\(1\)表示其有一条链向父亲连，\(2\)表示子树背包有一条经过\(u\)的完整的内部消化链。
转移显然。
先给一个\(60\)分的直接\(dp\)代码。
其为\(O(n^2k)\)。
[八省联考 2018] 林克卡特树 sub1
#include<bits/stdc++.h>
#define ll long long
#define N 300005
#define K 200
int n,k;
int f[N][K][3];
struct P{
int to,next,v;
}e[N << 1];
int head[N],cnt;
void add(ll x,ll y,ll v){
e[++cnt].to = y;
e[cnt].next = head[x];
e[cnt].v = v;
head[x] = cnt;
}
void dfs(int u,int fa){
f[u][0][0] = f[u][0][1] = f[u][1][2] = 0;
for(int i = head[u];i;i = e[i].next){
int v = e[i].to;
if(v == fa)
continue;
dfs(v,u);
for(int j = k;j;--j){
f[u][j][1] = std::max(f[u][j][1],f[u][j][0] + f[v][0][1] + e[i].v);
for(int l = j - 1;~l;--l){
f[u][j][0] = std::max(f[u][j][0],f[u][l][0] + f[v][j - l][0]);
f[u][j][1] = std::max(f[u][j][1],std::max(f[u][l][1] + f[v][j - l][0],f[u][l][0] + f[v][j - l][1] + e[i].v));
f[u][j][2] = std::max(f[u][j][2],std::max(f[u][l][2] + f[v][j - l][0],f[u][l][1] + f[v][j - l - 1][1] + e[i].v));
}
}
f[u][0][1] = std::max(f[u][0][1],f[v][0][1] + e[i].v);
}
for(int i = 1;i <= k;++i)
f[u][i][0] = std::max(f[u][i][0],std::max(f[u][i - 1][1],f[u][i][2]));
}
int main(){
scanf("%d%d",&n,&k),++k;
for(int i = 1;i < n;++i){
ll x,y,v;
scanf("%lld%lld%lld",&x,&y,&v);
add(x,y,v);
add(y,x,v);
}
memset(f,~0x3f,sizeof(f));dfs(1,0);
std::cout<<f[1][k][0]<<std::endl;
}
然后猜想其对\(k\)有凸性，凸优化一下，但是好像没人证明这个结论，\(O(nlogk)\)。
分治系列
CDQ分治
平面最近点对（加强版）
考虑我们按x分治。
每次按中位数分成两块，然后递归处理。
设两边答案的最小值为\(d\)，我们把\(x \in[x - d,x + d]\)的点拉出来按\(y\)排序。
我们枚举每个点，往后暴力枚举，当两点距离\(>d\)时撤销。
证明请见。
平面最近点对（加强版）
#include<bits/stdc++.h>
#define N 2000005
#define ll long long
struct P{
int x,y;
}a[N],b[N];
bool cmp1(P ai,P b){
return ai.x < b.x;
}
bool cmp2(P ai,P b){
return ai.y < b.y;
}
const long long inf=5e18;
long long sqr(int x){return (long long)x*x;}
long long dis(int l,int r){return sqr(a[l].x-a[r].x)+sqr(a[l].y-a[r].y);}
ll dd(P ai,P b){return sqr(ai.x - b.x) + sqr(ai.y - b.y);}
inline ll solve(int l,int r){
if(l >= r)return inf;
if(l + 1 == r)return dis(l,r);
#define mid ((l + r) >> 1)
int cnt = 0;
int t = a[mid].x;
ll d = std::min(solve(l,mid),solve(mid + 1,r));
for(int i = l;i <= r;++i)
if(sqr(a[i].x - t) < d)
b[++cnt] = a[i];
std::sort(b + 1,b + cnt + 1,cmp2);
for(int i = 1;i <= cnt;++i)
for(int j = i + 1;j <= cnt && sqr(b[j].y - b[i].y) < d;++j)
d = std::min(d,dd(b[i],b[j]));
return d;
}
int n;
int main(){
scanf("%d",&n);
for(int i = 1;i <= n;++i)
scanf("%d%d",&a[i].x,&a[i].y);
std::sort(a + 1,a + n + 1,cmp1);
printf("%.4lf",sqrt(solve(1,n)));
}
CF1442D Sum
有结论:一定只会有一个未全部取完的组。
贪心易证。
我们直接分治到最低节点钦定其为未取完的即可，然后处理背包问题。
CF1442D Sum
#include<bits/stdc++.h>
#define ll long long
#define N 3005
int n,k;
ll ans;
ll vi[N];
std::vector<int>a[N];
std::vector<ll>dp(N,0);
inline void sol(int l,int r){
if(l == r){
// std::cout<<l<<std::endl;
// for(int i = 0;i <= k;++i)
// std::cout<<dp[i]<<" ";
// puts("");
ll w = 0,v = 0;
ans = std::max(ans,dp[k]);
for(int i = 0;i < a[l].size();++i)
++w,v += a[l][i],ans = std::max(ans,k - w >= 0 ? dp[k - w] + v : 0ll);
return ;
}
#define mid ((l + r) >> 1)
std::vector<ll> t = dp;
for(int i = l;i <= mid;++i)
for(int j = k;j >= (int)a[i].size();--j)
dp[j] = std::max(dp[j],dp[j - (int)a[i].size()] + vi[i]);
sol(mid + 1,r);
dp = t;
for(int i = mid + 1;i <= r;++i)
for(int j = k;j >= (int)a[i].size();--j)
dp[j] = std::max(dp[j],dp[j - (int)a[i].size()] + vi[i]);
sol(l,mid);
}
int main(){
scanf("%d%d",&n,&k);
for(int i = 1;i <= n;++i){
int l;
scanf("%d",&l);
while(l -- ){
int x;
scanf("%d",&x);
vi[i] += x;
a[i].push_back(x);
}
}
sol(1,n);
std::cout<<ans<<std::endl;
}
【模板】三维偏序（陌上花开）
版。版。板。
【模板】三维偏序（陌上花开）
#include<iostream>
#include<cstdio>
#include<algorithm>
#define ll long long
#define N 100005
#define lowbit(x) (x & -x)
struct P{
ll x,y,z,id;
}e[N];
ll ans[N],unq[N],f[N];
ll t[N * 2];
ll n,k;
void add(ll x,ll p){
for(int i = x;i <= k;i += lowbit(i))
t[i] += p;
}
int get(ll x){
ll ans = 0;
for(int i = x;i;i -= lowbit(i))
ans += t[i];
return ans;
}
bool cmp(P t,P s){
if(t.x != s.x)
return t.x < s.x;
if(t.y != s.y)
return t.y < s.y;
return t.z < s.z;
}
bool cmp1(P t,P s){
if(t.y != s.y)
return t.y < s.y;
if(t.z != s.z)
return t.z < s.z;
return t.x < s.x;
}
void cdq(ll l,ll r){
if(l == r)
return;
int mid = (l + r) >> 1;
cdq(l,mid),cdq(mid + 1,r);
std::sort(e + l,e + r + 1,cmp1);
for(int i = l;i <= r;++i)
if(e[i].x <= mid)
add(e[i].z,1);
else
ans[e[i].id] += get(e[i].z);
for(int i = l;i <= r;++i){
if(e[i].x <= mid)
add(e[i].z,-1);
// printf("%lld %lld\n",e[i].x,ans[e[i].id]);
}
}
int main(){
scanf("%lld%lld",&n,&k);
for(int i = 1;i <= n;++i)
scanf("%lld%lld%lld",&e[i].x,&e[i].y,&e[i].z),e[i].id = i;
std::sort(e + 1,e + n + 1,cmp);
for(int i = 1,j;i <= n;){
j = i + 1;
while(j <= n && e[j].x == e[i].x && e[j].y == e[i].y && e[j].z == e[i].z)
j ++ ;
while(i < j)
unq[e[i].id] = e[j - 1].id,i ++ ;
}
for(int i = 1;i <= n;++i)
e[i].x = i;
cdq(1,n);
for(int i = 1;i <= n;++i)
f[ans[unq[e[i].id]]] ++ ;
for(int i = 0;i < n;++i)
printf("%lld\n",f[i]);
}
[CQOI2011]动态逆序对
考虑把一个点写作\((t,w,v)\)表示其被删除的时间，以及位置，和权值。
则一个点对能贡献一定有\(t_i < t_j\)，然后就变成逆序对了。
然后将答案写在\(f_{t_i}\)，然后做一个后缀和。
[CQOI2011]动态逆序对
#include<bits/stdc++.h>
#define ll long long
#define N 100005
struct P{
int t,w,v;
}e[N];
int n;
int m;
ll f[N];
int del[N];
inline bool cmp(P a,P b){
return a.t < b.t;
}
inline bool cmp2(P a,P b){
return a.w < b.w;
}
int T[N];
#define lowbit(x) (x & -x)
inline void add(int x,int p){
for(int i = x;i <= n;i += lowbit(i))
T[i] += p;
}
inline int find(int x){
int ans = 0;
for(int i = x;i;i -= lowbit(i))
ans += T[i];
return ans;
}
inline void solve(int l,int r){
#define mid ((l + r) >> 1)
if(l == r)return ;
solve(mid + 1,r);
solve(l,mid);
std::sort(e + l,e + mid + 1,cmp2);
std::sort(e + mid + 1,e + r + 1,cmp2);
// std::cout<<"!"<<l<<" "<<r<<" "<<mid<<std::endl;
// for(int i = mid + 1;i <= r;++i)
// std::cout<<e[i].w<<" ";
// puts("");
int ri = mid + 1;
// std::cout<<"!"<<l<<" "<<r<<" "<<mid<<std::endl;
for(int i = l;i <= mid;++i){//wx < wy vx > vy
// std::cout<<e[i].t<<" "<<e[i].w<<" "<<e[i].v<<std::endl;;
while(e[ri].w < e[i].w && ri <= r)
add(e[ri].v,1),++ri;
// std::cout<<find(n) - find(e[i].v)<<std::endl;
f[e[i].t] += find(n) - find(e[i].v);
}
-- ri;
while(ri >= mid + 1)
add(e[ri].v,-1),--ri;
ri = r;//wx > wy vx < vy
for(int i = mid;i >= l;--i){
// std::cout<<e[i].t<<" "<<e[i].w<<" "<<e[i].v<<std::endl;;
while(e[ri].w > e[i].w && ri >= mid + 1)
add(e[ri].v,1),--ri;
// std::cout<<find(e[i].v - 1)<<std::endl;
f[e[i].t] += find(e[i].v - 1);
}
++ ri;
while(ri <= r)
add(e[ri].v,-1),++ri;
}
int main(){
scanf("%d%d",&n,&m);
for(int i = 1;i <= n;++i)
scanf("%d",&e[i].v),e[i].w = i;
for(int i = 1;i <= m;++i){
int x;
scanf("%d",&x);
del[x] = i;
}
for(int i = 1;i <= n;++i){
if(del[e[i].v])
e[i].t = del[e[i].v];
else
e[i].t = m + 1;
}
std::sort(e + 1,e + n + 1,cmp);
solve(1,n);
for(int i = m;i >= 1;--i)
f[i] = f[i + 1] + f[i];
for(int i = 1;i <= m;++i)
std::cout<<f[i]<<std::endl;
}
线段树分治
CF601E A Museum Robbery
把物品打在树上，暴力背包。
CF601E A Museum Robbery
#include<bits/stdc++.h>
#define ll long long
#define N 40007
#define K 1007
#define base ((ll)1e7 + 19)
#define mod ((ll)1e9 + 7)
using std::pair;
using std::vector;
#define pii std::pair<int,int>
#define vii std::vector<pii>::iterator
struct P{
int v,w,l,r;
}e[N];
int k;
std::vector<pii> seg[N << 2];
ll dp[K];
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define mid ((l + r) >> 1)
inline void add(int u,int l,int r,int tl,int tr,int v,int w){
if(tl > tr)return ;
if(tl <= l && r <= tr){
seg[u].push_back(std::make_pair(v,w));
return ;
}
if(tl <= mid)
add(ls(u),l,mid,tl,tr,v,w);
if(tr > mid)
add(rs(u),mid + 1,r,tl,tr,v,w);
}
int n,q,opt,u,v,t = 1;
inline void solve(int u,int l,int r,ll *f){
for(vii it = seg[u].begin();it != seg[u].end();++it){
for(int j = k;j >= it -> second;--j)
f[j] = std::max(f[j],f[j - it -> second] + it -> first);
//,std::cout<<it -> first<<" "<<it -> second<<" "<<f[j]<<std::endl
}
// std::cout<<u<<" "<<l<<" "<<r<<std::endl;
// for(int i = 1;i <= k;++i)
// std::cout<<f[i]<<" ";
// puts("");
if(l == r){
ll ans = 0;
for(int i = k;i;--i)
ans = (ans * base + f[i]) % mod;
std::cout<<ans<<std::endl;
return ;
}
ll Q[K];
memcpy(Q,f,sizeof(Q));
solve(ls(u),l,mid,Q);
memcpy(Q,f,sizeof(Q));
solve(rs(u),mid + 1,r,Q);
}
int main(){
scanf("%d%d",&n,&k);
for(int i = 1;i <= n;++i){
scanf("%d%d",&u,&v);
e[i] = (P){u,v,t,-1};
}
scanf("%d",&q);
for(int i = 1;i <= q;++i){
scanf("%d",&opt);
if(opt == 1){
scanf("%d%d",&u,&v);
e[++n] = (P){u,v,t,-1};
}else if(opt == 2){
int x;
scanf("%d",&x);
e[x].r = t - 1;
}else{
++ t;
}
}
--t;
for(int i = 1;i <= n;++i){
e[i].r = e[i].r == -1 ? t : e[i].r;
add(1,1,t,e[i].l,e[i].r,e[i].v,e[i].w);
}
solve(1,1,t,dp);
}
CF813F Bipartite Checking 与 二分图 /【模板】线段树分治
拆点，一个点拆成白点和黑点，一次加边如果两点同色在一个集合则其非法。
要做的就是给修改丢到线段树上，然后搞个可撤销并查集就行了。
线段树下标要对应。
二分图 /【模板】线段树分治
#include<bits/stdc++.h>
#define ll long long
#define N 200005
int n,m,k;
using std::pair;
using std::vector;
#define pii std::pair<int,int>
#define vii std::vector<pii>
vii T[N << 2];
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define mid ((l + r) >> 1)
inline void add(int u,int l,int r,int tl,int tr,pii t){
if(tl > tr)return;
if(tl <= l && r <= tr){
T[u].push_back(t);
return ;
}
if(tl <= mid)
add(ls(u),l,mid,tl,tr,t);
if(tr > mid)
add(rs(u),mid + 1,r,tl,tr,t);
}
int fa[N << 1],top;
ll key[N << 1];
bool tag = 0;
int st[(N << 1) * 2];
inline int find(int u){return (u == fa[u]) ? u : find(fa[u]);}
inline void merge(int x,int y){
int fx = find(x),fy = find(y);
if(key[fx] >= key[fy])
std::swap(fx,fy);
st[++top] = fx;
fa[fx] = fy;
}
inline void del(int now){
while(top > now){
fa[st[top]] = st[top];
-- top;
}
}
inline void solve(int u,int l,int r){
int las = top;
tag = 0;
for(int i = 0;i < T[u].size();++i){
pii a = T[u][i];
if(find(a.first) == find(a.second)){
tag = 1;
for(int j = l;j <= r;++j)
puts("No");
break;
}else{
merge(a.first + n,a.second);
merge(a.first,a.second + n);
}
}
if(!tag){
if(l == r)
puts("Yes");
else{
solve(ls(u),l,mid);
solve(rs(u),mid + 1,r);
}
}
del(las);
}
#define fhq_treap time(0)
int main(){
srand(fhq_treap);
scanf("%d%d%d",&n,&m,&k);
for(int i = 1;i <= m;++i){
int x,y,l,r;
scanf("%d%d%d%d",&x,&y,&l,&r);
if(l == r)continue;
add(1,1,k,l + 1,r,std::make_pair(x,y));
}
for(int i = 1;i <= n << 1;++i)
fa[i] = i,key[i] = rand() << 15 | rand();
solve(1,1,k);
}
CF938G Shortest Path Queries
前置知识：[WC2011]最大XOR和路径和[学习笔记] 线性基 ，后者年久失修。
考虑这题实际上是动态问题。
我们维护可撤销线性基以及可撤销并查集表示树结构即可。
和上题代码差不太多，咕咕咕了。
CF576E Painting Edges
考虑这题的难点是我们并不知道一条影响是否会改变下一条
我们不妨假定其染色成功。
我们发现如果染色成功等同于其影响后延，那么我们不撤销操作，否则我们撤销操作。
然后和前面的题一样，不同的是维护\(k\)的并查集即可。
代码咕咕咕。
CF603E Pastoral Oddities
有如下结论：
一定是所有联通块均为偶数点，且加边不影响答案。
考虑一个静态问题：
有一个固定边集我们如何操作。
我们一定是从小到大能加就加。
因为对奇数联通块数量来说加一条边一定不劣。
考虑动态问题。
我们先思考为什么我们不能直接把每条边打在区间上然后操作：
因为不满足最优子结构，我这里选了这条边显然底下会出问题。
但是我们发现：一个最优答案的子结构一定满足最优化（最优化定义为按可选边权依次加入并查集的边。）
我们发现加边不好做，我们不妨思考倒序处理。
那么我们从后往前处理最优化结构：
我们可以确定其中的边集内的边的属于最优结构的范围为\([begin,\max T (i \in best\ when\ in\ T]\)。
那么我们就确定了其中的范围可以在树上打标记了。
很好的题。
CF603E Pastoral Oddities
#include<bits/stdc++.h>
#define N 300005
int n,m,pos,ans[N],odd;
struct P{
int x,y,v,id;
}e[N];
bool operator < (P a,P b){
return a.v < b.v;
}
struct Last{int x,y,dlt;}st[N];//可撤销
int fa[N],siz[N],top;
inline int find(int x){return fa[x] == x ? x : find(fa[x]);}
std::vector<P>vec[N << 2];
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define mid ((l + r) >> 1)
inline void cover(int u,int l,int r,int tl,int tr,P v){
if(tl > tr)return;
if(tl <= l && r <= tr){
vec[u].push_back(v);
return ;
}
if(tl <= mid)
cover(ls(u),l,mid,tl,tr,v);
if(tr > mid)
cover(rs(u),mid + 1,r,tl,tr,v);
}
inline void merge(int x,int y){
int fx = find(x),fy = find(y);
if(fx == fy)return;
if(siz[fx] < siz[fy])std::swap(fx,fy);
st[++top] = (Last){fx,fy,0};
if(siz[fx] % 2 && siz[fy] % 2)
odd -= 2,st[top].dlt += 2;
siz[fx] += siz[fy],fa[fy] = fx;
}
inline void solve(int u,int l,int r){
int las = top;
for(int i = 0;i < vec[u].size();++i)
merge(vec[u][i].x,vec[u][i].y);
if(l == r){
while(1){
if(odd == 0 || pos == m)break;
if(e[pos + 1].id <= l){
merge(e[pos + 1].x,e[pos + 1].y);
cover(1,1,m,e[pos + 1].id,l - 1,e[pos + 1]);
}
++ pos;
}
if(odd == 0)ans[l] = e[pos].v;
else ans[l] = -1;
}else{
solve(rs(u),mid + 1,r);
solve(ls(u),l,mid);
}
while(top != las){
int x = st[top].x,y = st[top].y,dlt = st[top].dlt;
siz[x] -= siz[y],fa[y] = y;
odd += dlt;
-- top;
}
}
int main(){
scanf("%d%d",&n,&m);
odd = n;
for(int i = 1;i <= n;++i)
fa[i] = i,siz[i] = 1;
for(int i = 1;i <= m;++i)
scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].v),e[i].id = i;
std::sort(e + 1,e + m + 1);
solve(1,1,m);
for(int i = 1;i <= m;++i)
std::cout<<ans[i]<<std::endl;
}
二维分治
CF364E Empty Rectangles
考虑横竖交替分治。
维护\(k\)个指针表示：在分治线上和线下的和为\(x\)的边界。
我们枚举矩形的左边界 \(i\)，然后把右边界当成指针一直往右扫，过程中维护"橙线"，也就是达到 \(x\) 个 \(1\) 的边界。显然随着右边界的移动上面橙线只会下移，下面的橙线只会上移，这个是具有单调性的，可以维护 \(k\) 个指针，算答案的时候还是简单乘法原理。
CF364E Empty Rectangles
#include <cstdio>
#include <iostream>
using namespace std;
const int M = 2505;
#define ll long long
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,k,a[M][M],b[M][M],up[2][10];ll ans;
int cal(int xl,int xr,int yl,int yr)
{
return b[xr][yr]-b[xr][yl]-b[xl][yr]+b[xl][yl];
}
void cdq(int xl,int xr,int yl,int yr,int ty)
{
if(xl==xr || yl==yr) return ;
if(xl+1==xr && yl+1==yr)
{
ans+=(cal(xl,xr,yl,yr)==k);
return ;
}
if(ty==0)
{
int mid=(xl+xr)>>1;
cdq(xl,mid,yl,yr,1);
cdq(mid,xr,yl,yr,1);
for(int i=yl;i<=yr;i++)
{
up[0][0]=up[1][0]=mid;
for(int j=1;j<=k+1;j++)
up[0][j]=xl,up[1][j]=xr;
for(int j=i+1;j<=yr;j++)
{
for(int p=1;p<=k+1;p++)
{
while(cal(up[0][p],mid,i,j)>=p)
up[0][p]++;
while(cal(mid,up[1][p],i,j)>=p)
up[1][p]--;
}
for(int p=0;p<=k;p++)
ans+=(up[0][p]-up[0][p+1])
*(up[1][k-p+1]-up[1][k-p]);
}
}
}
else
{
int mid=(yl+yr)>>1;
cdq(xl,xr,yl,mid,0);
cdq(xl,xr,mid,yr,0);
for(int i=xl;i<=xr;i++)
{
up[0][0]=up[1][0]=mid;
for(int j=1;j<=k+1;j++)
up[0][j]=yl,up[1][j]=yr;
for(int j=i+1;j<=xr;j++)
{
for(int p=1;p<=k+1;p++)
{
while(cal(i,j,up[0][p],mid)>=p)
up[0][p]++;
while(cal(i,j,mid,up[1][p])>=p)
up[1][p]--;
}
for(int p=0;p<=k;p++)
ans+=(up[0][p]-up[0][p+1])
*(up[1][k-p+1]-up[1][k-p]);
}
}
}
}
signed main()
{
n=read();m=read();k=read();
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
b[i][j]=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
scanf("%1d",&a[i][j]);b[i][j]+=a[i][j];
}
cdq(0,n,0,m,1);
printf("%lld\n",ans);
}
整体二分
[POI2011]MET-Meteors
考虑其二分是非常简单的。
贡献的时候拆环就行了。
然后可以相当于是个整体二分板子。
同时其也利用了分治中心移动距离\(O(nlog)\)的操作保证了复杂度。
[POI2011]MET-Meteors
#include<bits/stdc++.h>
#define ll unsigned long long
#define N 300010
#define int ll
int n,m,belong[N],ls[N],rs[N],target[N],k;
int val[N],now,cont[N],lt[N],rt[N],ans[N];
ll tree[N],tc[N];
using std::vector;
std::vector<int>T[N];
#define lowbit(x) (x & -x)
inline void add(int x,int p){
for(int i = x;i <= m;i += lowbit(i))
tree[i] += p;
}
inline ll find(int x){
ll ans = 0;
for(int i = x;i;i -= lowbit(i))
ans += tree[i];
return ans;
}
inline void change(int l,int r,int x){
if(l <= r){
add(l,x);
add(r + 1,-x);
}else{
add(l,x),add(m + 1,-x);
add(1,x),add(r + 1,-x);
}
}
int t;
#define mid ((l + r) >> 1)
inline void query(int l,int r,int L,int R){
if(l > r)return;if(L > R)return ;
// std::cout<<l<<" "<<r<<std::endl;
// for(int i = L;i <= R;++i)
// std::cout<<cont[i]<<" ";
// puts("");
if(l == r){
for(int i = L;i <= R;++i)
ans[cont[i]] = l;
return ;
}
while(now < mid)++now,change(ls[now],rs[now],val[now]);
while(now > mid)change(ls[now],rs[now],-val[now]),--now;
for(int i = L;i <= R;++i){
tc[cont[i]] = 0;
for(int j =0;j < T[cont[i]].size();++j)
tc[cont[i]] += find(T[cont[i]][j]);
}
int lct = 0,rct = 0;
for(int i = L;i <= R;++i){
if(tc[cont[i]] >= target[cont[i]])
lt[++lct] = cont[i];
else
rt[++rct] = cont[i];
}
int split = lct;
// puts("LC");
// for(int i = 1;i <= lct;++i)
// std::cout<<lt[i]<<" ";
// puts("");
// puts("RC");
// for(int i = 1;i <= rct;++i)
// std::cout<<rt[i]<<" ";
// puts("");
for(int i = 1;i <= lct;++i)
cont[i + L - 1] = lt[i];
for(int i = 1;i <= rct;++i)
cont[L + lct + i - 1] = rt[i];
query(l,mid,L,L + split - 1);
query(mid + 1,r,L + split,R);
}
signed main(){
scanf("%llu%llu",&n,&m);
for(int i = 1;i <= m;++i){
scanf("%llu",&belong[i]);
T[belong[i]].push_back(i);
}
for(int i = 1;i <= n;++i){
scanf("%llu",&target[i]);
cont[i] = i;
}
scanf("%llu",&k);
for(int i = 1;i <= k;++i){
scanf("%llu%llu%llu",&ls[i],&rs[i],&val[i]);
}
++ k;
ls[k] = 1;
rs[k] = m;
val[k] = 0x3f3f3f3f;
now = 0;
query(1,k,1,n);
for(int i = 1;i <= n;++i){
if(ans[i] == k)
puts("NIE");
else
std::cout<<ans[i]<<std::endl;
}
return 0;
}
[国家集训队]矩阵乘法
整体二分板板。
[国家集训队]矩阵乘法
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 3e5 + 50, INF = 0x3f3f3f3f;
inline int read () {
register int x = 0, w = 1;
register char ch = getchar ();
for (; ch < '0' || ch > '9'; ch = getchar ()) if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar ()) x = x * 10 + ch - '0';
return x * w;
}
int n, q, len, c[maxn], a[505][505], tree[505][505], ans[maxn], mp[maxn];
vector <int> res;
vector <pair <int, int> > pos[maxn];
struct Node {
int x1, y1, x2, y2, k;
} b[maxn];
inline void Insert (register int x, register int y) {
for (register int i = x; i <= n; i += i & -i)
for (register int j = y; j <= n; j += j & -j)
tree[i][j] ++;
}
inline void Delete (register int x, register int y) {
for (register int i = x; i <= n; i += i & -i)
for (register int j = y; j <= n; j += j & -j)
tree[i][j] --;
}
inline int Query (register int x, register int y, register int ans = 0) {
for (register int i = x; i; i -= i & -i)
for (register int j = y; j; j -= j & -j)
ans += tree[i][j];
return ans;
}
inline void Binary (register int l, register int r, vector <int> vec) {
if (! vec.size ()) return;
if (l == r) {
for (register int i = 0; i < vec.size (); i ++) ans[vec[i]] = mp[l];
return;
}
register int mid = (l + r) >> 1;
vector <int> vec0, vec1;
for (register int x = l; x <= mid; x ++)
for (register int i = 0; i < pos[x].size (); i ++)
Insert (pos[x][i].first, pos[x][i].second);
for (register int i = 0; i < vec.size (); i ++) {
register int id = vec[i], x1 = b[id].x1, y1 = b[id].y1, x2 = b[id].x2, y2 = b[id].y2;
register int sum = Query (x2, y2) - Query (x1 - 1, y2) - Query (x2, y1 - 1) + Query (x1 - 1, y1 - 1);
if (sum >= b[id].k) vec0.push_back (id);
else b[id].k -= sum, vec1.push_back (id);
}
for (register int x = l; x <= mid; x ++)
for (register int i = 0; i < pos[x].size (); i ++)
Delete (pos[x][i].first, pos[x][i].second);
Binary (l, mid, vec0), Binary (mid + 1, r, vec1);
}
int main () {
n = read(), q = read();
for (register int i = 1; i <= n; i ++)
for (register int j = 1; j <= n; j ++)
a[i][j] = c[++ len] = read();
sort (c + 1, c + len + 1), len = unique (c + 1, c + len + 1) - c - 1;
for (register int i = 1; i <= n; i ++) {
for (register int j = 1; j <= n; j ++) {
register int res = lower_bound (c + 1, c + len + 1, a[i][j]) - c;
mp[res] = a[i][j], a[i][j] = res, pos[res].push_back (make_pair (i, j));
}
}
for (register int i = 1; i <= q; i ++)
b[i].x1 = read(), b[i].y1 = read(), b[i].x2 = read(), b[i].y2 = read(), b[i].k = read(), res.push_back (i);
Binary (1, len, res);
for (register int i = 1; i <= q; i ++) printf ("%d\n", ans[i]);
return 0;
}
决策单调性分治
CF868F Yet Another Minimization Problem
待会写个四边形不等式的博。
这是一个 2D/1D 动态规划问题。
每次对一维通过上一维dp过来。
这是一个 1D/1D 动态规划问题。
前文我们提到，1D/1D问题可以考虑CDQ分治，但我们需要在合并两段区间时也能做到对右子区间做到\(O(n)\)。
但是这题的贡献并不满足这个条件。
我们转而思考，这类区间贡献的方式是否拥有决策单调性。
下面证明该问题具有决策单调性：
即证明\(\forall i_1 < i_2\)，假设其转移点为\(x_1,x_2\)，那么有\(x_1\leq x_2\)。
假设若有\(x_1 > x_2\),则有\(f_{x_1} + w_{x_1 + 1,i1} \leq f_{x_2} + w_{x_2 + 1,i2}\),\(f_{x_1} + w_{x_2 + 1,i1} \leq f_{x_2} + w_{x_1 + 1,i2}\)
若两等号均成立知其不影响证明。
若有一个取了小于：不妨假设其为\(f_{x_1} + w_{x1 + 1,i1} \leq f_{x_2} + w_{x2 + 1,i2}\).\(f_{x_1} + w_{x_2 + 1,i1} < f_{x_2} + w_{x_1 + 1,i2}\)
整理可得\(w_{x_1 + 1,i1} - w_{x_2 + 1,i1} < w_{x_1 + 1,i2} - w_{x_2 + 1,i2}\)
由\(i1 < i2\)知其错误。
则结论得证。
可分治解决该问题。
具体可以看代码。
其中利用了两个指针在分治过程移动距离不过\(O(nlogn)\)
CF868F Yet Another Minimization Problem
#include<bits/stdc++.h>
#define ll long long
#define N 100005
int n,k;
int buc[N],L,R,a[N];
ll ans;
inline void up(int c,int d){ans += d * buc[c] * 1ll * (buc[c] - 1) / 2;}
inline ll cal(int l,int r){
while(L < l)up(a[L],-1),buc[a[L]] -- ,up(a[L],1),++L;
while(L > l)L -- ,up(a[L],-1),buc[a[L]] ++ ,up(a[L],1);
while(R > r)up(a[R],-1),buc[a[R]] -- ,up(a[R],1),R --;
while(R < r)R ++ ,up(a[R],-1),buc[a[R]] ++ ,up(a[R],1);
return ans;
}
ll dp[22][N];
int cur;
inline void solve(int lb,int rb,int l,int r){
if(lb > rb || l > r)return ;
int d = 0;
ll res = 1e18;
#define mid ((l + r) >> 1)
for(int i = lb;i <= rb;++i){
ll tmp = cal(i + 1,mid);
if(res > dp[cur - 1][i] + tmp) res = dp[cur - 1][i] + tmp,d = i;
}
dp[cur][mid] = res;
solve(lb,d,l,mid - 1),solve(d,rb,mid + 1,r);
}
int main(){
std::memset(dp,0x3f,sizeof(dp));
dp[0][0] = 0;
scanf("%d%d",&n,&k);
for(int i = 1;i <= n;++i)
scanf("%d",&a[i]);
buc[a[1]] ++ ,L = R = 1;
for(cur = 1;cur <= k;++cur)
solve(0,n - 1,1,n);
std::cout<<dp[k][n]<<std::endl;
}
树分治
点分治
CF150E Freezing with Style
二分答案。
树上启发式合并单调队列。
淀粉质上去就行了。
CF150E Freezing with Style
#include <cstdio>
#include <vector>
#include <algorithm>
const int Inf = 0x3f3f3f3f;
const int MN = 100005;
int N, L, R, Ans = -1, AnsU, AnsV;
int uv[MN], w[MN];
std::vector<int> G[MN];
int dw[MN], M;
int vis[MN], siz[MN], tsiz, rsiz, Root;
void GetRoot(int u, int fz) {
siz[u] = 1;
int nsiz = 0;
for (auto i : G[u]) {
int v = uv[i] ^ u;
if (v == fz || vis[v]) continue;
GetRoot(v, u), siz[u] += siz[v];
if (nsiz < siz[v]) nsiz = siz[v];
}
if (nsiz < tsiz - siz[u]) nsiz = tsiz - siz[u];
if (rsiz > nsiz) rsiz = nsiz, Root = u;
}
int stk[MN], tp, _U;
inline bool cmp(int i, int j) {
return siz[uv[i] ^ _U] < siz[uv[j] ^ _U];
}
int seq[MN], sequ[MN], odep, tmp[MN], tmpu[MN], ndep;
void DFS(int u, int fz, int d, int x, int y) {
if (tmp[d] < x) tmp[d] = x, tmpu[d] = u;
if (ndep < d) ndep = d;
for (auto i : G[u]) {
int v = uv[i] ^ u;
if (v == fz || vis[v]) continue;
DFS(v, u, d + 1, x + (w[i] >= y ? 1 : -1), y);
}
}
int ucal, vcal;
bool Calc(int u, int x) {
static int que[MN];
seq[odep = 0] = 0, sequ[0] = u;
for (int i = 1; i <= tp; ++i) {
int v = uv[stk[i]] ^ u;
for (int j = 1; j <= siz[v]; ++j) tmp[j] = -Inf;
ndep = 0, DFS(v, u, 1, w[stk[i]] >= x ? 1 : -1, x);
int l = 1, r = 0, lb = odep, rb = odep + 1;
for (int j = 1; j <= ndep; ++j) {
while (rb > 0 && rb > L - j) {
--rb;
while (l <= r && seq[que[r]] < seq[rb]) --r;
que[++r] = rb;
}
while (lb >= 0 && lb > R - j) {
--lb;
while (l <= r && que[l] > lb) ++l;
}
if (l <= r && seq[que[l]] + tmp[j] >= 0) {
ucal = sequ[que[l]], vcal = tmpu[j];
return 1;
}
}
while (odep < ndep) seq[++odep] = -Inf;
for (int j = 1; j <= ndep; ++j)
if (seq[j] < tmp[j])
seq[j] = tmp[j], sequ[j] = tmpu[j];
}
return 0;
}
void Solve(int u) {
int nsiz = tsiz;
tp = 0;
for (auto i : G[u]) {
int v = uv[i] ^ u;
if (vis[v]) continue;
siz[v] = siz[v] > siz[u] ? nsiz - siz[u] : siz[v];
stk[++tp] = i;
}
_U = u, std::sort(stk + 1, stk + tp + 1, cmp);
int lb = 1, rb = M, mid, ans = 0, ansu = 0, ansv = 0;
while (lb <= rb) {
mid = (lb + rb) >> 1;
if (Calc(u, dw[mid])) {
ans = mid;
ansu = ucal, ansv = vcal;
lb = mid + 1;
}
else rb = mid - 1;
}
if (Ans < dw[ans]) {
Ans = dw[ans];
AnsU = ansu, AnsV = ansv;
}
vis[u] = 1;
for (auto i : G[u]) {
int v = uv[i] ^ u;
if (vis[v]) continue;
rsiz = tsiz = siz[v], GetRoot(v, 0), Solve(Root);
}
}
int main() {
scanf("%d%d%d", &N, &L, &R);
for (int i = 1; i < N; ++i) {
int x, y;
scanf("%d%d%d", &x, &y, &w[i]);
uv[i] = x ^ y;
G[x].push_back(i);
G[y].push_back(i);
dw[i] = w[i];
}
std::sort(dw + 1, dw + N);
M = std::unique(dw + 1, dw + N) - dw - 1;
rsiz = tsiz = N, GetRoot(1, 0), Solve(Root);
printf("%d %d\n", AnsU, AnsV);
return 0;
}
淀粉树
写吐了兄弟。
【模板】点分树 | 震波
建出点分树。
然后用两个BIT来询问的时候容斥。
【模板】点分树 | 震波
#include <vector>
#include <cstdio>
#include <iostream>
#include <algorithm>
const int N = 4e5 + 5;
int n, m, val[N];
struct Edge { int to, next; } e[N << 1];
int head[N], cnt = 0;
void Add(int x, int y) {
e[++cnt].next = head[x];
e[cnt].to = y;
head[x] = cnt;
}
int dep[N], siz[N], fa[N];
int pos[N], lg[N << 1], st[N << 1][21], scnt = 0;
void Dfs1(int u, int f) {
st[++cnt][0] = u;
pos[u] = cnt;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f)
continue;
dep[v] = dep[u] + 1;
Dfs1(v, u);
st[++cnt][0] = u;
}
}
int GetMin(int x, int y) {
return dep[x] < dep[y] ? x : y;
}
void GetST()
{
lg[1] = 0;
for(int i = 2; i <= cnt; ++i)
lg[i] = lg[i >> 1] + 1;
for(int j = 1; 1 << j <= cnt; j++)
for(int i = 1; i + (1 << j) <= cnt; i++)
st[i][j] = GetMin(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
int GetDis(int u, int v) {
if (pos[u] > pos[v])
std :: swap(u, v);
int pu = pos[u], pv = pos[v];
int len = pv - pu +1;
return dep[u] + dep[v] - 2 * dep[GetMin(st[pu][lg[len]], st[pv - (1 << lg[len]) + 1][lg[len]])];
}
std :: vector <int> tr[2][N];
void Modify(int u, int opt, int x, int v) {
// printf("siz%d\n", siz[u]);
x++;
for (int i = x; i <= siz[u]; i += i & -i)
tr[opt][u][i] += v;
}
int Query(int u, int opt, int x) {
int res = 0;
x = std :: min(x + 1, siz[u]);
for (int i = x; i; i -= i & -i)
res += tr[opt][u][i];
return res;
}
int tot, rt, vis[N << 1], mn;
void FindRt(int u, int f) {
siz[u] = 1;
int res = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f || vis[v])
continue;
FindRt(v, u);
siz[u] += siz[v];
res = std :: max(res, siz[v]);
}
res = std :: max(res, tot - siz[u]);
if (res < mn)
mn = res, rt = u;
}
void Dfs2(int u) {
vis[u] = 1;
siz[u] = tot + 1;
tr[0][u].resize(siz[u] + 1);
tr[1][u].resize(siz[u] + 1);
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (vis[v])
continue;
tot = siz[v];
rt = 0;
mn = 1e9;
FindRt(v, 0);
fa[rt] = u;
Dfs2(rt);
}
}
void Calc(int u ,int w) {
for (int i = u; i; i = fa[i])
// printf("dis%d\n", GetDis(u, i)),
Modify(i, 0, GetDis(u, i), w);
for (int i = u; fa[i]; i = fa[i])
// printf("dis%d\n", GetDis(u, fa[i])),
Modify(i, 1, GetDis(u, fa[i]), w);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", &val[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
Add(u, v);
Add(v, u);
}
Dfs1(1, 0);
GetST();
tot = n;
mn = 1e9;
FindRt(1, 0);
Dfs2(rt);
for (int i = 1; i <= n; i++)
Calc(i, val[i]);
int lst = 0;
// for (int i = 1; i <= n; i++)
// printf("%d ", GetDis(i, i + 2));
// puts("");
while (m--) {
int opt, x, y;
scanf("%d%d%d", &opt, &x, &y);
x ^= lst, y ^= lst;
if (opt == 0) {
lst = 0;
lst += Query(x, 0, y);
for (int i = x; fa[i]; i = fa[i])
if (y >= GetDis(x, fa[i]))
lst += Query(fa[i], 0, y - GetDis(x, fa[i])) - Query(i, 1, y - GetDis(x, fa[i]));
printf("%d\n", lst);
}
else {
Calc(x, y - val[x]);
val[x] = y;
}
}
}
[HNOI2015]开店
和上面那个题差不多。
真写不动了。/tuu。
为了提升分治操作，准备找一天挑战紫荆花之恋。
终于了结束了啊，分治专题。
启发式合并
长链启发式合并
CF1009F Dominant Indices
板板题。
没有采用指针方式，而是使用了\(vector\)
CF1009F Dominant Indices
#include<bits/stdc++.h>
#define ll long long
#define N 1000005
std::vector<int>e[N],f[N];
int fa[N],len[N],son[N];
int ans[N];
int n;
inline void dfs1(int u,int f){//find_len_rt
// std::cout<<u<<" "<<f<<std::endl;
fa[u] = f;
for(auto v : e[u]){
if(v == f)continue;
dfs1(v,u);
if(len[v] >= len[son[u]])
son[u] = v,len[u] = len[v] + 1;
}
}
inline void dfs2(int u){
if(son[u]){
dfs2(son[u]);
std::swap(f[u],f[son[u]]);
f[u].push_back(1);
ans[u] = ans[son[u]];
if(f[u][ans[u]] == 1)ans[u] = len[u];
for(auto v : e[u]){
// std::cout<<v<<std::endl;
if(v == fa[u] || v == son[u])continue;
dfs2(v);
for(int i = len[v];i >= 0;--i){
int tmp = i + len[u] - len[v] - 1;
f[u][tmp] += f[v][i];
if(f[u][tmp] > f[u][ans[u]])
ans[u] = tmp;
else
if(f[u][tmp] == f[u][ans[u]] && tmp > ans[u])
ans[u] = tmp;
}
}
}else{
f[u].push_back(1);
ans[u] = 0;
}
// std::cout<<u<<std::endl;
// for(int i = len[u];i >= 0;--i)
// std::cout<<f[u][i]<<" ";
// puts("");
}
int main(){
scanf("%d",&n);
for(int i = 1;i < n;++i){
int x,y;
scanf("%d%d",&x,&y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs1(1,0);
dfs2(1);
for(int i = 1;i <= n;++i)
printf("%d\n",len[i] - ans[i]);
}
CF1499F Diameter Cuts
考虑\(dp\)。
令\(f_{u,i}\)为\(u\)子树里能到达\(u\)的最大深度为\(i\)，且子树合法的方案数。
有断边和不断边两种转移
\(f_{u,max(i,j + 1)} = f_{u,i} * f_{v,j} (i + j + 1 < k)\)
\(f_{u,i} = f_{u,i} * f_{v,j} (j < k)\)
套用转移即可。
这题甚至\(O(n^2)\)可过。
倍增
[SCOI2015]国旗计划
如果他不是环。
那简直是典中典题。
考虑记录\(f_{i,j}\)即从\(i\)处使用了\(2^j\)个区间达到的最右边的处。
环就直接扩展\(2\)倍。
[SCOI2015]国旗计划
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
using namespace std;
int n, m, res[200005];
struct soldier {
int id, l, r;
} s[400005];
int cmp(soldier a, soldier b)
{
return a.l < b.l;
}
int go[400005][20];
void pre()
{
for(int i = 1, p = i; i <= 2 * n; i++) {
while(p <= 2 * n && s[p].l <= s[i].r)
p++;
int pos = p - 1;
go[i][0] = pos;
}
for(int i = 1; i < 20; i++) {
for(int j = 1; j <= 2 * n; j++) {
go[j][i] = go[go[j][i - 1]][i - 1];
}
}
}
void search(int k)
{
int lmt = s[k].l + m, ans = 1, p = k;
for(int i = 19; i >= 0; i--) {
if(go[k][i] != 0 && s[go[k][i]].r < lmt) {
ans += (1 << i);
k = go[k][i];
}
}
res[s[p].id] = ans + 1;
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++) {
cin >> s[i].l >> s[i].r;
if(s[i].r < s[i].l)
s[i].r += m;
s[i].id = i;
}
sort(s + 1, s + 1 + n, cmp);
for(int i = 1; i <= n; i++) {
s[i + n] = s[i];
s[i + n].l = s[i].l + m;
s[i + n].r = s[i].r + m;
}
pre();
for(int i = 1; i <= n; i++)
search(i);
for(int i = 1; i <= n; i++)
cout << res[i] << " ";
return 0;
}
扫描线
略。(题单上来的时候扫描线已经全做完了)
分块
数论分块
略。该技巧在某些反演题中反复出现。
操作分块
[APIO2019]桥梁
考虑如果没有修改操作，我们显然排序并查集可做。
但是有了修改操作。
我们发现无法快速维护，这个时候我们用到操作分块。
我们把操作分为\(S\)块，我们依次处理块内问题。
我们依次处理每个块，把每个块前的修改都修改。
然后将询问与修改按权排序，枚举询问，先把在块内未被修改过的操作给他永久加入。
然后我们对询问将满足他条件的加入，处理完这个询问之后就暴力撤销。
其一个块的复杂度为\(O(mlogm + S^2logn)\)
调一调块长，取块长为\(750 ~ 780\)好像能跑的飞快。
贡献卡常记录。
[APIO2019]桥梁
#include<bits/stdc++.h>
#define ll long long
#define N 100005
int n,m;
inline int read(){
int ans = 0,f = 1;
char a = getchar();
while(a != '-' && !(a <= '9' && a >= '0'))
a = getchar();
while(a <= '9' && a >= '0')
ans = (ans << 1) + (ans << 3) + (a - '0'),a = getchar();
return f * ans;
}
struct P{
int x,y,p;// x <-> y color : p
int id;
}e[N],D[N];//have_done_edge
inline bool cmp1(P a,P b){
return a.p > b.p;
}
inline bool cmp2(P a,P b){
return a.id < b.id;
}
struct All{
int x,y,tim;//b_x -> y or form x up with color y
}C[N],Q[N];
inline bool cmp(All a,All b){
return a.y > b.y;
}
inline bool cmp3(All a,All b){
return a.tim > b.tim;
}
inline bool cmp5(All a,All b){
return a.tim < b.tim;
}
int fa[N],sz[N];
int stk[N],top;//can _ del _ DSU
int stk2[N];
int q;
int now = 1;
int B = 750;
int ccnt,qcnt;
int fans[N];
int rk[N];
int siz[N];
bool vis[N],used[N];
inline void cancel(int las){
while(top != las){
// std::cout<<"del"<<stk[top]<<" "<<stk2[top]<<std::endl;
fa[stk[top]] = stk[top];
siz[stk2[top]] -= siz[stk[top]];
-- top;
}
}
inline int find(int x){return fa[x] == x ? x : find(fa[x]);}
inline void merge(int x,int y){
int fx = find(x),fy = find(y);
// std::cout<<x<<" "<<y<<std::endl;
if(fx == fy)return;
if(rk[fx] > rk[fy])std::swap(fx,fy);
fa[fx] = fy;
siz[fy] += siz[fx];
stk[++top] = fx;
stk2[top] = fy;
}
inline void del(){
int R = std::min(now + B,q);
int L = now;
ccnt = qcnt = 0;
for(int i = 1;i <= m;++i)
e[i] = D[i];
for(int i = 1;i <= n;++i)
fa[i] = i,siz[i] = 1;
top = 0;
for(;now <= R;++now){
int opt = read(),x = read(),y = read();
// scanf("%d%d%d",&opt,&x,&y);
// std::cout<<now<<std::endl;
// std::cout<<opt<<" "<<x<<" "<<y<<std::endl;
if(opt == 1){
C[++ccnt].x = x;
C[ccnt].y = y;
C[ccnt].tim = now;
}else{
Q[++qcnt].x = x;
Q[qcnt].y = y;
Q[qcnt].tim = now;
}
}
for(int i = 1;i <= m;++i)
vis[i] = 0;
for(int i = 1;i <= ccnt;++i)
vis[C[i].x] = 1;
for(int i = 1;i <= m;++i)
if(vis[i])
C[++ccnt].x = i,C[ccnt].y = e[i].p,C[ccnt].tim = 0;
std::sort(e + 1,e + m + 1,cmp1);
std::sort(Q + 1,Q + qcnt + 1,cmp);
std::sort(C + 1,C + ccnt + 1,cmp3);
// puts("Stand edge");
// for(int i = 1;i <= m;++i)
// std::cout<<e[i].x<<" "<<e[i].y<<" "<<e[i].p<<" "<<vis[i]<<std::endl;
int done = 1;
for(int i = 1;i <= qcnt;++i){
// puts("Query");
// std::cout<<Q[i].x<<" "<<Q[i].y<<" "<<Q[i].tim<<std::endl;
// std::cout<<"match"<<" "<<e[done].p<<std::endl;
while(e[done].p >= Q[i].y && done <= m){
if(!vis[e[done].id]){
merge(e[done].x,e[done].y);
}
++ done;
}
// puts("Change");
int las = top;
for(int j = 1;j <= ccnt;++j){
// std::cout<<C[j].x<<" "<<C[j].y<<" "<<C[j].tim<<" "<<used[C[j].x]<<std::endl;
if(C[j].tim <= Q[i].tim && !used[C[j].x]){
used[C[j].x] = 1;
if(C[j].y >= Q[i].y)
merge(D[C[j].x].x,D[C[j].x].y);
}
}
for(int j = 1;j <= ccnt;++j)
used[C[j].x] = 0;
fans[Q[i].tim] = siz[find(Q[i].x)];
// std::cout<<"getans"<<find(Q[i].x)<<" "<<siz[find(Q[i].x)]<<std::endl;
cancel(las);//回退到las
// puts("cancel_done");
// for(int j = 1;j <= n;++j)
// std::cout<<fa[j]<<" "<<siz[j]<<std::endl;
}
// std::sort(e + 1,e + m + 1,cmp2);
// std::sort(C + 1,C + ccnt + 1,cmp5);
for(int i = ccnt;i >= 1;--i){
// std::cout<<C[i].x<<" "<<C[i].y<<std::endl;
D[C[i].x].p = C[i].y;
}
}
template <typename T>
void write(T x)
{
if(x < 0) {
putchar('-');
x = -x;
}
if(x > 9)
write(x/10);
putchar(x % 10 + '0');
return;
}
int main(){
std::srand(time(0));
n = read(),m = read();
for(int i = 1;i <= n;++i)
rk[i] = rand() << 15 | rand(),siz[i] = 1;
for(int i = 1;i <= m;++i){
int x,y,c;
x = read();
y = read();
c = read();
e[i].x = x,e[i].y = y,e[i].p = c,e[i].id = i;
D[i] = e[i];
}
q = read();
while(now <= q){
del();//del with the block
}
for(int i = 1;i <= q;++i)
if(fans[i])
write(fans[i]),puts("");
}
/*
7 8
1 2 5
1 6 5
2 3 5
2 7 5
3 4 5
4 5 5
5 6 5
6 7 5
5
1 1 1
1 2 3
1 5 2
1 3 1
2 4 2
*/
CF1588F Jumping Through the Array
考虑操作分块。
考虑每个块只会有\(B\)个操作。
那么我们把操作的点作为黑点。
我们发现其黑点的个数只有\(O(B)\)个。
那么我们把一串白色的点给他全合并，则其是静态的。
其这样的白色链也为\(O(B)\)。
操作二，我们直接\(O(B)\)暴力更改其所在环的白链的\(\Delta\)。
操作三，我们直接\(O(1)\)交换两黑点所在的置换环的答案。
查询时我们直接查询每个白链其在二分\([l,r]\)的答案以及暴力枚举黑点。
其复杂度为\(O(\frac{q}{B} * n + q * (B + B log n) )\)
