海亮日寄2.0

day -inf

回大连再写

算了，开写

听说期末考试不补考了，于是停课在410写bytoj

笑死，停课一周写了bytoj的1/4

一大早六点半从家里出发去赶飞机，顺便在机场吃了早饭

大家都没来，东方幻想eclipse启动！需要更新？？？pubg启动！账号寄了？？

我***************************************************************************************************

很好，飞机晚点半小时，于是在机场傻站着

终于到了hl，没有收手机，于是开新号玩游戏，爽！

day1 6.27 构造题专练

[正睿集训2021] 构造专练 - C202044zxy - 博客园 (cnblogs.com)

原题都在这里了

t1

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    if(n%2==0)
    {
        cout<<"NO"<<endl;
        return 0;
    }
    cout<<"YES"<<endl;
    for(int i=0;i<n;i++)
    {
        cout<<i<<endl;
    } 
    for(int i=0;i<n;i++)
    {
        cout<<i<<endl;
    }
    for(int i=0;i<n;i++)
    {
        cout<<2*i%n<<endl;
    }
    return 0;
}

 

t2

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    n=pow(2,n)-1;
    int sum=n*(n-1)/6;
    cout<<sum<<endl;
    for(int i=1;i<=n;i++)
    {
        for(int j=1+i;j<=n;j++)
        {
            int k=0 xor i xor j;
            if(k>j)
            {
                cout<<k<<" "<<i<<" "<<j<<endl;
            }
        }
    }
    return 0;
}

 

t3 最恶心的一集

#include<bits/stdc++.h>
using namespace std;
vector<pair<int,int>>q[11451];
int n;
int main()
{
    cin>>n;
    for(int i=0;i<2*n-1;i++)
    {
        for(int j=i+1;j<2*n-1;j++)
        {
            q[(i+j)%(2*n-1)].push_back(make_pair(i,j));
        }
    }
    for(int i=0;i<2*n-1;i++)
    {
        q[2*i%(2*n-1)].push_back(make_pair(i,2*n-1));
    }
    for(int i=0;i<2*n-1;i++)
    {
        for(auto ans:q[i])
        {
            cout<<ans.first+1<<" "<<ans.second+1<<endl;
        }
    }
    return 0;
}

 

注意上述代码不开o2过不了

t4

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2020;
int per[maxn],st[maxn],top;
int n;
std::set<int> s[maxn];
inline int adde(int x,int y){
    if(s[x].count(y)||s[y].count(x))return 1;
    s[x].insert(y),s[y].insert(x);
    return 0;
}
char buf[(int)1e8],*vout=buf;
inline void pc(int x){*vout++=x;}
inline void put(int x){
    if(x>9)put(x/10);
    pc(x%10+48);
}
int main(){
    scanf("%d",&n);
    put(n/2),pc(10);
    for(int i=1;i<=n;i+=2)per[i]=++top;
    top=n;
    for(int i=2;i<=n;i+=2)per[i]=top--;
    for(int i=1;i<=n/2;++i){
        for(int j=1;j<n;++j){
            put(per[j]),pc(' '),put(per[j+1]),pc(' ');
        }
        for(int i=1;i<=n;++i)++per[i]==n+1?per[i]=1:0;
        pc(10);
    }
    fwrite(buf,vout-buf,1,stdout);
}

 

不知道为啥，hloj没法交cf的题，索性交洛谷

_________________________________________________________可爱的分割线_______________________________________________________________________________________

连自己想+看题解+问别人终于写了十道题，1k pts

来之前我洛谷只AC了7道紫题

今天一晚上写了4紫+1黑

由于紫题之前做过一些，所以索性说一下那个黑题

传送门：Rectangular Polyline - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

其实这道题好像数学上向量的基底分解

只需要用背包维护存在$|𝑎𝑖|=𝑙𝑖,|𝑏𝑖|=𝑝𝑖且\sum ai=\sum bi=0，其中i\in [1,n]$

$woc，$$快九点了$

$直接上代码$

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
bitset<maxn*maxn>f[maxn];
int t,n,m,a[maxn],b[maxn];
inline cal(int *a)
{
    int m=0;
    for(int i=1;i<=n;i++)
    {
        m+=a[i];
    }
    if(m&1)
    {
        return 0;
    }
    m>>=1;
    for(int i=1;i<=n;i++)
    {
        f[i]=((f[i-1])|(f[i-1]<<a[i]));
    }
    if(!f[n][m])
    {
        return 0;
    }
    for(int i=n;i;i--)
    {
        if(!f[i-1][m])
        {
            m-=a[i];
            a[i]=-a[i];
        }
    }
    return 1;
}
int main()
{
    f[0][0]=1;
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        cin>>m;
        for(int i=1;i<=m;i++)
        {
            cin>>b[i];
        }
        if((n!=m) or (!cal(a)) or (!cal(b)))
        {
            cout<<"NO"<<endl;
            continue;
        }
        int cnt=0;
        for(int i=1;i<=n;i++)
        {
            cnt+=(a[i]<0)-(b[i]<0);
        }
        if(cnt<0)
        {
            for(int i=1;i<=n;i++)
            {
                a[i]=-a[i];
                b[i]=-b[i];
            }
        }
        sort(a+1,a+1+n),reverse(a+1,a+1+n);
        sort(b+1,b+1+n),reverse(b+1,b+1+n);
        for(int i=1;i<=n+1;i++)
        {
            if((i>n) or (a[i]<0))
            {
                reverse(b+1,b+i);
                break;
            }
        }
        for(int i=n;i>=0;i--)
        {
            if((!i) or (b[i]>0))
            {
                reverse(a+i+1,a+1+n);
                break;
            }
        }
        cout<<"YES"<<endl;
        for(int i=1,x=0,y=0;i<=n;i++)
        {
            x+=a[i];
            cout<<x<<" "<<y<<endl;
            y+=b[i];
            cout<<x<<" "<<y<<endl;            
        }
    }
    return 0;
}

 

 day2 6.28

上午模拟赛，全是remote judge题，结果codeforces崩了（估计现在毛子们在睡觉，服务器下线维护了）

前两题煞笔题目，20分钟拿下

t3，好像可以参照转换二进制写法，对k取模之后进行计算（k进制数最大为k--），但是注意要有qpow，否则日爆

#include<bits/stdc++.h>
using namespace std;
const int maxn = 114;
const int inf = 1e6;
typedef long long ll;
ll t,n,k,cnt,a[maxn],vis[maxn],fac[maxn];
int main()
{
    cin>>t;
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        cin>>n>>k;
        fac[0]=1;
        for(int i=1;fac[i-1]<inf;i++)
        {
            fac[i]=fac[i-1]*k;
            cnt=i;
        }
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        for(int i=1;i<=n;i++)
        {
            int p=0;
            while(a[i])
            {
                vis[p]+=a[i]%k;
                a[i]/=k;
                p++;
            }
        }
        bool flag=false;
        for(int i=0;i<=cnt;i++)
        {
            if(vis[i]>1)
            {
                flag=true;
            }
        }
        if(flag)
        {
            cout<<"NO"<<endl;
        }
        else
        {
            cout<<"YES"<<endl;
        }
    }
    return 0;
}

 

t4

智商正常的应该都能看出来相等的一组数肯定在最大值的两边，那么可以将除了最大值外的所有数分在最大值的两边

