再努力一次
再努力一次吧。
牛客多校第一场F.cut
对于区间“合并”，段数变化是O(n)的
在一段里面，数字都是递增或递减的
只需要维护一颗权值线段树，以及递增递减标志就可以表示完整个区间
把一段分成两段，或者把两段合成一段，本质就是线段树的合并或者分裂，都可以实现
每次询问，先把l，r分裂出来，然后中间不断合并即可
点击查看代码
#include<bits/stdc++.h>
using namespace std;
const int N=5000005;
set<int> ss;
struct node
{
int l,r,len,ans;
node (int _l,int _r,int _len,int _ans):l(_l),r(_r),len(_len),ans(_ans){}
node()
{
l=r=ans=len=0;
}
node friend operator +(node a,node b)
{
if (!b.len) return a;
if (!a.len) return b;
return node(a.l,b.r,a.len+b.len,a.ans+b.ans+((a.r&1)^(b.l&1)));
}
void print ()
{
printf("%d %d %d %d\n",l,r,len,ans);
}
}tr[N*2],seg[N/10];int num;
bool rev[N];
vector<int> Del;
int s1[N],s2[N];
int rt[N];
int n,m;
int new_node ()
{
int x;
if (!Del.empty()) {x=Del.back();Del.pop_back();}
else x=++num;
return x;
}
void del (int x) {Del.push_back(x);s1[x]=s2[x]=0;tr[x].len=tr[x].ans=0;}
void bt (int &now,int L,int R,int x)
{
now=new_node();
if (L==R)
{
tr[now]=node(x,x,1,0);
return ;
}
int mid=(L+R)>>1;
if (x<=mid) bt(s1[now],L,mid,x);
else bt(s2[now],mid+1,R,x);
tr[now]=tr[s1[now]]+tr[s2[now]];
}
int Merge (int rt1,int rt2)
{
if (rt1==0||rt2==0) return rt1|rt2;
// printf("%d %d\n",rt1,rt2);
s1[rt1]=Merge(s1[rt1],s1[rt2]);
s2[rt1]=Merge(s2[rt1],s2[rt2]);
tr[rt1]=tr[s1[rt1]]+tr[s2[rt1]];
del(rt2);
return rt1;
}
void modify (int now,int l,int r,int x)
{
if (l==r)
{
seg[now]=tr[rt[x]];
if (rev[x]) swap(seg[now].l,seg[now].r);
return ;
}
int mid=(l+r)>>1;
if (x<=mid) modify(now<<1,l,mid,x);
else modify(now<<1|1,mid+1,r,x);
seg[now]=seg[now<<1]+seg[now<<1|1];
}
node query (int now,int L,int R,int l,int r)
{
if (L==l&&R==r) return seg[now];
int mid=(L+R)>>1;
if (r<=mid) return query(now<<1,L,mid,l,r);
else if (l>mid) return query(now<<1|1,mid+1,R,l,r);
else return query(now<<1,L,mid,l,mid)+query(now<<1|1,mid+1,R,mid+1,r);
}
void split (int rt1,int &rt2,int k,int Rev)
{
if (tr[rt1].len==k) return ;
rt2=new_node();
if (Rev==0)
{
if (k>tr[s1[rt1]].len) split(s2[rt1],s2[rt2],k-tr[s1[rt1]].len,Rev);
else
{
swap(s2[rt1],s2[rt2]);
split(s1[rt1],s1[rt2],k,Rev);
}
}
else
{
if (k>tr[s2[rt1]].len) split(s1[rt1],s1[rt2],k-tr[s2[rt1]].len,Rev);
else
{
swap(s1[rt1],s1[rt2]);
split(s2[rt1],s2[rt2],k,Rev);
}
}
tr[rt1]=tr[s1[rt1]]+tr[s2[rt1]];
tr[rt2]=tr[s1[rt2]]+tr[s2[rt2]];
}
set<int> :: iterator SP(int x)
{
auto now=ss.lower_bound(x);
if (*now==x) return now;
now--;
split(rt[*now],rt[x],x-*now,rev[x]=rev[*now]);
modify(1,1,n,*now);
modify(1,1,n,x);
return ss.insert(x).first;
}
int main()
{
scanf("%d%d",&n,&m);
ss.insert(n+1);
for (int u=1;u<=n;u++)
{
int x;
scanf("%d",&x);
bt(rt[u],1,n,x);
modify(1,1,n,u);
ss.insert(u);
}
while (m--)
{
int op,l,r;
scanf("%d%d%d",&op,&l,&r);
auto L=SP(l),R=SP(r+1);
if (op<=2)
{
L++;
for (auto i=L;i!=R;i++)
{
// tr[rt[*i]].print();
// tr[rt[l]].print();
rt[l]=Merge(rt[l],rt[*i]);
modify(1,1,n,*i);
//printf("Merge:%d %d\n",l,*i);
}
// tr[rt[l]].print();
rev[l]=op-1;
modify(1,1,n,l);
ss.erase(L,R);
}
else
{
printf("%d\n",query(1,1,n,l,r).ans+1);
}
}
return 0;
}
codeforces 1726F. Late For Work
可以发现，花在路上的时间，不管等不等灯都一定要花的
因此，我们可以前把每个路口当前的时间加上路程时间，然后变成路上都不需要花时间
然后每一个灯，能通过的时间\([L[i],R[i])\)，显然有\(L[i]=-c[i],R[i]=L[i]+g[i]\)
同时这也就是说我们每一个灯会拦住一段时间，前面来的人都会在这里被拦住
我们设\(f_i\)表示在第i个路口等了灯往后还要多久
这个显然是会走到下一个灯的地方，然后一直到那个灯的L才能走
相当于我们每一次要插入一段时间，表示这段时间都要等某一个灯
然后支持往后询问我要等哪一个灯
set对区间进行维护即可
codeforces 1065F
题意是任意一个叶子，所以可以用某一个浅的叶子刷
考虑dp，\(f_x\)表示从子树最后可以回到根，\(g_x\)表示不需要回到根
\(f\)只可以从\(f\)转移过来，并且需要满足该子树里面有一个可以到达父亲的节点来刷
\(g\)则可以再\(f\)的基础上再选择一个\(g\)，表示最后停在这个子树里面
codeforces 730I
I. Olympiad in Programming and Sports
n只有3000，是一个可以暴力跑费用流的范围。
但可以通过模拟费用流优化
每一条增广路只有以下四种情况:
1.选择一个A
2.选择一个B
3.选择一个A，并将一个A换为B
4.选择一个B，并将一个B换为A
用四个堆分别维护这四个操作即可
gym102538 E
easywin
之前在随缘更新题解里面写过一次。
但当时偷懒没有写代码。
照着当时写的思路把坑补上了。
亲测写得还是很清晰的
codeforce865D
cf865D
我们可以让某一天可以同时买或同时卖，这样相互抵消就可以了
因此可以先假设每一天都买
然后考虑是否要卖出，如果卖出了，那么一定是选择之前最便宜的一个
值得注意的是，如果我们再某一天选择了卖出，并借此换掉了之前的一支股票。那么我们再这一天其实是可以买两次的，可以理解为反悔当天买入的操作。
种树
种树
题目大意：有n个数，要你在里面不超过选择k个，要求不能有选择的数相邻。问你最大价值是多少。
题解：
经典老番了。
先介绍一个经典的贪心思路：
如果我们选择了i，那么i-1和i+1要么同时选，要么同时不选。因为如果只选了一个显然不如选会i优。
因此便有了贪心的思路，选完i后，把i，i+1，i-1合并成a[i+1]+a[i-1]-a[i]。然后重复子问题即可。
再介绍一个费用流的思路：
两排点，第一排为奇数的间隔，第二排为偶数的间隔。两排点之间以具体的数来连边。然后跑流量为k的费用流即可。
考虑模拟费用流，可以发现，每一次我们一定会选择一段 （不选，选，不选，选，不选），然后集体大反转
可以得到和上面贪心一模一样的做法。
