10.12离线赛

一、神经网络
数据：对于50%的数据，n∈[1,100]
对于100%的数据，n∈[1,200]

很简单的一道题，但是只看题目会有点误解。题目中说神经若处于兴奋状态，下一秒向后发消息。我理解成这个要按照时间来，用完后就有成平静态。这样的话U[i]就多减了，而且有问题，只有20分。
实际上是一个点的Ci要把所有他的输入的Cj全部算出来才行。

这样就有两种方法：
1、按照拓扑序，一层一层算过来
2、反向，从输出层往前，用一下记忆化搜索。

我写的是记忆化搜索。这个比较简单，只需反向存一下边就行了。

二、最大字典序排列
数据：对于60%的数据，n∈[1,2000]
对于80%的数据，n∈[1,20000]
对于100%的数据，n∈[1,100000]

不看题就猜这是到dp题，这是惯例。然后猜错了。幸好没仔细想。

正解是贪心，每次从后面选出一个数值最大并且可以交换到这个位子的数。直接实现的话类似于冒泡排序，一位一位交换上来，这样是n^2。但这道题直接这样算不对，这样写有80分。

然后就要写N log N 的了。log N 的不多，这里用的是线段树。
线段树里装的是在[L,R]这个区间里的最大值和这个区间里还有几个数没被用过(即被交换到前面)。不用记录最大值的位置吗？因为是1-N的排列，只要起初记录一下，然后再删除就行了。

Code:

#include<bits/stdc++.h>using namespace std;int A[100005],G[100005],Q[100005];//原数组，每个数的位置，哪些数已输出struct node{int L,R,mx,cnt;}tree[400005];//左右，最大值，有多少个数 void Up(int p){    tree[p].mx=max(tree[p*2].mx,tree[p*2+1].mx);    tree[p].cnt=tree[p*2].cnt+tree[p*2+1].cnt;}void Build(int L,int R,int p){    tree[p].L=L;tree[p].R=R;    if(L==R){        tree[p].mx=A[L];        tree[p].cnt=1;        return;    }    int mid=(L+R)/2;    Build(L,mid,p*2);Build(mid+1,R,p*2+1);    Up(p);}int Delete(int x,int p){//一边删除，一边计算移动步数     if(tree[p].L==tree[p].R){        tree[p].mx=tree[p].cnt=0;        return 0;    }    int mid=(tree[p].L+tree[p].R)/2;    int del;    if(mid>=x)del=Delete(x,p*2);    else del=Delete(x,p*2+1)+tree[p*2].cnt;    Up(p);    return del;}int Query(int K,int p){    if(K<0)return 0;    if(tree[p].cnt<=K)return tree[p].mx;//大区间符合，直接返回    int Lr=Query(K,p*2);//先左边，移动的步数少，    if(tree[p*2].cnt<K)return max(Lr,Query(K-tree[p*2].cnt,p*2+1));//行的话右边，K要减一下是因为右边的也要交换经过左边    return Lr;} int main(){    int n,k;    scanf("%d%d",&n,&k);    for(int i=1;i<=n;i++){        scanf("%d",&A[i]);        G[A[i]]=i;Q[i]=1;//记录位置，初始状态    }    Build(1,n,1);    for(int i=1;i<=n;i++){        if(k<=0)break;        int res=Query(k+1,1);//单点查询        printf("%d\n",res);        Q[G[res]]=0;        int del=Delete(G[res],1);        k-=del;//减去res的交换步数    }    for(int i=1;i<=n;i++)        if(Q[i])printf("%d\n",A[i]);//最后没输出的输出    return 0;}

三、航线规划
数据：对于 30%的数据,n 的范围[2,100],m 的范围[1,500],Q 的范围[1,100]
对于 60%的数据,n 的范围[2,10000],m 的范围[1,30000],Q 的范围[1,20000],数据中没有删边操作
对于 100%的数据,n 的范围[2,30000],m 的范围[1,100000],Q 的范围[1,40000],数据保证任何时候图都是连通,且没有重边和自环

又一道图论神题。兼用前几次考试最后一题的部分思想。
理一下知识点：
1、线段树(可以用BIT代替)
2、路径压缩(并查集实现)
3、LCA(倍增)
4、dfs序(造树)
5、求两点之间的路径上的值

这道题与前面的不一样的地方是，建树时随便建的，反正没用的边迟早会被标记掉，关键路径永远不会被标记掉，而且肯定在所造的树上(否则不用这条边就没办法连通了，反证法，想想很简单的)。然后是题目要删边，干脆先把边删完，最后反着一条一条加回去，这样就一样了。