然而至少有三个数才可以进行上述操作，加个特判就完事了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
inline ll read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
inline ll ksm(ll a,ll b)
{
    ll res=1;
    while(b)
    {
        if(b&1)
        {
            res=res*a%mod;
        }
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
ll ans=1,res=1;
int main()
{
    int n=read(),m=read();
    if(n==2)
    {
        cout<<0<<endl;
        return 0;
    }
    for(int i=1;i<=m;i++)
    {
        ans=ans*i%mod;
    }
    for(int i=1;i<=n-1;i++)
    {
        res=res*i%mod;
    }
    for(int i=1;i<=m-n+1;i++)
    {
        res=res*i%mod;
    }
    ans=((ans*ksm(res,mod-2)%mod)*(n-2)%mod)*ksm(2,n-3)%mod;
    cout<<ans<<endl;
    return 0;
}

 

t5

区间dp大水题

只需要找到[l,r]长度和区间和的特殊情况，就可以结束了

#include<bits/stdc++.h>
using namespace std;
const int maxn = 505;
int a[maxn],n,dp[maxn][maxn];
int sum[maxn][maxn];
//sum qujianhe
//dp qujianchangdu min
int main()
{
    memset(dp,1e6,sizeof(dp));
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        dp[i][i]=1;
        sum[i][i]=a[i];
    }
    for(int k=2;k<=n;k++)
    {
        for(int l=1;l+k-1<=n;l++)
        {
            int r=l+k-1;
            for(int mid=l;mid<r;mid++)
            {
                dp[l][r]=min(dp[l][r],dp[l][mid]+dp[mid+1][r]);
                if(sum[l][mid]==sum[mid+1][r] and dp[l][mid]==1 and dp[l][mid]==dp[mid+1][r])
                {
                    dp[l][r]=1;
                    sum[l][r]=sum[l][mid]+1;
                }
            }
        }
    }
    cout<<dp[1][n]<<endl;
    return 0;
}

 

t5写完就剩10分钟了，索性开摆

就是说今天cf怎么推出oi赛制了

中午回寝室，累的厉害，于是躺在床上探讨哲学问题和恋爱心理

就是说hl的床，上铺翻身的时候下面跟坐船一样，晃得厉害，俗称《有推背感》

day3 6.29

说在前面，考试前不要眼瞎，看清楚是标准输入输出还是文件读写，这个神操作导致我33pts-—>0pts

警钟撅烂

题目挺难，考完瞬间想退役了

 

但是听完讲解感觉自己又行了（“很难不想到”）

不细说了，离谱

day4 6.30

上午团建，累死，下午回寝室玩到4点半。

听说要学平衡树了，于是预习，还有亲手调了一个小时才写完的splay板子，直到发现把-inf写成了inf，自己脑补精神状态

 

#include<bits/stdc++.h>
#define root tree[0].ch[1]
#define inf 1000000005
using namespace std;
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
struct Splay{
    int fa,ch[2],v,sum,rec;
}tree[50005];
int tot=0;
inline bool findd(register int x)
{
    return x==tree[tree[x].fa].ch[0]?0:1;
}
inline void connect(register int x,register int fa,register int son)
{
    tree[x].fa=fa;
    tree[fa].ch[son]=x;
}
inline void update(register int x)
{
    tree[x].sum=tree[tree[x].ch[0]].sum+tree[tree[x].ch[1]].sum+tree[x].rec;
}
inline void rotate(register int x)
{
    int Y=tree[x].fa;
    int R=tree[Y].fa;
    int Yson=findd(x);
    int Rson=findd(Y);
    int B=tree[x].ch[Yson^1];
    connect(B,Y,Yson);
    connect(Y,x,Yson^1);
    connect(x,R,Rson);
    update(Y),update(x);
}
inline void splay(register int x,register int to)
{
    to=tree[to].fa;
    while(tree[x].fa!=to)
    {
        int y=tree[x].fa;
        if(tree[y].fa==to)
            rotate(x);
        else if(findd(x)==findd(y))
            rotate(y),rotate(x);
        else
            rotate(x),rotate(x);
    }
}
inline int newpoint(register int v,register int fa)
{
    tree[++tot].v=v;
    tree[tot].fa=fa;
    tree[tot].sum=tree[tot].rec=1;
    return tot;
}
inline void Insert(register int x)
{
    int now=root;
    if(root==0)
    {
        newpoint(x,0);
        root=tot;
    }
    else
    {
        while(1)
        {
            ++tree[now].sum;
            if(x==tree[now].v)
            {
                ++tree[now].rec;
                splay(now,root);
                return;
            }
            int nxt=x<tree[now].v?0:1;
            if(!tree[now].ch[nxt])
            {
                int p=newpoint(x,now);
                tree[now].ch[nxt]=p;
                splay(p,root);
                return;
            }
            now=tree[now].ch[nxt];
        }
    }
}
inline int find(register int x)
{
    int now=root;
    while(1)
    {
        if(x==tree[now].v)
        {
            splay(now,root);
            return now;
        }
        int nxt=x<tree[now].v?0:1;
        if(!tree[now].ch[nxt])
            return 0;
        now=tree[now].ch[nxt];
    }
}
inline void delet(register int x)
{
    int pos=find(x);
    if(!pos)
        return;
    if(tree[pos].rec>1)
    {
        --tree[pos].rec;
        --tree[pos].sum;
    }
    else
    {
        if(!tree[pos].ch[0]&&!tree[pos].ch[1])
            root=0;
        else if(!tree[pos].ch[0])
        {
            root=tree[pos].ch[1];
            tree[root].fa=0;
        }
        else
        {
            int left=tree[pos].ch[0];
            while(tree[left].ch[1])
                left=tree[left].ch[1];
            splay(left,tree[pos].ch[0]);
            connect(tree[pos].ch[1],left,1);
            connect(left,0,1);
            update(left);
        }
    }
}
inline int lower(register int v)
{
    int now=root,ans=-inf;
    while(now)
    {
        if(tree[now].v<v&&tree[now].v>ans)
            ans=tree[now].v;
        if(tree[now].v>v)
            now=tree[now].ch[0];
        else
            now=tree[now].ch[1];
    }
    return ans;
}
inline int upper(register int v)
{
    int now=root,ans=inf;
    while(now)
    {
        if(tree[now].v>v&&tree[now].v<ans)
            ans=tree[now].v;
        if(tree[now].v>v)
            now=tree[now].ch[0];
        else
            now=tree[now].ch[1];
    }
    return ans;
}
bool vis[50005];
int stac[50005],top=-1;
int main()
{
    memset(vis,false,sizeof(vis));
    int n=read(),m=read();
    Insert(0);
    Insert(n+1);
    while(m--)
    {
        char ch=getchar();
        while(ch!='D'&&ch!='R'&&ch!='Q')
            ch=getchar();
        if(ch=='D')
        {
            int x=read();
            vis[x]=true;
            stac[++top]=x;
            Insert(x);
        }
        else if(ch=='R')
        {
            vis[stac[top]]=false;
            delet(stac[top--]);
        }
        else
        {
            int x=read();
            if(vis[x])
                puts("0");
            else
            {
            cout<<(upper(x)-lower(x)-1)<<endl;
            }
        }
    }
    return 0;
}

 

day5 7.1

rfy限时返场讲课，平衡树？！

听FDsama等已经肝过金牌导航的神犇们说平衡树极其的简单

听完后我的评价是

简单个**

引用一下化竞大佬zyw的名言：“退竞！！！！！！！！！！！！！！！！！！！！”

我也是终于明白一道题写两个小时200 lines+结果写挂了是什么感觉了

但是有一说一，为什么rfy给的题好像没有一道题必须用平衡树？

A.luogu p3165

#include<bits/stdc++.h>
using  namespace std;
const int maxn = 1e5+5;
struct node
{
    int i,k;
}a[maxn];
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
int n,fa[maxn],siz[maxn],ch[maxn][2],root,tag[maxn];
inline bool cmp(node a,node b)
{
    if(a.k<b.k)
    {
        return 1;
    }
    if(a.k==b.k)
    {
        return a.i<b.i;
    }
    return 0;
}
inline void update(int x)
{
    siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+1;
}
inline void build(int l,int r,int f)
{
    if(l>r)
    {
        return;
    }
    int mid=(l+r)>>1;
    if(mid<f)
    {
        ch[f][0]=mid;
    }
    else ch[f][1]=mid;
    siz[mid]=1;
    fa[mid]=f;
    if(l==r)
    {
        return;
    }
    build(l,mid-1,mid);
    build(mid+1,r,mid);
    update(mid);
}
inline void down(int k)
{
    tag[k]^=1;
    if(ch[k][0])
    {
        tag[ch[k][0]]^=1;
    }
    if(ch[k][1])
    {
        tag[ch[k][1]]^=1;
    }
    swap(ch[k][1],ch[k][0]);
}
inline void roate(int x,int &goal)
{
    int y=fa[x],z=fa[y],k=ch[y][1]==x;
    if(y==goal)
    {
        goal=x;
    }
    else
    {
        ch[z][ch[z][1]==y]=x;
    }
    ch[y][k]=ch[x][k^1];
    ch[x][k^1]=y;
    fa[y]=x;
    fa[x]=z;
    fa[ch[y][k]]=y;
    update(y);
}
inline void splay(int x,int &goal)
{
    while(x!=goal)
    {
        int y=fa[x],z=fa[y];
        if(tag[z])
        {
            down(z);
        }
        if(tag[y])
        {
            down(y);
        }
        if(tag[x])
        {
            down(x);
        }
        if(y!=goal)
        {
            if(ch[y][1]==x^ch[z][1]==y)
            {
                roate(x,goal);
            }
            else
            {
                roate(y,goal);
            }
        }
        roate(x,goal);
        update(x);
    }
}
inline int find(int now,int k)
{
    if(tag[now])
    {
        down(now);
    }
    int l=ch[now][0],r=ch[now][1];
    if(siz[l]+1==k)
    {
        return now;
    }
    if(k<=siz[l])
    {
        return find(l,k);
    }
    return find(r,k-siz[l]-1);
}
inline void reverse(int l,int r)
{
    int x=find(root,l-1),y=find(root,r+1);
    splay(x,root);
    splay(y,ch[x][1]);
    tag[ch[y][0]]^=1;
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        a[i+1].k=read();
        a[i+1].i=i+1;
    }
    a[1].i=1;
    a[n+2].i=n+2;
    a[n+2].k=2000000001;
    sort(a+1,a+3+n,cmp);
    build(1,n+2,0);
    root=n+3>>1;
    int p;
    for(int i=2;i<=n;i++)
    {
        splay(a[i].i,root);
        p=siz[ch[root][0]]+1;
        cout<<p-1<<" ";
        reverse(i,p);
    }
    cout<<n<<endl;
    return 0;
}

B.cf702f treap树板子题（代码有亮点）

#include<bits/stdc++.h>
using namespace std;
#define ls(x) tr[x].l
#define rs(x) tr[x].r
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
const int maxn = 2e5+5;
struct treap
{
    int siz,val,sum,w;
    int l,r;
    int lazy,sub;
}tr[maxn];
int root,cnt,a,b,c;
inline int add(int k)
{
    tr[++cnt].val=k;
    tr[cnt].w=rand();
    tr[cnt].siz=1;
    tr[cnt].l=tr[cnt].r=tr[cnt].sum=tr[cnt].lazy=tr[cnt].sub=0;
    return cnt;
}
inline void pushup(int x)
{
    tr[x].siz=tr[ls(x)].siz+tr[rs(x)].siz+1;
}
inline void pushdown(int x)
{
    if(tr[x].lazy)
    {
        if(ls(x))
        {
            tr[ls(x)].lazy+=tr[x].lazy;
            tr[ls(x)].sum+=tr[x].lazy;
        }
        if(rs(x))
        {
            tr[rs(x)].lazy+=tr[x].lazy;
            tr[rs(x)].sum+=tr[x].lazy;
        }
        tr[x].lazy=0;
    }
    if(tr[x].sub)
    {
        if(ls(x))
        {
            tr[ls(x)].sub+=tr[x].sub;
            tr[ls(x)].val-=tr[x].sub;
        }
        if(rs(x))
        {
            tr[rs(x)].sub+=tr[x].sub;
            tr[rs(x)].val-=tr[x].sub;
        }
        tr[x].sub=0;
    }
}
inline void splitval(int x,int k,int &a,int &b)
{
    if(!x)
    {
        return a=b=0,void();
    }
    pushdown(x);
    if(k>=tr[x].val)
    {
        a=x;
        splitval(rs(x),k,rs(x),b);
    }
    else
    {
        b=x;
        splitval(ls(x),k,a,ls(x));
    }
    pushup(x);
}
inline void splitsiz(int x,int k,int &a,int &b)
{
    if(!x)
    {
        return a=b=0,void();
    }
    pushdown(x);
    if(k>=tr[ls(x)].siz+1)
    {
        a=x;
        splitsiz(rs(x),k-tr[ls(x)].siz-1,rs(x),b);
    }
    else
    {
        b=x;
        splitsiz(ls(x),k,a,ls(x));
    }
    pushup(x);
}
inline int merge(int x,int y)
{
    if(!x or !y)
    {
        return x|y;
    }
    pushdown(x);
    pushup(x);
    pushdown(y);
    pushup(y);
    if(tr[x].w<tr[y].w)
    {
        rs(x)=merge(rs(x),y);
        return pushup(x),x;
    }
    else
    {
        ls(y)=merge(x,ls(y));
        return pushup(y),y;
    }
}
inline void ins(int k)
{
    int a,b;
    splitval(root,k,a,b);
    root=merge(merge(a,add(k)),b);
}
inline void update(int x)
{
    if(!x)
    {
        return;
    }
    pushdown(x);
    update(ls(x));
    update(rs(x));
}
/******************************
treap-tree    juejueviki617
******************************/

