ZJOI2012题解

t1灾难 给一个食物网 如果一个生物吃的所有东西都灭绝了 它也跟着灭绝 求每个生物灭绝时跟着灭绝的生物数量

支配树裸题，我们先拓扑排序，然后建立一棵树满足一个点灭绝时，有且仅有它的子树跟着灭绝

考虑如何建立这棵支配树

我们可以考虑先建立一个假想的根节点$root$，让所有“生产者”都吃$root$

这样所有点的地位就同意了（都捕食某种东西）

按照拓扑序加点

考虑对于一个点$node$

假设他的食物$fd[1],fd[2],fd[3], \cdots , fd[SIZE]$已经按拓扑序排好且排在$node$前

当且仅当这一串食物的$LCA$灭绝会导致$node$灭绝，否则$node$一定能找到食物

于是可以把$node$连到那个$LCA$下面

然后计算一下每个点子树大小-1就可以了

#include<map>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
#define inf 1000000000
using namespace std;
int read()
{
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
int bin[];
int n,cnt;
struct edge{
    int to,next;
}e[];
vector<int> st,q;
struct G{
    int last[],deep[],in[],size[];
    int fa[][];
    void insert(int u,int v)
    {
        e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
        in[v]++;
    }
    void dfs(int x)
    {
        for(int i=last[x];i;i=e[i].next)
            if(e[i].to!=fa[x][])
            {
                fa[e[i].to][]=x;
                dfs(e[i].to);
                size[x]+=size[e[i].to]+;
            }
    }
    int lca(int x,int y)
    {
        if(x==-)return y;
        if(deep[x]<deep[y])swap(x,y);
        int t=deep[x]-deep[y];
        for(int i=;bin[i]<=t;i++)
            if(t&bin[i])x=fa[x][i];
        for(int i=;i>=;i--)
            if(fa[x][i]!=fa[y][i])
                x=fa[x][i],y=fa[y][i];
        if(x==y)return x;
        return fa[x][];
    }
    void tp()
    {
        for(int i=;i<=n;i++)
            if(!in[i])st.push_back(i);
        while(!st.empty())
        {
            int now=st.back();
            st.pop_back();
            q.push_back(now);
            for(int i=last[now];i;i=e[i].next)
            {
                in[e[i].to]--;
                if(!in[e[i].to])
                    st.push_back(e[i].to);
            }
        }
    }
    void pre(int x)
    {
        for(int i=;bin[i]<=deep[x];i++)
            fa[x][i]=fa[fa[x][i-]][i-];
    }
}G1,G2;
void build_tree()
{
    for(int i=q.size()-;i>=;i--)
    {
        int now=q[i],Fa=-;
        for(int j=G1.last[now];j;j=e[j].next)
            Fa=G2.lca(Fa,e[j].to);
        if(Fa==-)Fa=;
        G2.insert(Fa,now);
        G2.deep[now]=G2.deep[Fa]+;
        G2.fa[now][]=Fa;
        G2.pre(now);
    }
}
int main()
{
    bin[]=;
    for(int i=;i<;i++)bin[i]=bin[i-]<<;
    n=read();
    for(int i=;i<=n;i++)
    {
        int x=read();
        while(x)
        {
            G1.insert(i,x);
            x=read();
        }
    }
    G1.tp();
    build_tree();
    G2.dfs();
    for(int i=;i<=n;i++)
        printf("%d\n",G2.size[i]);
    return ;
}

t2网络

这题一眼上去就是LCT

大力LCT硬搞

因为颜色只有10种，建10个LCT

修改颜色的时候，cut然后link就行了...

改权值就是10个LCT一起改

为什么会有这种侮辱智商的题

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10010
using namespace std;
int x,y,c[][N][],fa[][N],rev[][N],n,k,kind,T,cz,v[N],p[][N],mx[][N];
int st[N],q[N],m;
struct use{int st,en,c;}e[N**];
inline int read(){
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
bool cmp(use a,use b){return a.st<b.st||(a.st==b.st&&a.en<b.en);}
bool isroot(int k,int x){return c[k][fa[k][x]][]!=x&&c[k][fa[k][x]][]!=x;}
void updata(int k,int x){
  int l=c[k][x][],r=c[k][x][];mx[k][x]=x;
  if (v[mx[k][x]]<v[mx[k][l]]) mx[k][x]=mx[k][l];
  if (v[mx[k][x]]<v[mx[k][r]]) mx[k][x]=mx[k][r];
}
void pushdown(int k,int x){
  int l=c[k][x][],r=c[k][x][];
  if (rev[k][x]){rev[k][l]^=;rev[k][r]^=;rev[k][x]^=;swap(c[k][x][],c[k][x][]);}
}
void rotata(int k,int x){
  int l,r,y=fa[k][x],z=fa[k][y];
  if (c[k][y][]==x) l=;else l=;r=l^;
  if (!isroot(k,y)){if (c[k][z][]==y) c[k][z][]=x;else c[k][z][]=x;}
  fa[k][x]=z;fa[k][y]=x;fa[k][c[k][x][r]]=y;
  c[k][y][l]=c[k][x][r];c[k][x][r]=y;
  updata(k,y);updata(k,x);
}
void splay(int k,int x){
  int top();st[++top]=x;
  for (int i=x;!isroot(k,i);i=fa[k][i]) st[++top]=fa[k][i];
  for (int i=top;i;i--) pushdown(k,st[i]);
  while (!isroot(k,x)){
   int y=fa[k][x],z=fa[k][y];
   if (!isroot(k,y))
     if (c[k][y][]==x^c[k][z][]==y) rotata(k,y);else rotata(k,x);
   rotata(k,x);
  }
}
void access(int k,int x){
  int t();while (x){splay(k,x);c[k][x][]=t;t=x;updata(k,x);x=fa[k][x];}
}
void makeroot(int k,int x){access(k,x);splay(k,x);rev[k][x]^=;}
void link(int k,int x,int y){p[k][x]++;p[k][y]++;makeroot(k,x);fa[k][x]=y;}
void cut(int k,int x,int y){
  p[k][x]--;p[k][y]--;
  makeroot(k,x);access(k,y);splay(k,y);c[k][y][]=fa[k][x]=;
}
void split(int k,int x,int y){makeroot(k,y);access(k,x);splay(k,x);}
int find(int k,int x){
  access(k,x);splay(k,x);
  int y=x;while (c[k][y][]) y=c[k][y][];
  return y;
}
int fd(int x,int y){
  int l=,r=m;
  while (l<=r){
    int mid=(l+r)>>;
    if (e[mid].st<x||(e[mid].st==x&&e[mid].en<y)) l=mid+;
    else if (e[mid].st==x&&e[mid].en==y) return mid;
    else r=mid-;
  }
}
int main(){
 n=read();m=read();cz=read();T=read();
 for (int i=;i<=n;i++) v[i]=read();
 for (int i=;i<=m;i++){
   e[i].st=read();e[i].en=read();e[i].c=read();
   if (e[i].st>e[i].en) swap(e[i].st,e[i].en);
   link(e[i].c,e[i].st,e[i].en);
 }
 sort(e+,e+m+,cmp);
 for (int i=;i<=T;i++){
   kind=read();x=read();y=read();
   if (kind==){
    for (int j=;j<cz;j++){splay(j,x);v[x]=y;updata(j,x);}
    continue;
   }
   if (kind==){
     k=read();if (x>y) swap(x,y);int t=fd(x,y);
     if (k!=e[t].c){
     if (e[t].st!=x||e[t].en!=y){puts("No such edge.");continue;}
     if (p[k][x]>=||p[k][y]>=){puts("Error 1.");continue;}
     if (find(k,x)==find(k,y)){puts("Error 2.");continue;}
     cut(e[t].c,x,y);link(k,x,y);e[t].c=k;
     }
     puts("Success.");
   }
  if (kind==){
   k=read();
   if(find(x,y)!=find(x,k)) printf("-1\n");
   else{split(x,y,k);printf("%d\n",v[mx[x][y]]);}
  }
 }
}  

t3

保留$K$位小数，$K \leq 30$ ...

可能要__float128

考虑从$1$到$N$依次插入每个数，这样可以消除绝对值

那么插入一个数有很多种情况。

1.插入以后它两边都没有数。

2.插入以后它两边都有数。

3.插入以后它的一边有数。

4.插入在边界上，且它旁边没有数。

5.插入在边界上，且它旁边有数。

于是我们用dp[i][j][k][l]表示插入了i个数，当前序列波动值为j，序列现在被分为k段，序列边界上有l个数

非常良心 __float128不会因为慢的问题被卡掉

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
const int N=1e5+;
typedef long long ll;
const int mo=,MX=;
namespace normal
{
    typedef double db;
    db f[][][][];
 }
namespace extend
{
    typedef __float128 db;
    db f[][][][];
}
int sta[N],top;
template <class node>
inline void print(node a,int p,char c=)
{
    ll s=(ll)a;
    a-=s;
    for(top=;s;s/=)sta[++top]=s%;
    if(!top)sta[++top]=;
    int x=top;
    fo(i,,p+)a*=,sta[++top]=(int)a,a-=sta[top];
    int g=;
    if (sta[top]>=)g=;
    top--;
    fd(i,top,)
    {
        sta[i]+=g;
        g=;
        if (sta[i]>=)sta[i]-=,g=;
     }
     if (g)
     {
        ++top;++x;
        fd(i,top,)sta[i]=sta[i-];
        sta[]=;
     }
     fo(i,,x)putchar(sta[i]+'');
     if (!p)
     {
        putchar(c);
        return;
     }
     else putchar('.');
     fo(i,x+,top)putchar(sta[i]+'');
     putchar(c);
}
int n,m,q;
template <class node>
inline void solve(node f[][][][])
{
    int x=,last=;
    f[x][][-+mo][]=;
    f[x][][-+mo][]=;
    f[x][][+mo][]=;
    fo(i,,n)
    {
        x=last^;
        memset(f[x],,sizeof(f[x]));
        fo(j,,mo*)
        {
            fo(k,,n-)
            {
                if (f[last][k][j][])
                {
                    node tmp=f[last][k][j][];
                    if (j-*i>=)f[x][k+][j-*i][]+=tmp*(k+);
                    if (j+*i<=MX)f[x][k-][j+*i][]+=tmp*(k-);
                    f[x][k][j][]+=tmp**k;
                    if (j+i<=MX)f[x][k][j+i][]+=tmp*;
                    if (j-i>=)f[x][k+][j-i][]+=tmp*;
                }
                if (f[last][k][j][])
                {
                    node tmp=f[last][k][j][];
                    if (j-*i>=)f[x][k+][j-*i][]+=tmp*k;
                    if (j+*i<=MX)f[x][k-][j+*i][]+=tmp*(k-);
                    f[x][k][j][]+=tmp*(*k-);
                    if (j+i<=MX)f[x][k][j+i][]+=tmp;
                    if (j-i>=)f[x][k+][j-i][]+=tmp;
                }
                if (f[last][k][j][])
                {
                    node tmp=f[last][k][j][];
                    if (j-*i>=)f[x][k+][j-*i][]+=tmp*(k-);
                    if (j+*i<=MX)f[x][k-][j+*i][]+=tmp*(k-);
                    f[x][k][j][]+=tmp**(k-);
                }
            }
        }
        last=x;
    }
    node res=;
    fo(i,m+mo,mo*)res+=f[x][][i][];
    fo(i,,n)res/=(node)i;
    print(res,q,'\n');
}
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    if (q<=)solve(normal::f);
    else solve(extend::f);
    return ;
}