卡了很久，错了三个地方：
1、LCA手贱把 step=dep[y]-dep[x] 写成 step=dep[x]-dep[y] ，这样step就是负数了，不知道哪里来的60分(全部询问输出0就有60分，这数据……)
2、合并路径时，x和y要先指向自己的父亲节点，否则会重复更新。之前那道题没有加，是因为那个更新不会造成影响，而这个不一样。
3、数组开小了，按照数据一直90，后来把数组扩大5倍对了，然后仔细想发现山区的边可能会重复问，这样就要开两倍，两倍也是对的。(之前开了个1.5倍的，错了)

Code(小长)：

#include<bits/stdc++.h>#define M 100005using namespace std;vector<int>edge[M];set<int>edge1[M];int n,m,len,cas;int fa[20][M],fa2[M],ans[M],dep[M],op[M],Q[M];struct node1{int x,y;}G[M*2],G1[M*2];int Lt[M],Rt[M],dfsline[M],T;void f(int x,int fa1){//随机把图变成一棵树    Q[x]=1;    Lt[x]=++T;dfsline[T]=x;    fa[0][x]=fa1;dep[x]=dep[fa1]+1;    for(int i=0;i<(int)edge[x].size();i++){        int y=edge[x][i];        if(y==fa1)continue;        if(edge1[x].find(y)!=edge1[x].end())continue;//要删除的边不能放进去        if(Q[y]){G1[++len]=(node1){x,y};continue;}        f(y,x);    }    Rt[x]=T;}struct Tree{//线段树部分    struct node{int L,R,sum;}tree[4*M];    void Build(int L,int R,int p){        tree[p].L=L;tree[p].R=R;tree[p].sum=0;        if(L==R){tree[p].sum=dep[dfsline[L]];return;}        int mid=(L+R)/2;        Build(L,mid,p*2);Build(mid+1,R,p*2+1);    }    int Query(int x,int p){        if(tree[p].L==tree[p].R)return tree[p].sum;        int mid=(tree[p].L+tree[p].R)/2;        if(mid>=x)return tree[p].sum+Query(x,p*2);        else return tree[p].sum+Query(x,p*2+1);    }    void Change(int L,int R,int p){        if(tree[p].L==L&&tree[p].R==R){            tree[p].sum--;return;        }        int mid=(tree[p].L+tree[p].R)/2;        if(mid>=R)Change(L,R,p*2);        else if(mid<L)Change(L,R,p*2+1);        else Change(L,mid,p*2),Change(mid+1,R,p*2+1);    }}tree;struct Lca{//LCA部分    void Init(){        for(int j=1;j<20;j++)            for(int i=1;i<=n;i++)                fa[j][i]=fa[j-1][fa[j-1][i]];    }    int LCA(int x,int y){        if(dep[x]>dep[y])swap(x,y);        int step=dep[y]-dep[x];//一开始这里错了        for(int i=0;i<20;i++)            if(step&(1<<i))y=fa[i][y];        if(x==y)return x;        for(int i=19;i>=0;i--)            if(fa[i][x]!=fa[i][y])                x=fa[i][x],y=fa[i][y];        return fa[0][x];    }}LCA;int Find(int x){return x==fa2[x]?x:fa2[x]=Find(fa2[x]);}void Hebing(int x,int y){    x=Find(x),y=Find(y);//这两句一开始没加，然后运行错，要是不加，下面的程序就会执行两次，Tree.Change就会用两次    while(x!=y){        if(dep[x]>=dep[y]){            tree.Change(Lt[x],Rt[x],1);            fa2[x]=fa[0][x];            x=Find(x);        }        else{            tree.Change(Lt[y],Rt[y],1);            fa2[y]=fa[0][y];            y=Find(y);        }    }}int main(){     scanf("%d%d%d",&n,&m,&cas);    for(int i=1;i<=m;i++){        int x,y;        scanf("%d%d",&x,&y);        edge[x].push_back(y);        edge[y].push_back(x);    }     for(int i=1;i<=cas;i++){        scanf("%d%d%d",&op[i],&G[i].x,&G[i].y);        if(op[i]==0)edge1[G[i].x].insert(G[i].y),edge1[G[i].y].insert(G[i].x);//把删除的边存下来    }    f(1,0);//造树    LCA.Init();//LCA预处理    tree.Build(1,n,1);//建线段树    for(int i=1;i<=n;i++)fa2[i]=i;    for(int i=1;i<=len;i++)Hebing(G1[i].x,G1[i].y);    for(int i=cas;i>=1;i--){        if(op[i]==0)Hebing(G[i].x,G[i].y);        else {//这里更以前一样            int lca=LCA.LCA(G[i].x,G[i].y);            int Lres=tree.Query(Lt[G[i].x],1),Rres=tree.Query(Lt[G[i].y],1),LCAres=tree.Query(Lt[lca],1);            ans[i]=Lres+Rres-LCAres*2;        }    }    for(int i=1;i<=cas;i++)        if(op[i])printf("%d\n",ans[i]);    return 0;}

被第一题坑了，卡了一个多小时，哎……