int n,m;
struct node
{
    int c,q;
    bool operator<(const node &b) const
    {
        if(q!=b.q)
        {
            return q>b.q;
        }
        else
        {
            return c<b.c;
        }
    }
}p[maxn];
int v[maxn];
queue<int> q;
inline void build(int &r1,int r2,int x)
{
    int a,b;
    while(!q.empty())
    {
        q.pop();
    }
    q.push(r2);
    while(!q.empty())
    {
        int tmp=q.front();
        q.pop();
        pushdown(tmp);
        if(ls(tmp))
        {
            q.push(ls(tmp));
        }
        if(rs(tmp))
        {
            q.push(rs(tmp));
        }
        splitval(r1,tr[tmp].val-p[x].c,a,b);
        ls(tmp)=rs(tmp)=tr[tmp].lazy=tr[tmp].sub=0;
        tr[tmp].val-=p[x].c;
        tr[tmp].siz=1;
        tr[tmp].sum++;
        r1=merge(merge(a,tmp),b);
    }
}
inline void work(int x)
{
    int a,b,c;
    splitval(root,p[x].c-1,a,b);
    splitval(b,(p[x].c<<1)-1,b,c);
    tr[c].sub+=p[x].c;
    tr[c].val-=p[x].c;
    tr[c].sum++;
    tr[c].lazy++;
    build(a,b,x);
    root=merge(a,c);
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        p[i].c=read();
        p[i].q=read();
    }
    sort(p+1,p+1+n);
    m=read();
    for(int i=1;i<=m;i++)
    {
        int x=read();
        ins(x);
    }
    for(int i=1;i<=n;i++)
    {
        work(i);
    }
    update(root);
    for(int i=1;i<=m;i++)
    {
        cout<<tr[i].sum<<" ";
    }
    return 0;
}

后续不写了，因为t6我没写，其他的因为被平衡树折磨地索性不用了qwq

 /*

在这里特别说几句，部分人学竞赛成绩还挺好的，但是你有什么资本仗着自己成绩好在机房发癫，觉得自己光荣吗？

我想问一句，你是没有母本，无性生殖的产物吗？？？？

长的跟朱元璋似的还真以为自己能诛别人九族吗

忘了，这种人本身就没有九族

说谁谁知道，自己想对号入座我也不拦着

*/

day6 7.2

今天发生啥了？

好像就是在补题

不写了

但是部分煞笔每天恶心我好几回就不地道了吧（某位天天鸡叫的唐氏小青年）

 

但是我好奇一件事，这是谁干的

 day7 7.3

来hl一周了

上午打cf t1-t3我都不知道怎么ac的，t4不会，后来才知道不是博弈论

直接跳到了t5

暴力搜索，因为数据范围不大，索性过了

总之寄了

赞美cf的罚时制度和极其小的数据范围！！！

晚上搬寝室，但是海初宿舍的楼梯是真的高，满头大汗，赞美帮我们搬行李的hlgg

有句话说的不错，叫做学oi就像人生，退役和离世一样都是必然而无可避免的。FDsama想要送porter“最后一程”，于是协商和我换寝室。

不想写了，部分傻逼恶心死我了。说谁自己心里清楚。

寝室里其他人大多数只是问了一下我为什么和唐老师swap了，了解情况后自己忙自己的了，部分人单方面提出我前来没有经过“你们”的同意

我记得唐老师问过你们寝室的人吧

看来是没经过你本人的同意，但是你本人凭啥代表你整个寝室来冲我贴脸开大？你配吗？

你！

不！

配！

傻逼

纯傻逼

之前无数次在机房公然骂我傻逼

我知道你的名字是“傻逼”，别天天挂嘴边

唐老师想在自己回jp24之前多陪陪自己好友有什么不对（porter可爱tietie）

 

祝愿你爸妈死的时候没人守灵，傻逼玩意

不对，你需要父母吗？

update：我是来自7.5的zimo，根据FDsama说，上述内容在div2机房已经有人看见过了，而且都好奇是谁。

这里说一句，知道是谁对你们没有好处，想知道的自己打听，之后这些内容不再更新，也不会删除，集训结束后我会原模原样发到群里。

day8 7.4

前几天看了孙宝的博客，提到女生宿舍禁止男生入内，男寝门口没有（我想看哈利波特了）

所以这个告诉我们add(x,y)与add(y,x)是不同的

上午预习数据结构“水题”，这要是水题我tm都想退竞了

有人看B站被hzg抓包了

我不说是谁

好的，接下来说一说难评的数据结构题

 偶，今天是7.5

所以就7.5再说吧

day9 7.5

好的，今天模拟——焯！

oi赛制——焯！

三个半小时——焯！

cdx：这道题如果没写到45pts你就要考虑一下这个班级是否适合你——焯！

t1是个简单无比（真的很简单）的dfs，可惜考场上没看出来，于是决定输出20pts的特殊性质骗分。但是题目审错了，cout<<0;很显然爆零了qwq。

jyy：它即使已经成星了你也可以删掉点集让度数>=3啊

好的，第二题，容斥+高维前缀和

不好意思，老子不会

t3

其实正解也快做出来了，但是时间不够，于是写暴力骗分

好的，确实没爆零

t4

我的电脑怎么有网了？哦，十一点了，算了不做了。

 

马上吃晚饭了，再做题肯定是不现实的

索性补一下昨天该写的数据结构题

A. New Year and Conference

好神奇的一道题，其实改一下形式化题意就简单一点了，所以用线段树维护一下就万事大吉

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
const int inf = 0x3f3f3f3f;
int n,cnt,id[maxn<<2];
bool flag=true;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
struct node
{
    int s,t,x,y;
    bool operator <(const node &a) const
    {
        if(x==a.x)
        {
            return y<a.y;
        }
        else return x<a.x;
    }
}a[maxn];
inline int ls(int x)
{
    return x<<1;
}
inline int rs(int x)
{
    return x<<1|1;
}
struct xds
{
    int mx[maxn<<4],mn[maxn<<4];
    inline void build(int l,int r,int x)
    {
        mx[x]=0,mn[x]=inf;
        if(l==r)
        {
            return;
        }
        int mid=(l+r)>>1;
        build(l,mid,ls(x));
        build(mid+1,r,rs(x));
        return;
    }
    inline void pushup(int x)
    {
        mx[x]=max(mx[ls(x)],mx[rs(x)]);
        mn[x]=min(mn[ls(x)],mn[rs(x)]);
    }
    inline void change(int pos,int l,int r,int x,int val)
    {
        if(l==r)
        {
            mx[x]=max(val,mx[x]);
            mn[x]=min(val,mn[x]);
            return;
        }
        int mid=(l+r)>>1;
        if(pos<=mid)
        {
            change(pos,l,mid,ls(x),val);
        }
        else
        {
            change(pos,mid+1,r,rs(x),val);
        }
        pushup(x);
        return;
    }
    inline int qumax(int lp,int rp,int l,int r,int x)
    {
        if(lp<=l and rp>=r)
        {
            return mx[x];
        }
        int res=0;
        int mid=(l+r)>>1;
        if(lp<=mid)
        {
            res=max(res,qumax(lp,rp,l,mid,ls(x)));
        }
        if(rp>mid)
        {
            res=max(res,qumax(lp,rp,mid+1,r,rs(x)));
        }
        return res;
    }
    inline int qumin(int lp,int rp,int l,int r,int x)
    {
        if(lp<=l and rp>=r)
        {
            return mn[x];
        }
        int res=inf;
        int mid=(l+r)>>1;
        if(lp<=mid)
        {
            res=min(res,qumin(lp,rp,l,mid,ls(x)));
        }
        if(rp>mid)
        {
            res=min(res,qumin(lp,rp,mid+1,r,rs(x)));
        }
        return res;
    }
}t,s;
inline void work()
{
    s.build(1,cnt,1);
    t.build(1,cnt,1);
    for(int i=1;i<=n;i++)
    {
        int maxx=t.qumax(a[i].x,cnt,1,cnt,1);
        int minn=s.qumin(a[i].x,cnt,1,cnt,1);
        if(minn<a[i].s or maxx>a[i].t)
        {
            flag=false;
        }
        t.change(a[i].y,1,cnt,1,a[i].s);
        s.change(a[i].y,1,cnt,1,a[i].t);
    }
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        a[i].x=read();
        a[i].y=read();
        a[i].s=read();
        a[i].t=read();
        id[++cnt]=a[i].x;
        id[++cnt]=a[i].s;
        id[++cnt]=a[i].y;
        id[++cnt]=a[i].t;
    }
    sort(id+1,id+1+cnt);
    cnt=unique(id+1,id+1+cnt)-(id+1);
    for(int i=1;i<=n;i++)
    {
        a[i].x=lower_bound(id+1,id+1+cnt,a[i].x)-id;
        a[i].y=lower_bound(id+1,id+1+cnt,a[i].y)-id;
        a[i].s=lower_bound(id+1,id+1+cnt,a[i].s)-id;
        a[i].t=lower_bound(id+1,id+1+cnt,a[i].t)-id;
    }
    sort(a+1,a+1+n);
    work();
    for(int i=1;i<=n;i++)
    {
        swap(a[i].x,a[i].s);
        swap(a[i].y,a[i].t);
    }
    sort(a+1,a+1+n);
    work();
    if(flag)
    {
        cout<<"YES"<<endl;
    }
    else
    {
        cout<<"NO"<<endl;
    }
    return 0;
}

B. Lexicographically Small Enough

