[校内训练20_01_17]ABC

1.平面上每次加入直角边平行于坐标轴的等腰直角三角形，每次询问某个点被覆盖了多少次。

大常数算法：O(nlog^2)

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=3E5+;
 int n,q;
 inline int read()
 {
     char ch=getchar();
     while(!isdigit(ch))ch=getchar();
     int x=ch-'';
     ch=getchar();
     while(isdigit(ch)){x=x*+ch-'';ch=getchar();}
     return x;
 }
 int G[];
 inline void write(int x)
 {
     int g=;
     do{G[++g]=x%;x/=;}while(x);
     for(int i=g;i>=;--i)putchar(G[i]+'');putchar('\n');
 }
 //////////////////////////////////////////////////////////////////////////////////////// splay
 int t[],fa[],val[],sum[],son[][],cnt[],TOT;
 struct Splay
 {
     int root;
     inline void update(int x)
     {
         sum[x]=sum[son[x][]]+sum[son[x][]]+cnt[x];
     }
     inline void rotate(int x)
     {
         int y=fa[x];
         int c=son[y][]==x;
         fa[x]=fa[y];
         son[y][!c]=son[x][c];
         if(son[x][c])
             fa[son[x][c]]=y;
         if(son[fa[y]][]==y)
             son[fa[y]][]=x;
         else
             son[fa[y]][]=x;
         son[x][c]=y;
         fa[y]=x;
         update(y);
         update(x);
         if(y==root)
             root=x;
     }
     inline void splay(int x)
     {
         if(x==root)
             return;
         while(true)
         {
             int y=fa[x];
             if(y==)
                 break;
             if(y==root)
             {
                 rotate(x);
                 break;
             }
             if((son[fa[y]][]==y)==(son[y][]==x))
                 rotate(y),rotate(x);
             else
                 rotate(x),rotate(x);
         }
     }
     inline void insert(int x)
     {
         if(root==)
         {
             root=++TOT;
             sum[root]=cnt[root]=;
             val[root]=x;
             return;
         }
         int pos=root;
         while(true)
         {
             ++sum[pos];
             if(val[pos]==x)
             {
                 ++cnt[pos];
                 break;
             }
             if(x<val[pos])
             {
                 if(son[pos][]==)
                 {
                     son[pos][]=++TOT;
                     sum[TOT]=cnt[TOT]=;
                     val[TOT]=x;
                     fa[TOT]=pos;
                     break;
                 }
                 pos=son[pos][];
             }
             else
             {
                 if(son[pos][]==)
                 {
                     son[pos][]=++TOT;
                     sum[TOT]=cnt[TOT]=;
                     val[TOT]=x;
                     fa[TOT]=pos;
                     break;
                 }
                 pos=son[pos][];
             }
         }
 //        splay(pos);
     }
     inline int askSmaller(int x)// how many numbers are <= x
     {
         int ans=;
         int pos=root;
         while(pos)
         {
             if(x<val[pos])
                 pos=son[pos][];
             else
             {
                 ans+=sum[son[pos][]]+cnt[pos];
                 pos=son[pos][];
             }
         }
         return ans;
     }
     inline int askBigger(int x)// how many numbers are >= x
     {
         int ans=;
         int pos=root;
         while(pos)
         {
             if(x>val[pos])
                 pos=son[pos][];
             else
             {
                 ans+=sum[son[pos][]]+cnt[pos];
                 pos=son[pos][];
             }
         }
         return ans;
     }
     void out()
     {
         cout<<root<<endl;
         cout<<"FA   :";for(int i=;i<=TOT;++i)cout<<fa[i]<<" ";cout<<endl;
         cout<<"SUM  :";for(int i=;i<=TOT;++i)cout<<sum[i]<<" ";cout<<endl;
         cout<<"VAl  :";for(int i=;i<=TOT;++i)cout<<val[i]<<" ";cout<<endl;
         cout<<"SON  :";for(int i=;i<=TOT;++i)cout<<son[i][]<<" ";cout<<endl;
         cout<<"     :";for(int i=;i<=TOT;++i)cout<<son[i][]<<" ";cout<<endl;
     }
 };
 ////////////////////////////////////////////////////////////////////////////////////////
 struct Segment
 {
     Splay T[maxn*];
     inline void add(int L,int R,int l,int r,int x,int num)
     {
         if(L<=l&&r<=R)
         {
             T[num].insert(x);
             return;
         }
         int mid=(l+r)>>;
         if(R<=mid)
             add(L,R,l,mid,x,num<<);
         else if(mid<L)
             add(L,R,mid+,r,x,num<<|);
         else
             add(L,R,l,mid,x,num<<),add(L,R,mid+,r,x,num<<|);
     }
     inline int askSmaller(int l,int r,int pos,int x,int num)// <=
     {
         if(l==r)
             return T[num].askSmaller(x);
         int mid=(l+r)>>;
         if(pos<=mid)
             return askSmaller(l,mid,pos,x,num<<)+T[num].askSmaller(x);
         else
             return askSmaller(mid+,r,pos,x,num<<|)+T[num].askSmaller(x);
     }
     inline int askBigger(int l,int r,int pos,int x,int num)// >=
     {
         if(l==r)
             return T[num].askBigger(x);
         int mid=(l+r)>>;
         if(pos<=mid)
             return askBigger(l,mid,pos,x,num<<)+T[num].askBigger(x);
         else
             return askBigger(mid+,r,pos,x,num<<|)+T[num].askBigger(x);
     }
 }T[];
 int main()
 {
     freopen("frontier.in","r",stdin);
     freopen("frontier.out","w",stdout);
     ios::sync_with_stdio(false);
     int useless=read();
     n=read(),q=read();
     while(q--)
     {
         int opt=read();
         if(opt==)
         {
             opt=read();
             int x=read(),y=read(),z=read();
             if(opt==)
             {
                 T[].add(y,y+z,,n,x+y+z,);
                 T[].add(y,y+z,,n,x-,);
             }
             else if(opt==)
             {
                 T[].add(y-z,y,,n,x-(y-z),);
                 T[].add(y-z,y,,n,x-,);
             }
             else if(opt==)
             {
                 T[].add(y,y+z,,n,x-(y+z),);
                 T[].add(y,y+z,,n,x+,);
             }
             else
             {
                 T[].add(y-z,y,,n,x+y-z,);
                 T[].add(y-z,y,,n,x+,);
             }
         }
         else
         {
             int x=read(),y=read();
             int ans1=T[].askBigger(,n,y,x+y,)-T[].askBigger(,n,y,x,);
             int ans2=T[].askBigger(,n,y,x-y,);
             int ans3=T[].askSmaller(,n,y,x-y,)-T[].askSmaller(,n,y,x,);
             int ans4=T[].askSmaller(,n,y,x+y,);
             write(ans1+ans2+ans3+ans4);
         }
     }
     return ;
 }

