11.2NOIP模拟赛

/*
根右左遍历后最长上升子序列
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>

using namespace std;

typedef long long LL;

inline LL read()
{
    char c=getchar();LL num=,f=;
    for(;!isdigit(c);c=getchar())
        f=c=='-'?-:f;
    for(;isdigit(c);c=getchar())
        num=num*+c-'';
    return num*f;
}

const int N=1e5+;

int n;
LL w[N];
int son[N][];

LL dfn[N],tim;
void dfs(int u)
{
    dfn[++tim]=w[u];
    if(son[u][]!=)
        dfs(son[u][]);
    if(son[u][]!=)
        dfs(son[u][]);
}

LL lis[N],len;
int main()
{
    freopen("point.in","r",stdin);
    freopen("point.out","w",stdout);
     int size =  << ; // 256MB
        char *p = (char*)malloc(size) + size;
        __asm__("movl %0, %%esp\n" :: "r"(p));

    n=read();
    for(int i=;i<=n;++i)
        w[i]=read();
    for(int i=;i<=n;++i)
        son[i][]=read(),son[i][]=read();
    dfs();
    lis[len=]=dfn[];
    for(int i=;i<=tim;++i)
    {
        if(dfn[i]>lis[len]) lis[++len]=dfn[i];
        else lis[lower_bound(lis+,lis+len+,dfn[i])-lis]=dfn[i];
    }
    cout<<len;
    fclose(stdin);fclose(stdout);
    return ;
}

/*
序列分为移动的序列和未移动的序列两部分
询问离散化后
对于移动的序列，抽出来树状数组统计逆序对
对于未移动的序列，想办法能直接统计答案
首先维护哪些数未被移动过，然后对于未被移动过的数求前缀和sum[i]
这样就得到了1~i中未被移动过的数的个数，进而能O(1)得出每段区间未被移动的数的个数。
考虑一个移动了的元素，从i向前移动到了j，那么他对答案的贡献，就是sum[j,i]
因为向前移动后[j,i]这段区间所有数都比他小。
同理一个元素从i向后移动到了j，那么他对答案的贡献为sum[i,j]
所以未被移动的元素对答案的贡献和就是Σabs(sum[原来位置]-sum[移动后的位置])
*/
#include<bits/stdc++.h>

#define N 200007
#define ll long long

using namespace std;
int n,m,cnt,num;
ll ans;
ll pos[N],a[N],sum[N];
struct node{
    int L,R;
}ask[N];

struct BIT_{

    int n;ll a[N];

    static int lowbit(int x){

        return x & -x;
    }

    void clear(){

        for(int i=;i<=n;i++) a[i]=;
    }

    ll query(int pos){

        ll ans=;
        for(int i=pos;i>;i-=lowbit(i)) ans+=a[i];
        return ans;
    }

    void update(int pos,int val){

        for(int i=pos;i<=n;i+=lowbit(i)) a[i]+=val;
    }
}bit;