写了个树状数组

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5+5;
const ll inf = 1e18;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
namespace aclove //juejue
{
    int n;
    bool b[maxn];
    char s[maxn],t[maxn];
    ll ans,ans2,c[maxn];
    inline int lowbit(int x)
    {
        return (-x)&x;
    }
    inline void u(int p,int d)
    {
        for(;p<=n;p+=lowbit(p))
        {
            c[p]+=d;
        }
    }
    inline ll q(int p,ll s=0)
    {
        for(;p;p-=lowbit(p))
        {
            s+=c[p];
        }
        return s;
    }
    inline int work()
    {
        int T=read();
        while(T--)
        {
            ans=inf;
            ans2=0;
            memset(c,0,sizeof(c));
            memset(b,0,sizeof(b));
            vector<int> ap[26];
            n=read();
            scanf("%s %s",s+1,t+1);
            for(int i=1;i<=n;i++)
            {
                ap[s[i]-'a'].emplace_back(i);
            }
            for(int i=0;i<26;i++)
            {
                reverse(ap[i].begin(),ap[i].end());
            }
            for(int i=1,p=1,c_last;i<=n;i++)
            {
                while(b[p] and p<n)
                {
                    p++;
                }
                if(s[p]>=t[i])
                {
                    c_last=n+1;
                    for(int j=0;j<t[i]-'a';j++)
                    {
                        if(ap[j].size() and *ap[j].rbegin()<c_last)
                        {
                            c_last=*ap[j].rbegin();
                        }
                    }
                    if(c_last != n+1)
                    {
                        ans=min(ans,ans2+c_last-p+q(c_last)-q(p));
                    }
                }
                else 
                {
                    ans=min(ans,ans2);
                }
                if(s[p]!=t[i])
                {
                    if(!ap[t[i]-'a'].size())
                    {
                        break;
                    }
                    c_last=*ap[t[i]-'a'].rbegin();
                    b[c_last]=true;
                    ans2+=c_last-p+q(c_last)-q(p);
                    u(p,1);
                    u(c_last,-1);
                    ap[t[i]-'a'].pop_back();
                }
                else
                {
                    ++p;
                    ap[t[i]-'a'].pop_back();
                }
            }
            printf("%lld\n", (ans < inf ? ans : -1));
        }
        return 0;
    }
}
using namespace aclove;
int main()
{
    work();
    return 0;
}

C. 「Wdsr-3」令人感伤的红雨

好喜欢题面，而且做这道题的时候耳机里刚好在放《被毁坏的护身符》（风神录二面关底bgm二创），都是《東方風神錄》的产物，好耶。（秋静叶：一面道中，秋穣子：一面关底）

原题给的柿子过于“答辩”了——konata

所以给算数天才cirno化简一下

可爱的并查集       

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 6e6+5;
int n,q,a[maxn],nxt[maxn],cost[maxn],fa[maxn];
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
inline int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    else 
    {
        return fa[x]=find(fa[x]);
    }
}
signed main()
{
    n=read(),q=read();
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
        fa[i]=i;
        nxt[i]=n+1;
        cost[i]=-1;
    }
    int tmp=1;
    for(int i=2;i<=n;i++)
    {
        if(a[i]>=a[tmp])
        {
            nxt[tmp]=i;
            cost[tmp]=a[i]-a[tmp];
            tmp=i;
        }
        else 
        {
            fa[i]=tmp;
        }
    }
    int opt,x,y,del;
    while(q--)
    {
        opt=read(),x=read(),y=read();
        if(opt==1)
        {
            tmp=find(x);
            cost[tmp]-=y;
            while(nxt[tmp]<n+1 and cost[tmp]<0)
            {
                del=nxt[tmp];
                cost[tmp]+=cost[del];
                nxt[tmp]=nxt[del];
                fa[del]=tmp;
                nxt[del]=n+1;
                cost[del]=-1;
            }
        }
        else
        {
            printf("%lld\n",max((long long)0,x-find(y)));
        }
    }
    return 0;
}

 

D. Guessing Permutation for as Long as Possible

我爱国，不做日本题

好的，带权并查集

#include<bits/stdc++.h>
using namespace std;
const int maxn = 405;
const int maxm = 160005;
const int mod = 1e9+7;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
int col[maxn][maxn];
int ti[maxn][maxn];
int fa[maxm<<1],n,m;
inline int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    else return fa[x]=find(fa[x]);
}
inline bool remerge(int x,int y)
{
    if(find(x)==find(y))
    {
        return 0;
    }
    if(find(x+m)==find(y+m))
    {
        return 0;
    }
    fa[find(x)]=find(y+m);
    fa[find(y)]=find(x+m);
    return 1;
}
inline bool merge(int x,int y)
{
    if(find(x)==find(y+m))
    {
        return 0;
    }
    if(find(y)==find(x+m))
    {
        return 0;
    }
    fa[find(x)]=find(y);
    fa[find(x+m)]=find(y+m);
    return 1;
}
int main()
{
    n=read();
    m=n*(n-1)/2;
    for(int i=1;i<=m;i++)
    {
        int x=read(),y=read();
        ti[x][y]=ti[y][x]=i;
    }
    for(int i=1;i<=m;i++)
    {
        fa[i]=i;
        fa[i+m]=i+m;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=i+1;k<=n;k++)
            {
                if(i!=j and j!=k)
                {
                    int tmp1=ti[i][j],tmp2=ti[i][k],tmp3=ti[j][k];
                    if(tmp2>max(tmp1,tmp3))
                    {
                        if(!(((i<j)^(j<k))?merge(tmp1,tmp3):remerge(tmp1,tmp3)))
                        {
                            cout<<0<<endl;
                            return 0;
                        }
                    }
                }
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        if(find(i)==find(i+m))
        {
            cout<<0<<endl;
            return 0;
        }
    }
    int ans=1,cnt=0;
    for(int i=1;i<=2*m;i++)
    {
        if(find(i)==i)
        {
            cnt++;
        }
    }
    for(int i=1;i<=cnt/2;i++)
    {
        ans=ans*2%mod;
    }
    cout<<ans<<endl;
    return 0;
}

E. 生日礼物

第一眼没会，用了Konata讲的方法，很炸裂的stl用法

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 1e5+5;
int n,m,cnt,ans,l[maxn],r[maxn],a[maxn];
bool flag[maxn];
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > q;
inline void del(int x)
{
    flag[x]=1;
    l[r[x]]=l[x];
    r[l[x]]=r[x];
}
int main()
{
    n=read(),m=read();
    int tmp=0;
    for(int i=1;i<=n;i++)
    {
        int x=read();
        if(!x)
        {
            continue;
        }
        if(1ll*a[tmp]*x>0)
        {
            a[tmp]+=x;
        }
        else 
        {
            a[++tmp]=x;
        }
    }
    n=tmp;
    for(int i=1;i<=n;i++)
    {
        if(a[i]>0)
        {
            cnt++;
            ans+=a[i];
        }
        l[i]=i-1;
        r[i]=i+1;
        q.push(make_pair(abs(a[i]),i));
    }
    while(cnt>m)
    {
        while(flag[q.top().second])
        {
            q.pop();
        }
        int x=q.top().second;
        q.pop();
        if((l[x] and r[x]!=n+1) or (a[x]>0))
        {
            --cnt;
            ans-=abs(a[x]);
            a[x]+=a[l[x]]+a[r[x]];
            q.push(make_pair(abs(a[x]),x));
            del(l[x]);
            del(r[x]);
        } 
        else 
        {
            del(x);
        }
    }
    cout<<ans<<endl;
    return 0;
}

H. 算术天才⑨与等差数列

为什么一下跳到了H

很简单，没时间做了

但是谁能拒绝cirno呢，有一说一，这道题今天早上才AC

可爱的线段树二分

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int sgt_sz = maxn << 2;
const int mod = 998244353;
const int inf = 2147483647;
const int inv6 = 166374059;

inline int min(const int &a, const int &b) { return (a <= b ? a : b); }
inline int max(const int &a, const int &b) { return (a >= b ? a : b); }

int n, m;
int a[maxn];

namespace SGT
{
    #define ls (k << 1)
    #define rs (k << 1 | 1)

    int sum[sgt_sz], mnv[sgt_sz];

    void push_up(int k) { sum[k] = (sum[ls] + sum[rs]) % mod, mnv[k] = min(mnv[ls], mnv[rs]); }

    void build(int k, int l, int r)
    {
        if (l == r) return sum[k] = 1ll * a[l] * a[l] % mod, mnv[k] = a[l], void();
        int mid = (l + r) >> 1;
        build(ls, l, mid), build(rs, mid + 1, r), push_up(k);
    }

    void update(int k, int l, int r, int p, int w)
    {
        if (l == r) return sum[k] = 1ll * w * w % mod, mnv[k] = w, void();
        int mid = (l + r) >> 1;
        if (p <= mid) update(ls, l, mid, p, w);
        else update(rs, mid + 1, r, p, w);
        push_up(k);
    }

    int query_min(int k, int l, int r, int ql, int qr)
    {
        if ((l >= ql) && (r <= qr)) return mnv[k];
        int mid = (l + r) >> 1, res = inf;
        if (ql <= mid) res = min(res, query_min(ls, l, mid, ql, qr));
        if (qr > mid) res = min(res, query_min(rs, mid + 1, r, ql, qr));
        return res;
    }

    int query_sum(int k, int l, int r, int ql, int qr)
    {
        if ((l >= ql) && (r <= qr)) return sum[k];
        int mid = (l + r) >> 1, res = 0;
        if (ql <= mid) res = (res + query_sum(ls, l, mid, ql, qr)) % mod;
        if (qr > mid) res = (res + query_sum(rs, mid + 1, r, ql, qr)) % mod;
        return res;
    }
}

int pw2_sum(int x) { return 1ll * x * (x + 1) % mod * (2 * x + 1) % mod * inv6 % mod; }

int main()
{
    // freopen("P5278_1.in", "r", stdin);
    // freopen("P5278_1.res", "w", stdout);
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    SGT::build(1, 1, n);
    int cnt = 0;
    while (m--)
    {
        int op, x, y, l, r, k;
        scanf("%d", &op);
        if (op == 1)
        {
            scanf("%d%d", &x, &y);
            x ^= cnt, y ^= cnt;
            SGT::update(1, 1, n, x, y);
        }
        else
        {
            scanf("%d%d%d", &l, &r, &k);
            l ^= cnt, r ^= cnt, k ^= cnt;
            int x = SGT::query_min(1, 1, n, l, r);
            int sum = (1ll * (r - l + 1) * x % mod * x % mod + 1ll * k * x % mod * (r - l) % mod * (r - l + 1) % mod + 1ll * k * k % mod * pw2_sum(r - l) % mod) % mod;
            int rsum = SGT::query_sum(1, 1, n, l, r);
            // printf("%d %d\n", sum, rsum);
            if (sum == rsum) puts("Yes"), cnt++;
            else puts("No");
        }
    }
    return 0;
}

 

中午花絮：那个管寝室跟管白公馆、渣滓洞一样的宿管可以去死了

这里是浙江，和重庆好像不是一个地方吧

寝室人数是生产队的驴吗？折磨精打细算

还有窗帘必须拉上两层（外面那一层跟蛇皮袋一样），不让在寝室喝汤吃泡面是什么性质

今天海宁学长去了医院，很好，就查了个血常规花费65CNY，无敌了

好的，晚上的杂题选讲

好的，又被叫到隔壁机房听cdx讲多维前缀和，留了11道题

不是，我模拟题还没补完qwq

补不完了qwq

day10 7.6