离线做法：还没写

---

2.

    小L 的治疗总共分为N 个阶段，在第i 个阶段，小L 可以做出如下选择：
    1.施放治愈法术，为永恒之树恢复xi + S 点生命力
    2.为法杖注入能量，令法术强度S 增加yi
    3.吟唱圣歌，召唤zi只木精灵
    在每个阶段结束时，每只木精灵会使得法术强度S增加1
    请帮助小L 计算在N个阶段结束后，能够为永恒之树恢复的最大生命力。
    n <= 80

简单题。n^4

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long int ll;
 const ll inf=1E15;
 ll f[][][*];
 ll n,a[],b[],c[];
 inline ll max(ll x,ll y)
 {
     return x>y?x:y;
 }
 inline void U(ll&x,ll y)
 {
     x=max(x,y);
 }
 inline void solve()
 {
     cin>>n;
     for(
     int i=;i<=n;++i)
         cin>>a[i]>>b[i]>>c[i];
     for(int i=;i<=n;++i)
         for(int j=;j<=n;++j)
             for(int k=;k<=n*n;++k)
                 f[i][j][k]=-inf;
     f[n][][]=;
     f[n][][]=a[n];
     for(int i=n;i>=;--i)
     {
         for(int j=;j<=n;++j)
         {
             for(int k=;k<=n*n;++k)
             {
                 U(f[i-][j+][j+k],f[i][j][k]+a[i-]);
                 U(f[i-][j][j+k],f[i][j][k]+b[i-]*j);
                 U(f[i-][j][j+k],f[i][j][k]+c[i-]*(j+k));
             }
         }
     }
     ll ans=;
     for(int i=;i<=n;++i)
         for(int j=;j<=n*n;++j)
             ans=max(ans,f[][i][j]);
     cout<<ans<<endl;
 }
 int main()
 {
     freopen("fortune.in","r",stdin);
     freopen("fortune.out","w",stdout);
     ios::sync_with_stdio(false);
     int useless,T;
     cin>>useless>>T;
     while(T--)
         solve();
     return ;
 }

---

3.

    在小L 的努力下，永恒之树已经恢复了生命力。
    渐渐恢复元气的X 国将进行一次占卜仪式，在仪式中，小L 将取下一段永恒之树的树枝。这里，我们将一段树枝抽象成
一张N个点，M 条边的无向图，恢复了生命力的永恒之树已经脱离了普通的树的范畴，但仍然具备一些树的特性，譬如每条边
都只在至多一个简单环中出现。
    小L 将对取下的树枝使用分解魔法，此后，树枝的每一个节点都会在一个时辰内随机的一个时刻，连同其连出去的边一
起被分解。在被分解的瞬间，每个节点会释放出等同于当时还与其连通的节点数量的能量，将这些能量求和，便得到了X 国的
气运。
    现在，小L 想要知道，X 国的气运期望会是多少。
    请求出X 国气运的期望对998244353 取模的结果。

　　

　　

即求一个仙人掌随机点分治的期望复杂度。

若仙人掌是一棵树，考虑一对点之间的贡献。即x对y产生贡献，即x在被选中前始终与y联通的概率，为$\frac{1}{dist(x,y)}$，dist为两点之间的点的个数。