inline int read()
{
    int x=,f=;char c=getchar();
    while(c>''||c<''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}

void discrete()
{
    for(int i=;i<=n;i++)
    {
        ask[i].L=read();ask[i].R=read();
        a[i]=ask[i].L;a[i+n]=ask[i].R;
        pos[i]=i;pos[i+n]=i+n;
    }
    sort(a+,a+n*+);
    num=unique(a+,a+n*+)-a-;
    for(int i=;i<=num;i++) sum[i]=sum[i-]+a[i]-a[i-]-;
    for(int i=;i<=n;i++)
    {
        ask[i].L=lower_bound(a+,a+num+,ask[i].L)-a;
        ask[i].R=lower_bound(a+,a+num+,ask[i].R)-a;
        swap(pos[ask[i].L],pos[ask[i].R]);
    }
}

int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    n=read();discrete();
    bit.n=n<<; bit.clear();
    for(int i=num;i>=;i--)
    {
        ans+=bit.query(pos[i]);
        ans+=abs(sum[pos[i]]-sum[i]);
        bit.update(pos[i],);
    }
    cout<<ans<<endl;
    return ;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>

#define N 200007

using namespace std;
int n,m,ans,cnt;
int head[N],pos[N],vis[N];
struct edge{
    int u,v,nxt;
}e[N<<];
struct node{
    int col,x,cur;
};queue<node>q;
inline void add(int u,int v)
{
    e[++cnt].v=v;e[cnt].nxt=head[u];head[u]=cnt;
}

inline int read()
{
    int x=,f=;char c=getchar();
    while(c>''||c<''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}

void bfs_change(int cur,int change)
{
    while(!q.empty()) q.pop();
    memset(vis,,sizeof vis);
    node u;u.col=pos[];u.x=;vis[]=;
    q.push(u);
    while(!q.empty())
    {
        u=q.front();q.pop();
        if(u.col==cur) pos[u.x]=change;
        for(int i=head[u.x];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(vis[v]) continue;
            vis[v]=;
            node tmp;tmp.x=v;tmp.col=pos[v];q.push(tmp);
        }
    }
}

void bfs_calc()
{
    ans=;
    while(!q.empty()) q.pop();
    memset(vis,,sizeof vis);
    node u;u.col=pos[];u.x=;u.cur=pos[];
    vis[]=;q.push(u);
    while(!q.empty())
    {
        u=q.front();q.pop();
        if(u.col!=u.cur) ans++;
        for(int i=head[u.x];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(vis[v]) continue;
            vis[v]=;node tmp;
            tmp.x=v;tmp.col=pos[v];tmp.cur=pos[u.x];q.push(tmp);
        }
    }
}

int main()
{
    freopen("simulator.in","r",stdin);
    freopen("simulator.out","w",stdout);
    int x,y;
    n=read();m=read();
    for(int i=;i<=n;i++) pos[i]=read();
    for(int i=;i<n;i++)
    {
        x=read();y=read();
        add(x,y);add(y,x);
    }
    for(int i=;i<=m;i++)
    {
        x=read();y=read();
        bfs_change(x,y);
        bfs_calc();
        printf("%d\n",ans);
    }
    return ;
}

30暴力

/*
bzoj1483 放到树上
见https://www.cnblogs.com/L-Memory/p/9898249.html
同理 vector+启发式合并。
*/
#include<bits/stdc++.h>

#define ll long long
#define M 200010
using namespace std;
int read()
{
    int nm = , f = ;
    char c = getchar();
    for(; !isdigit(c); c = getchar()) if(c == '-') f = -;
    for(; isdigit(c); c = getchar()) nm = nm *  + c - '';
    return nm * f;
}

int note[M], sz[M], cor[M], id[M];
vector<int>to[M], to1[M];
int n, q, ans;
void dfs(int now, int fa)
{
    if(cor[now] !=  && cor[now] != cor[fa]) ans++;
    for(int i = ; i < to[now].size(); i++)
    {
        int vj = to[now][i];
        if(vj == fa) continue;
        dfs(vj, now);
    }
}

void del(int x)
{
    for(int i = ; i < to[x].size(); i++)
    {
        int vj = to[x][i];
        if(cor[vj] != cor[x]) ans--;
    }
}
void insert(int x)
{
    for(int i = ; i < to[x].size(); i++)
    {
        int vj = to[x][i];
        if(cor[vj] != cor[x]) ans++;
    }
}
int tot = , tot2 = ;
int main()
{
    freopen("simulator.in", "r", stdin);
    freopen("simulator.out", "w", stdout);
    n = read(), q = read();
    for(int i = ; i <= n; i++) cor[i] = read(), sz[cor[i]]++, to1[cor[i]].push_back(i), id[i] = i, note[i] = i;
    for(int i = ; i < n; i++)
    {
        int vi = read(), vj = read();
        to[vi].push_back(vj), to[vj].push_back(vi);
    }
    to[].push_back(), cor[] = 0x3e3e3e3e;
    dfs(, );
    while(q--)
    {
        int x = read(), y = read();
        int xn = id[x], yn = id[y];
        if(sz[xn] < sz[yn])
        {
            tot += sz[xn], tot2 += to1[xn].size();
            for(int i = ; i < to1[xn].size(); i++)
            {
                int op = to1[xn][i];
                del(op);
                to1[yn].push_back(op);
            }
            for(int i = ; i < to1[xn].size(); i++)
            {
                int op = to1[xn][i];
                cor[op] = yn;
            }
            for(int i = ; i < to1[xn].size(); i++)
            {
                int op = to1[xn][i];
                insert(op);
            }
            to1[xn].clear();
            sz[yn] += sz[xn];
            sz[xn] = ;
            id[x] = ;
        }
        else
        {
            tot+=sz[yn], tot2 += to1[yn].size();
            for(int i = ; i < to1[yn].size(); i++)
            {
                int op = to1[yn][i];
                del(op);
                to1[xn].push_back(op);
            }
            for(int i = ; i < to1[yn].size(); i++)
            {
                int op = to1[yn][i];
                cor[op] = xn;
            }
            for(int i = ; i < to1[yn].size(); i++)
            {
                int op = to1[yn][i];
                insert(op);
            }
            to1[yn].clear();
            sz[xn] += sz[yn];
            sz[yn] = ;
            id[y] = xn;
            id[x] = ;
        }
        cout << ans << "\n";
    }
    return ;
}