双囍临门——四喜丸子（确信）

今天模拟赛

不知道脑子怎么抽的

也可能是被前几天noip模拟赛折磨的

前2道题极其简单，我却因为觉得暴力会写挂在想别的做法

我**********************************************************************************************************************************************************************************************************************

突然想起海宁学长

用线段树做洛谷“校门外的树”（红题）

写挂了

不说了，补题去了qwq

有一说一，这场比赛图论含量好低啊

明天好像去图书馆

？！

再放送：有人劝我删除7.3的部分博客内容，我在plq解释很清楚了

寝室规则怪谈海亮信息竞赛怪谈 - 类人群星闪耀时 - 博客园 (cnblogs.com)

 day11 7.7

休息日，有手机了，这是好的。

但是有人被抓到图书馆了，还有个别卷狗去机房了

怎么都这么卷

算了，反正是休息日，开摆

day12 7.8

说在前面，不要在人工智能蓬勃发展的今天挑战反作弊系统的底线，不细说了

 t1 红黑树

这个东西我最开始想法是寒假曾经讲过的树上dp+树的直径

很显然我距离正解好像没差多少

然而我好像没理解题意，导致样例二都没过，很显然交上去是0分的

那么说一下正解，定义dp[x][v][2]，其中‘2’代表两种状态红/黑，整个式子代表将x作为根节点且有v个顶点是黑色的方案能否可行

但是一定注意，每一个状态从哪里转移过来的

预计时间复杂度O(n*max(v))，考虑题面要求，因此是O(nlogn)

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 505;
bool dp[maxn][maxn][2],ans[maxn];
int n,root,fa[maxn];
vector<int> g[maxn];
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0' or ch>'9')
    {
        if(ch=='-')
          f=-1;
        ch=getchar();
    }
    while(ch>='0' and ch<='9')
      x=x*10+ch-'0',ch=getchar();
    return x*f;
}
inline void dfs(int x)
{
    if(g[x].size()==0)
    {
        dp[x][1][1]=1;
        dp[x][0][0]=1;
        return;
    }
    if(g[x].size()==1)
    {
        int v=g[x][0];
        dfs(v);
        dp[x][1][1]=dp[v][0][0];
        return;
    }
    for(auto v:g[x])
    {
        dfs(v);
    }
    for(int j=0;j<=n;j++)
    {
        dp[x][j][0]=1;
        for(auto v:g[x])
        {
            dp[x][j][0]&=dp[v][j][1];
        }
        if(!j)
        {
            continue;
        }
        dp[x][j][1]=1;
        for(auto v:g[x])
        {
            dp[x][j][1]&=(dp[v][j-1][0] or dp[v][j-1][1]);
        }
    }
    return;
}
inline void work(int u,int k)
{
    if(dp[u][k][1])
    {
        ans[u]=1;
        for(auto v:g[u])
        {
            work(v,k-1);
        }
    }
    else
    {
        ans[u]=0;
        for(auto v:g[u])
        {
            work(v,k);
        }
    }
    return;
}
signed main()
{
    //freopen("rbt.in", "r", stdin);
    //freopen("rbt.out", "w", stdout);
    n=read();
    for(int i=1;i<=n;i++)
    {
        fa[i]=read();
        if(fa[i])
        {
            g[fa[i]].push_back(i);
        }
        else
        {
            root=i;
        }
    }    
    dfs(root);
    for(int i=0;i<=n;i++)
    {
        if(dp[root][i][0] or dp[root][i][1])
        {
            work(root,i);
            for(int j=1;j<=n;j++)
            {
                if(ans[j])
                {
                    cout<<'B';
                }
                else 
                {
                    cout<<'R';
                }
            }
            return 0;
        }
    }
    cout<<"Impossible"<<endl;
    return 0;
}

t2 xor

卢卡斯定理，高维前缀和，子集枚举，状压DP

这四个东西

Lucas：没想到，高维前缀和：刚学，不敢用，子集枚举：这是啥玩意 好像我只会状压dp

于是跳了

赛后按照cdx的题解的思路，写了一份，O(nlogn)

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 5e6+5;
int n,q,dep[maxn],ans,a[maxn],tmp[maxn];
vector<int> g[maxn];
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0' or ch>'9')
    {
        if(ch=='-')
          f=-1;
        ch=getchar();
    }
    while(ch>='0' and ch<='9')
      x=x*10+ch-'0',ch=getchar();
    return x*f;
}
inline void dfs(int u,int fa)
{
    dep[u]=dep[fa]+1;
     tmp[dep[u]]^=a[u];
     for(auto v:g[u])
     {
        if(v==fa)
        {
            continue;
        }
        dfs(v,u);    
    }
    return;
}
signed main()
{
    //freopen("xor.in","r",stdin);
    //freopen("xor.out","w",stdout);
    n=read(),q=read();
    for(int i=1;i<n;i++)
    {
        int u=read(),v=read();
        u++;
        v++;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
    }
    dep[0]=-1;
    dfs(1,0);
    int inf=(1<<20)-1;
    for(int i=0;i<20;i++)
    {
        for(int j=0;j<=inf;j++)
        {
            if((j>>i)&1)
            {
                tmp[j]^=tmp[j^(1<<i)];
            }
        }
    }
    while(q--)
    {
        int x=read();
        cout<<tmp[inf^(x&inf)]<<endl;
    }
    return 0;
}

好的，t3

不会cdq分治，于是开始用线段树瞎搞，由于开t3的时候只有半小时了，没写完，乐了

但是我好奇一件事，256MB内存限制的评测机我是怎么在没分治的情况下写出MLE的

但是由于数据比较水，所以暴力维护前缀和、后缀和可以轻松卡过60pts

显然我截至撰稿都没写出正解

t4

对n和k的取值进行分类讨论

这样可以推出所有情况的式子

所以这道题是组合数学+容斥原理

由于我只写出了暴力70pts算法，索性不附上去了 

 

 今天cdx讲了cdq分治

后来撒了一些鲜花，提到了有一些去年这个时候在div3的学长，他们曾经模拟赛都是时常十几二十分甚至爆零的存在。

现在他们在哪

他们没有AFO，而是在div1为NOI冲刺

所以，为了一时榜单上的光鲜亮丽，做苟且之事不值当。选择了竞赛注定你是不凡的，也是注定你要走遍荆棘的。

也请大家给我和猫雷一次改过的机会

反正不作弊了

day13 7.9

不知不觉来hl快两周了

woc，快学考了，于是昨天晚上在寝室刷学考卷子，然而发现没有什么意义

我之前担心学考会不会考很变态的生物遗传计算题

原来是我多虑了，首先必修二基本不考，其次......如果你Aa杂交都不会你还学个**oi

好的，于是我打开了化学，有一说一，为什么把我初中就学过的东西拿出来恶心我

哦，忘了，我初中不会有机化学，乙烯加成反应？甲烷燃烧？

好的，我们接下来看看历史地理，很好，历史如果不会请反思一下自己是不是中国人

至于地理还是要好好分析一下，思维难度跟0/1背包差不多

于是zimo骂骂咧咧地收起了学考卷子

突然想起MerlinLee的一句话：毕竟有普高民办职高技校的学生也要去考，所以不用担心。

上午开始学习动态规划问题，吃灰了好几个月的六倍定理判定素数有一次派上了用场，具体的code下午再放

今天上午中考出分了，恭喜tjy学弟斩获775分的高分，对于没考好的不要气馁，作为竞赛生来日方长。

好的，一道区间dp+三道数学题

但是注意一件事情，++cnt和cnt++是完全不同的

至少a[++cnt]与a[cnt++]是不一样的

写错了你可以轻易地体会到什么叫“紫气东来”

 今天tjy学弟提到了他们这一届的中考，我的评价是：我但凡晚出生一年我就不一定能去哪了

今年中考说句不好听的就是给廿四输送来了一群文科生

甚至可以说是输送来了一批废物

谁家中考酸碱盐金属盐溶液成分推断、物理混合压强还有混联电路不考的

以及那个用脚都能115+的数学卷

day14 7.10

来hl已经两周了，今天学概率期望dp

爽了

代码最少的一集

上午预习式训练，做了六道题，哦，吃饭了，不写了。

中午回寝室做学考地理卷，生物化学历史都挺好的

不是，地理我好像啥也不会

哎不是，我真就******************************************************************

化学生物学了一半的唐老师：¿

 好的，下午cdx讲期望概率dp

oi是mo（确信）

不，oi是一只巨大的猫猫（雾）

 突然发现，我不会懒得写LATEX

所以今天不写题解了

/******************************************************************************我是分割线********************/

突然发现，明天好像高二学长（如果排除一只D类艾希）就要奔赴国赛了

今天的夜晚属于你们，独属于你们

无论一年后的我能否走到国赛这一步

在这里祝愿4位正式选手（虽然有一位营口的，但是同样祝你顺利）在国赛上取得优异的成绩

高三很苦，不上也罢！

加油！学长学姐们！

day15 7.11

再见，波特......

上午模拟赛，希望别赤石了

按照飞机起飞的时间，讲评够呛能听完了

很好，下午回家学考，但是我地理水平能不能过都是问题啊qwq

day16 7.12

LN普通高等学校学业水平考试RP++

回家打风神录，爽！！！！！！

MD，晚上出去理发，回家没看路，摔了，脚崴了

焯！

（灯光秀以来又一次跌打损伤)7.15鲜花——2024dl24灯光秀游记 - 类人群星闪耀时 - 博客园 (cnblogs.com)

 day17 7.13

今日单曲循环：《命運的陰暗面》（风神录stage2键山雏的曲子）

学考归来

上午坐飞机，浙江省云层太厚飞机降不下来，赞美绕行最后成功降落的机长

（我差点以为飞机要备降到别的城市了）

（谁家坐飞机要过三次防爆检测） 我爸：oi不能白学，各种图论算法要用上

哦，他老人家大学的时候也是学过c语言和GIS的

回机房补比赛题目

好的，清一色的弱智题

day18 7.14

摆烂

在手机上玩东方，好爽（网易云电脑）

day19 7.15

好的，尘封已久的树上算法

记得半年前好像就是在用这些东西折磨lyn学长的（bushi）

对于dfs曾经inf次写出死递归的我来说

今天好像没有那么多死递归了

爽

赞美来调研学习进度的hlgg

/*******************************************分割线*************************************************/

今天寝室发病率有点高

猫雷极度头晕难受，唐老师重感冒

至于我

昨天吃完华莱士以后，吃华莱士几乎没有出过问题的我今天拉肚子了/kel

大家都快好起来吧

番外：FDsama一直想要抱一只猫娘睡觉

这边建议你抱一只转转（键山雏）睡觉（bushi）

晚上，机房突然传来一阵骚动

洛谷炸了！！！！！！！！！

把电脑vpn打开，也不能访问

但是换个浏览器就好用了

到这里可以得出结论：某个shaber在校内局域网域名劫持，不知道用什么方式只是针对edge浏览器进行域名劫持

感觉这个“三好学生”很像键山雏（《风神录》二面关底boss）

为什么呢？

防止我们在洛谷刷题“累死”出面阻止，尽管会给他人带来厄运（指洛谷日爆）

//感兴趣的可以玩一下原作

update：网络已经在晚上9点左右恢复正常

简单说说今天做的题(知周所众，图论的代码极其长)

t1 cf1528c

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 3e5+5;
const int inf = 0x3f3f3f3f;
int st[maxn<<1],ft[maxn<<1];
vector<int> g1[maxn<<1],g2[maxn<<1];
set<pair<int,int> > ps;
int ans,ti;
void dfs1(int u,int f)
{
    st[u]=++ti;
    for(auto v : g2[u])
    {
        if(v==f)
        {
            continue;
        }
        dfs1(v,u);
    }
    ft[u]=++ti;
}
void dfs2(int u,int fa)
{
    bool flag=false;
    pair<int,int> kep;
    auto tar=ps.lower_bound({st[u],0});
    if(tar==ps.end() or ft[u]<=ft[tar->second])
    {
        tar=ps.upper_bound({st[u],0});
        if(tar!=ps.begin())
        {
            tar--;
            if(ft[u]<=ft[tar->second])
            {
                kep=*tar;
                ps.erase(tar);
                flag=true;
            }
        }
        ps.insert({st[u],u});
    }
    ans=max(ans,(int)ps.size());
    for(auto v:g1[u])
    {
        if(v==fa)
        {
            continue;
        }
        dfs2(v,u);
    }
    if(ps.count({st[u],u}))
    {
        ps.erase({st[u],u});
    }
    if(flag)
    {
        ps.insert(kep);
    }
}
int main()
{
    int t=read();
    while(t--)
    {
        int n=read();
        ps.clear();
        for(int i=1;i<=n;i++)
        {
            g1[i].clear();
            g2[i].clear();
        }
        for(int i=2;i<=n;i++)
        {
            int fa=read();
            g1[i].push_back(fa);
            g1[fa].push_back(i);
        }
        for(int i=2;i<=n;i++)
        {
            int fa=read();
            g2[i].push_back(fa);
            g2[fa].push_back(i);            
        }
        ti=0;
        ans=0;
        dfs1(1,0);
        dfs2(1,0);
        cout<<ans<<endl;
    }
    return 0;
}

t2 cf1707c

一定注意，树上差分结束以后必须重写dfs与链前，而且链前不开二倍空间会死的很惨

qwq

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 1e5+5;
int n,m,u[maxn<<1],v[maxn<<1],t[maxn];
int fa[maxn],head[maxn],cnt,vis[maxn<<1];
struct node
{
    int to,nxt;
}e[maxn<<1];
inline int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    else 
    {
        return fa[x]=find(fa[x]);
    }
}
bool merge(int x,int y)
{
    int ax=find(x),ay=find(y);
    if(ax!=ay)
    {
        fa[ax]=ay;
        return 1;
    }
    else 
    {
        return 0;
    }
}
inline void add(int u,int v)
{
    e[++cnt].to=v;
    e[cnt].nxt=head[u];
    head[u]=cnt;
}
void kru()
{
    for(int i=1;i<=n;i++)
    {
        fa[i]=i;
    }
    for(int i=1;i<=m;i++)
    {
        if(merge(u[i],v[i]))
        {
            vis[i]=1;
            add(u[i],v[i]);
            add(v[i],u[i]);
        }
    }
}
int f[maxn][30],dep[maxn];
void dfs1(int u,int far)
{
    f[u][0]=far;
    for(int i=1;i<=19;i++)
    {
        f[u][i]=f[f[u][i-1]][i-1];
    }
    dep[u]=dep[far]+1;
    for(int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].to;
        if(v!=far)
        {
            dfs1(v,u);
        }
    }
}
int lca(int x,int y)
{
    for(int i=19;i>=0;i--)
    {
        if(dep[f[y][i]]>=dep[x])
        {
            y=f[y][i];
        }
    }
    if(x==y)
    {
        return x;
    }
    for(int i=19;i>=0;i--)
    {
        if(f[x][i]!=f[y][i])
        {
            x=f[x][i];
            y=f[y][i];
        }
    }
    return f[x][0];
}
void dfs2(int u,int far)//shu4 shang4 cha1 fen1 hou4
{
    t[u]+=t[far];//qian2 zhui4 he2
    for(int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].to;
        if(v!=far)
        {
            dfs2(v,u);
        }
    }
}
int main()
{
    n=read(),m=read();
    for(int i=1;i<=m;i++)
    {
        u[i]=read(),v[i]=read();
    }
    kru();
    dfs1(1,0);
    for(int i=1;i<=m;i++)
    {
        if(!vis[i])
        {
            if(dep[u[i]]>dep[v[i]])
            {
                swap(u[i],v[i]);
            }
            int tmp=lca(u[i],v[i]);
            if(u[i]==tmp)
            {
                t[1]++;
                t[v[i]]++;
                int x=v[i];
                for(int j=19;j>=0;j--)
                {
                    if(dep[f[x][j]]>dep[u[i]])
                    {
                        x=f[x][j];
                    }
                }
                t[x]--;
            }
            else
            {
                t[u[i]]++;
                t[v[i]]++;
            }
        }
    }
    dfs2(1,0);
    for(int i=1;i<=n;i++)
    {
        if(t[i]==m-(n-1))
        {
            cout<<"1";
        }
        else 
        {
            cout<<"0";
        }
    }        
    cout<<endl;
    return 0;
}

t3 运输计划

折磨喜闻乐见的题目索性不赘述了

/*
略
*/

 day20 7.16

上午很显然，模拟赛

但是有人却在寝室休息，怎么会逝呢

至于模拟赛的题目，难以评价

t1按照题中给的比重，暴力期望得分30pts

结果得了70pts，赞美不杀之恩的rfy

t2乍一眼并不会，因为线段树写挂了/kel

后来才知道，这道题暴力模拟可以得到60pts

t3很有趣

定义dp[i][j]表示在第一天已经用了j小时的情况下完成i子树中的所有题目最少还需要多少天多少小时

用O（m！）复杂度遍历所有子树即可

后来才知道，这样做期望50pts

然而我考完试才发觉：

"我t2不是没做吗，我怎么交了一份代码？！"

“我t3交哪去了？！”

RE，50pts->0pts

t4没做，但是听说dj算法可以骗分20pts

订正去了

晚上讲基础容斥和二项式反演，这是好的

day21 7.17

上午模拟赛，寄了

值得一提的是，t3那道题我想出来了正解，使用dp+滚动数组，为了防止被卡常用了vector存图

但是还是寄了

我单独开了个结构体负责存对于图的询问（共q个询问）

然后我再对这个结构体进行sort的时候写成了

sort(qu+1,qu+1+n);

好巧不巧的，样例过了，交上去，100pts->0pts

焯！

t2好熟悉的样子，原来是酒店开关灯问题，梦开始的地方！！！！

但是数据范围1e18的你见过吗？！

热知识这道题暴力模拟没有分

下午和可爱的__int128斗智斗勇，事实证明__int128不能在Windows下编译

我****************************************************

day22 7.18

二分图，但是有霍尔定理没有匈牙利算法，怎么回事呢

“匈牙利算法是NOI级别的算法，所以不讲了。”——CDX

晚上的时候再附上几道题吧

今天FDsama又一次撑不住了，望早日康复

 由于博客内容有限，所以选择几道有代表性的题目。

t1，原题是hdu的acm考试题，翻译一下就是对于一个给定的图，删去最少的边使其变成二分图

其实枚举即可，枚举左右分布情况并且删除想同一侧的边就可以了

#include<bits/stdc++.h>
using namespace std;
#define map Deaphets
int t,n,m,map[20][20],fa[20],a[20],b[20],ans;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
int main()
{
    t=read();
    while(t--)
    {
        memset(map,0,sizeof(map));
        n=read(),m=read();
        for(int i=1;i<=m;i++)
        {
            int  u=read(),v=read();
            map[u][v]++;
            map[v][u]++;
        }
        ans=0x3f3f3f3f;
        for(int i=1;i<=(1<<n);i++)
        {
            int maxx=0;
            int cnta=0,cntb=0;
            memset(a,0,sizeof(a));
            memset(b,0,sizeof(b));
            for(int j=1;j<=n;j++)
            {
                if(i&(1<<(j-1)))
                {
                    a[++cnta]=j;
                }
                else
                {
                    b[++cntb]=j;
                }
            }
            for(int j=1;j<=cnta;j++)
            {
                for(int k=j+1;k<=cnta;k++)
                {
                    if(map[a[j]][a[k]])
                    {
                        maxx+=map[a[j]][a[k]];
                    }
                }
            }
            for(int j=1;j<=cntb;j++)
            {
                for(int k=j+1;k<=cntb;k++)
                {
                    if(map[b[j]][b[k]])
                    {
                        maxx+=map[b[j]][b[k]];
                    }
                }
            }
            ans=min(ans,maxx);
        }
        cout<<ans<<endl;
    }
    return 0;
}

t2，p1285，队员分组

事实证明，当你做题卡住的时候不建议和屎山代码死磕，在确保算法正确的前提下建议直接重构

#include<bits/stdc++.h>
using namespace std;
const int maxn = 105;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
vector<int> e[maxn],vec[maxn][2],ans[2];
inline void add(int u,int v)
{
    e[u].push_back(v);
}
int n,tmp[maxn][maxn],dp[maxn][maxn],opt[maxn][maxn];
int vis[maxn],col[maxn],cnt;
inline bool bfs(int x)
{
    queue<int> q;
    q.push(x);
    vis[x]=1;
    cnt++;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vec[cnt][col[u]].push_back(u);
        for(auto v:e[u])
        {
            if(!vis[v])
            {
                col[v]=col[u]^1;
                vis[v]=1;
                q.push(v);
            }
            else
            {
                if(col[v]==col[u])
                {
                    return false;
                }
            }
        }
    }
    return true;
}
inline void work()
{
    n=read();
    for(int u=1;u<=n;u++)
    {
        int v;
        while((v=read()))
        {
            tmp[u][v]=1;
        }
    }
    for(int u=1;u<=n;u++)
    {
        for(int v=u+1;v<=n;v++)
        {
            if(!(tmp[u][v] and tmp[v][u]))
            {
                add(u,v);
                add(v,u);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(!vis[i] and !bfs(i))
        {
            cout<<"No solution"<<endl;
            return;
        }
    }
    dp[0][0]=1;
    for(int i=1;i<=cnt;i++)
    {
        for(int j=0;j<=n;j++)
        {
            if(j>=vec[i][0].size() and dp[i-1][j-vec[i][0].size()])
            {
                dp[i][j]=1;
                opt[i][j]=0;
            }
            if(j>=vec[i][1].size() and dp[i-1][j-vec[i][1].size()])
            {
                dp[i][j]=1;
                opt[i][j]=1;
            }
        }
    }
    int now;
    for(int i=(n>>1);i>=0;i--)
    {
        if(dp[cnt][i])
        {
            now=i;
            break;
        }
    }
    for(int i=cnt;i>=1;i--)
    {
        for(auto x:vec[i][opt[i][now]])
        {
            ans[0].push_back(x);
        }
        for(auto x:vec[i][opt[i][now]^1])
        {
            ans[1].push_back(x);
        }
        now-=vec[i][opt[i][now]].size();
    }
    sort(ans[0].begin(),ans[0].end());
    sort(ans[1].begin(),ans[1].end());
    cout<<(int)ans[0].size()<<" ";
    for(auto x:ans[0])
    {
        cout<<x<<" ";
    }
    cout<<endl;
    cout<<(int)ans[1].size()<<" ";
    for(auto x:ans[1])
    {
        cout<<x<<" ";
    }
    cout<<endl;
}
int main()
{
    work();
    return 0;
}

可以先求出补图，对于补图中的每个连通块可以知道两边点数 a_i,b_i，其实在这个时候就相当于在维护对于每个连通块可以向左侧加上a_i或者b_i，最终让两侧的差值最小

这个时候尘封已久的背包dp就派上用场了

乐

t3，p10572

好新的一道月赛题

其实二分图我们可以把它视作为两个集合，这样一来就可以使用并查集维护二分图。

但是一定注意，由于图可能不是连通的，对于每一个连通块必须判断一次奇环

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 5e5+5;
int v[maxn],fa[maxn<<1],fa1[maxn<<1],fa2[maxn<<1],fa3[maxn<<1];
int tag1[maxn],tag2[maxn],jh[maxn],ans[maxn];
string s;
struct node
{
    int fi,se;
}e[maxn<<1];
inline int find(int *fa,int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa,fa[x]);
}
int main()
{
    int n=read(),m=read(),q=read();
    cin>>s;
    for(int i=1;i<=n;i++)
    {
        if(s[i-1]=='(')
        {
            v[i]=1;
        }
        else
        {
            v[i]=-1;
        }
    }
    for(int i=1;i<=n;i++)
    {
        fa1[i]=fa2[i]=fa3[i]=i;
    }
    for(int i=1;i<=(n<<1);i++)
    {
        fa[i]=i;
    }
    for(int i=1;i<=m;i++)
    {
        e[i].fi=read(),e[i].se=read();
        int x=e[i].fi,y=e[i].se;
        if(find(fa,x)!=find(fa,y+n))
        {
            fa[find(fa,x)]=find(fa,y+n);
        }
        if(find(fa,y)!=find(fa,x+n))
        {
            fa[find(fa,y)]=find(fa,x+n);
        }
        if(!(v[x]==-1 and v[y]==-1))
        {
            if(find(fa1,x)!=find(fa1,y))
            {
                fa1[find(fa1,x)]=find(fa1,y);
            }
        }
        if(!(v[x]==1 and v[y]==1))
        {
            if(find(fa2,x)!=find(fa2,y))
            {
                fa2[find(fa2,x)]=find(fa2,y);
            }
        }
        if(!(v[x]==-1 and v[y]==-1) and !(v[x]==1 and v[y]==1))
        {
            if(find(fa3,x)!=find(fa3,y))
            {
                fa3[find(fa3,x)]=find(fa3,y);
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        int x=e[i].fi,y=e[i].se;
        if(find(fa,x)==find(fa,x+n))
        {
            jh[find(fa,x)]=1;
        }
        if(find(fa,y)==find(fa,y+n))
        {
            jh[find(fa,y)]=1;
        }
    }
    for(int i=1;i<=m;i++)
    {
        int x=e[i].fi,y=e[i].se;
        if(v[x]==1 and v[y]==1)
        {
            tag1[find(fa1,x)]=1;
        }
        if(v[x]==-1 and v[y]==-1)
        {
            tag2[find(fa2,x)]=1;
        }
    }
    for(int i=1;i<=q;i++)
    {
        int x=read(),y=read();
        if(find(fa,x)!=find(fa,y) and find(fa,x)!=find(fa,y+n))
        {
            continue;
        }
        if(v[x]!=1 or v[y]!=-1)
        {
            continue;
        }
        if((!jh[find(fa,x)]) and (find(fa,x)==find(fa,y)))
        {
            continue;
        }
        if(find(fa3,x)==find(fa3,y))
        {
            ans[i]=1;
        }
        else if(tag1[find(fa1,x)] and tag2[find(fa2,y)])
        {
            ans[i]=1;
        }
    }
    for(int i=1;i<=q;i++)
    {
        cout<<ans[i];
    }
    cout<<endl;
    return 0;
}

先扔几个典题在这里吧

/************************************************可爱的分割线***************************/

喜报：tjy以775pts的成绩被大连市第二十四中录取，祝贺你成为了一位“骄傲而无所畏惧”的二十四中人。

 

/*********************************************************************************************************/

t4，做了一个逆天改命的行为，我想尝试写一份人生中第二份网络流（尽管可以写二分图）

好的，写了半个多小时做出来了

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
inline int lowbit(int x)
{
    return (-x)&x;
}
const int maxn = 25;
const int maxm = 4e6+5;
int n,k,a[maxn],s[maxm],f[1<<18];
int cnt[1<<18];
bool check(int m)
{
    memset(f,0,sizeof(f));
    for(int i=1;i<=m;i++)
    {
        f[s[i]]++;
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<(1<<n);j++)
        {
            if(!((j>>i)&1))
            {
                f[j]+=f[j|(1<<i)];
            }
        }
    }
    for(int i=1;i<(1<<n);i++)
    {
        if(m-f[i]+(n-cnt[i])*k<n*k)
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
    for(int i=1;i<(1<<18);i++)
    {
        cnt[i]=cnt[i-lowbit(i)]+1;
    }
    n=read(),k=read();
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
        for(int j=0;j<=2*n*k;j+=2*a[i])
        {
            for(int k=1;k<=a[i];k++)
            {
                s[j+k]|=(1<<(i-1));
            }
        }
    }
    for(int i=0;i<=2*n*k;i++)
    {
        s[i]^=(1<<n)-1;
    }
    int l=n*k,r=2*n*k;
    int ans=r+1;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;
            r=mid-1;
        }
        else
        {
            l=mid+1;
        }
    }
    cout<<ans<<endl;
    return 0;
}

其实不难发现N最大只有18，所以先建立网络流模型，然后第二层表示人，第三层表示天数，最大匹配等于最小割，割去除了第二层之外的所有都可以。对于第一层直接状压，因为不大可能大于等于18，然后考虑第三层有哪些需要割掉的。哦，原来是剩下点里可以通向第三层点的交集。

然后高维前缀和预处理，再写一个二分判断一下是否存在无法完全匹配的方案。

结束了。

day23 7.19

上午模拟赛，可惜这次暴力没有出奇迹，个人承认二分图并不难，但是今天比赛题目有很多“充分发扬人类智慧”的做法

t1，meet

有n个网红要见面，给出了每个人的n-1个期望见面顺序

当你在写二分图正解的时候，有人已经puts(“-1”);拿到20pts了，怎么回事呢

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 1e3+5;
const int maxm = 1e6+5;
int n,id[maxn][maxn],lst[maxn],m,deg[maxm];
int ans,day[maxm],vis;
vector<int> e[maxm];
queue<int> q;
int main()
{
    freopen("meet.in","r",stdin);
    freopen("meet.out","w",stdout);
    n=read();
    for(int i=1;i<=n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            id[i][j]=id[j][i]=++m;
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<n;j++)
        {
            int tmp=read();
            int now=id[i][tmp];
            if(lst[i])
            {
                e[lst[i]].push_back(now);
                deg[now]++;
            }
            lst[i]=now;
        }
    }
    for(int i=1;i<=m;i++)
    {
        if(!deg[i])
        {
            q.push(i);
            day[i]=1;
        }
    }
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        ans=max(ans,day[u]);
        vis++;
        for(auto v:e[u])
        {
            deg[v]--;
            day[v]=max(day[v],day[u]+1);
            if(deg[v]==0)
            {
                q.push(v);
            }
        }
    }
    if(vis==m)
    {
        cout<<ans<<endl;
    }
    else
    {
        puts("-1");
    }
    return 0;
}

t2，由于题目过于答辩，于是考试的时候并没有做

后来发现，打表好像挺好使的

确实是这样，唯一缺点是码量爆炸，极其难调试（不建议展开下面的代码，否则可能导致浏览器卡死）

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
bool dp[105][105];
int x[30005][6];
int main()
{
    freopen("bulb.in","r",stdin);
    freopen("bulb.out","w",stdout);
    int t=read();
    while(t--)
    {
        int n=read(),m=read(),ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                char c;
                cin>>c;
                dp[i][j]=c-'0';
            }
        }
        for(int i=1;i<n-1;i++)
        {
            for(int j=1;j<m;j++)
            {
                if(dp[i][j]==1)
                {
                    if(dp[i][j+1]==1)
                    {
                        ans++;
                        x[ans][0]=i;
                        x[ans][1]=j;
                        x[ans][2]=i;
                        x[ans][3]=j+1;
                        x[ans][4]=i+1;
                        x[ans][5]=j;
                        dp[i][j]^=1;
                        dp[i][j+1]^=1;
                        dp[i+1][j]^=1;
                    }
                    else
                    {
                        ans++;
                        x[ans][0]=i;
                        x[ans][1]=j;
                        x[ans][2]=i+1;
                        x[ans][3]=j+1;
                        x[ans][4]=i+1;
                        x[ans][5]=j;
                        dp[i][j]^=1;
                        dp[i+1][j+1]^=1;
                        dp[i+1][j]^=1;                        
                    }
                }
                else
                {
                    if(dp[i][j+1]==1)
                    {
                        ans++;
                        x[ans][0]=i;
                        x[ans][1]=j+1;
                        x[ans][2]=i+1;
                        x[ans][3]=j+1;
                        x[ans][4]=i+1;
                        x[ans][5]=j;
                        dp[i][j+1]^=1;
                        dp[i+1][j+1]^=1;
                        dp[i+1][j]^=1;                        
                    }
                }
            }
        }
        for(int j=1;j<m-1;j++)
        {
            if(dp[n-1][j]==1)
            {
                if(dp[n][j]==1)
                {
                    ans++;
                    x[ans][0]=n-1;
                    x[ans][1]=j;
                    x[ans][2]=n;
                    x[ans][3]=j;
                    x[ans][4]=n-1;
                    x[ans][5]=j+1;
                    dp[n-1][j]^=1;
                    dp[n][j]^=1;
                    dp[n-1][j+1]^=1;                                    
                }
                else
                {
                    ans++;
                    x[ans][0]=n-1;
                    x[ans][1]=j;
                    x[ans][2]=n-1;
                    x[ans][3]=j+1;
                    x[ans][4]=n;
                    x[ans][5]=j+1;
                    dp[n-1][j]^=1;
                    dp[n-1][j+1]^=1;
                    dp[n][j+1]^=1;                                
                }
            }
            else
            {
                if(dp[n][j]==1)
                {
                    ans++;
                    x[ans][0]=n;
                    x[ans][1]=j;
                    x[ans][2]=n;
                    x[ans][3]=j+1;
                    x[ans][4]=n-1;
                    x[ans][5]=j+1;
                    dp[n][j]^=1;
                    dp[n][j+1]^=1;
                    dp[n-1][j+1]^=1;                            
                }
            }
        }
        while(1)
        {
            int cnt=0;
            if(dp[n-1][m-1]==1)
            {
                cnt++;
            }
            if(dp[n][m-1]==1)
            {
                cnt++;
            }
            if(dp[n-1][m]==1)
            {
                cnt++;
            }
            if(dp[n][m]==1)
            {
                cnt++;
            }
            if(cnt==0)
            {
                break;
            }
            if(cnt==4)
            {
                ans++;
                x[ans][0]=n-1;
                x[ans][1]=m-1;
                x[ans][2]=n;
                x[ans][3]=m-1;
                x[ans][4]=n-1;
                x[ans][5]=m;
                dp[n-1][m-1]^=1;
                dp[n][m-1]^=1;
                dp[n-1][m]^=1;
            }
            else if(cnt==3)
            {
                ans++;
                int tmp=0;
                if(dp[n-1][m-1]==1)
                {
                    x[ans][tmp]=n-1;
                    x[ans][tmp+1]=m-1;
                    dp[n-1][m-1]^=1;
                    tmp+=2;
                }
                if(dp[n][m-1]==1)
                {
                    x[ans][tmp]=n;
                    x[ans][tmp+1]=m-1;
                    dp[n][m-1]^=1;
                    tmp+=2;
                }
                if(dp[n-1][m]==1)
                {
                    x[ans][tmp]=n-1;
                    x[ans][tmp+1]=m;
                    dp[n-1][m]^=1;
                    tmp+=2;
                }
                if(dp[n][m]==1)
                {
                    x[ans][tmp]=n;
                    x[ans][tmp+1]=m;
                    dp[n][m]^=1;
                    tmp+=2;
                }
            }
            else if(cnt<=2)
            {
                ans++;
                int hh=0,hb=0,hw=0;
                if(dp[n-1][m-1]==1 and hw<1)
                {
                    x[ans][hh]=n-1;
                    x[ans][hh+1]=m-1;
                    hh+=2;
                    hw++;
                    dp[n-1][m-1]^=1;
                }
                else if(dp[n-1][m-1]==0 and hb<2)
                {
                    x[ans][hh]=n-1;
                    x[ans][hh+1]=m-1;
                    hh+=2;
                    hb++;
                    dp[n-1][m-1]^=1;
                }
                if(dp[n-1][m]==1 and hw<1)
                {
                    x[ans][hh]=n-1;
                    x[ans][hh+1]=m;
                    hh+=2;
                    hw++;
                    dp[n-1][m]^=1;
                }
                else if(dp[n-1][m]==0 and hb<2)
                {
                    x[ans][hh]=n-1;
                    x[ans][hh+1]=m;
                    hh+=2;
                    hb++;
                    dp[n-1][m]^=1;
                }
                if(dp[n][m-1]==1 and hw<1)
                {
                    x[ans][hh]=n;
                    x[ans][hh+1]=m-1;
                    hh+=2;
                    hw++;
                    dp[n][m-1]^=1;
                }
                else if(dp[n][m-1]==0 and hb<2)
                {
                    x[ans][hh]=n;
                    x[ans][hh+1]=m-1;
                    hh+=2;
                    hb++;
                    dp[n][m-1]^=1;
                }
                if(dp[n][m]==1 and hw<1)
                {
                    x[ans][hh]=n;
                    x[ans][hh+1]=m;
                    hh+=2;
                    hw++;
                    dp[n][m]^=1;
                }
                else if(dp[n][m]==0 and hb<2)
                {
                    x[ans][hh]=n;
                    x[ans][hh+1]=m;
                    hh+=2;
                    hb++;
                    dp[n][m]^=1;
                }
            }
        }
        cout<<ans<<endl;
        for(int i=1;i<=ans;i++)
        {
            for(int j=0;j<=5;j++)
            {
                cout<<x[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    return 0;
}

t3，当你开始效仿昨天树上括号匹配那道题的做法开始写二分图或者像我一样写唐氏暴力dp的时候你已经输了

（尽管正解是dp，但是此处想说一种抽象的做法）

据某位热心群众发现，这道题cout<<k<<endl;可以拿到30pts

而且这道题常数很小

所以......

为了这道题，我甚至去Wikipedia上学习了一下Mersenne Twister

c语言代码如下：

#include <stdint.h>

#define n 624
#define m 397
#define w 32
#define r 31
#define UMASK (0xffffffffUL << r)
#define LMASK (0xffffffffUL >> (w-r))
#define a 0x9908b0dfUL
#define u 11
#define s 7
#define t 15
#define l 18
#define b 0x9d2c5680UL
#define c 0xefc60000UL
#define f 1812433253UL

typedef struct
{
    uint32_t state_array[n];         // the array for the state vector 
    int state_index;                 // index into state vector array, 0 <= state_index <= n-1   always
} mt_state;


void initialize_state(mt_state* state, uint32_t seed) 
{
    uint32_t* state_array = &(state->state_array[0]);
    
    state_array[0] = seed;                          // suggested initial seed = 19650218UL
    
    for (int i=1; i<n; i++)
    {
        seed = f * (seed ^ (seed >> (w-2))) + i;    // Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
        state_array[i] = seed; 
    }
    
    state->state_index = 0;
}


uint32_t random_uint32(mt_state* state)
{
    uint32_t* state_array = &(state->state_array[0]);
    
    int k = state->state_index;      // point to current state location
                                     // 0 <= state_index <= n-1   always
    
//  int k = k - n;                   // point to state n iterations before
//  if (k < 0) k += n;               // modulo n circular indexing
                                     // the previous 2 lines actually do nothing
                                     //  for illustration only
    
    int j = k - (n-1);               // point to state n-1 iterations before
    if (j < 0) j += n;               // modulo n circular indexing

    uint32_t x = (state_array[k] & UMASK) | (state_array[j] & LMASK);
    
    uint32_t xA = x >> 1;
    if (x & 0x00000001UL) xA ^= a;
    
    j = k - (n-m);                   // point to state n-m iterations before
    if (j < 0) j += n;               // modulo n circular indexing
    
    x = state_array[j] ^ xA;         // compute next value in the state
    state_array[k++] = x;            // update new state value
    
    if (k >= n) k = 0;               // modulo n circular indexing
    state->state_index = k;
    
    uint32_t y = x ^ (x >> u);       // tempering 
             y = y ^ ((y << s) & b);
             y = y ^ ((y << t) & c);
    uint32_t z = y ^ (y >> l);
    
    return z; 
}

来源：Wikipedia

所以可以发扬人类智慧，直接写随机化

 

#include<bits/stdc++.h>
using namespace std;
mt19937 mt_rand(random_device{}());
int rnd(int l,int r)
{
    return mt_rand()%(r-l+1)+l;
}
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 1e5+5;
int n,k,ans=1e9,a[maxn],p[maxn];
int dp[maxn][1<<5];
vector<int> e[maxn];
void dfs(int u,int fa)
{
    dp[u][1<<p[a[u]]]=1;
    for(auto v:e[u])
    {
        if(v==fa)
        {
            continue;
        }
        dfs(v,u);
        for(int i=(1<<k)-1;i>=0;i--)
        {
            for(int j=0;j<(1<<k);j++)
            {
                dp[u][i|j]=min(dp[u][i|j],dp[v][j]+dp[u][i]);
            }
        }
    }
    ans=min(ans,dp[u][(1<<k)-1]);
}
int main()
{
    //freopen("insect.in","r",stdin);
    //freopen("insect.out","w",stdout);
    n=read(),k=read();
    set<int> q;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",a+i);
        q.insert(a[i]);
    }
    for(int i=1;i<n;i++)
    {
        int u=read(),v=read();
        e[u].push_back(v);
        e[v].push_back(u);
    }
    if(q.size()<=k)
    {
        memset(dp,0x3f3f3f,sizeof(dp));
        int j=0;
        for(auto i:q)
        {
            p[i]=j++;
        }
        dfs(1,0);
        cout<<ans<<endl;
        return 0;
    }
    for(int i=1;i<=50;i++)
    {
        memset(dp,0x3f,sizeof(dp));
        for(int j=1;j<=n;j++)
        {
            p[j]=rnd(0,k-1);
        }
        dfs(1,0);
    }
    cout<<ans<<endl;
    return 0;
}

 

其实上述代码可以为对拍写某个区间内的随机数提供思路

晚上讲整体二分，但是为什么rfy的代码有种oiwiki的美感？

番外：这几天寝室晚上的话题有点炸裂了

 day24 7.20

上午周赛，下午就有手机了，赢！

下午陆续收到了两位学长的退役感言

其实还是很悲伤的

后人奋发吧

day25 7.21

休息一下吧！

day26 7.22

上午进行了“选水题讲“，对于一道博弈论题目我交了人生中第二篇题解，希望赶紧过审。

感谢在题目中出fft的cdx

不说了，补题去了

谴责某个背刺所有竞赛生去三寰牧场研学的学校