IOI2018题解

只有部分题解

练习赛

T2

自然还是要简单考虑了

0~n-1的排列,考虑相对的大小

 

我们先考虑对于前三个:a,b,c

询问a,b,询问b,c,再询问a,b,c

发现,如果三个知道两个,那么第三个可以唯一确定

所以分情况讨论一下:

1.a>b,不妨钦定a=n-1,然后得到a,b,c的值,再询问(c,d),(b,c,d)。。。就可以得到所有的值

2.a<b,不妨钦定a=0,然后得到a,b,c的值,再询问(c,d),(b,c,d)。。。就可以得到所有的值

这里,由于a的值是钦定的,可能得到某个值是负数或者是大于n-1的,那么可以整体上下平移,得到最后的序列

最后的序列中,只要满足0在n-1左边,并且是一个0~n-1的排列,那么就是答案(显然只有一个)

T3

 

可以说是经典的冒泡排序问题!

自然要抓住本质

我们考虑对于一个ai,它归位的次数就是它前面比它大的数的个数f[i]

证明:前面比它大的数,一次最多沉底一个,然而对于自己往后沉,在后面的bi前比bi小的数那里会考虑到的

所以就是max(f[i])

修改怎么办?

树套树!

两个logn成功T飞

发现,如果i<j并且ai>aj,那么f[i]一定小于f[j],这样的i是没有用的

把刚才的定义变一下:

然后动态开点权值线段树维护即可(离线离散化也可以不动态开点)

T4

 

更优用bfs O(n^2)判断(反正提交答案)

Day1

T1

首先,首字母只有一次

询问AB,如果长度>=1,就是A或者B,再问一次。否则是X或者Y,再问一次。——2次

后面怎么办?

 

这个长度不超过4n有点意思

首先一定要满足前缀是S,所以确定的前i-1位必须都有

看来要复制4份,不妨首字母是A

暴力枚举下一个:[A....BX][A....BY][A.....BB][A....X]

由于首字母只有一次,得到的一定是四个子串的最大匹配长度

如果多了2,就是B;多了1,就是X;不变,就是Y

1次确定一位。

最后一个,需要2次确定,尝试X,再尝试Y。

总共:2+(n-2)+2=n+2次

 

T2

 

贴课件:

(这个暂时不懂怎么找那H+W个矩形)

联通块的转化,然后利用点数-边数最少是1,所以维护最小值和最小值个数即可

联通块的转化很神仙啊

启示我们,对于一些不好处理的东西,我们提取特征值记录

这里还利用了最小是1,而1恰好是合法的这一个trick

具体实现的话:

每次把原来的贡献减掉,新来的再加上

[IOI2018] seats 排座位

T3

kruscal重构树石锤了

把边权看成min(idx,idy)(最大生成树)或者max(idx,idy)(最小生成树)

就是判断两个kruscal重构树对应的子树,有没有交点即可

考虑把每个端点看成二维平面上的一个点,横坐标是第一个重构树的位置编号,纵坐标是第二个重构树位置的编号

有无交点,就是统计(l1,l2,r1,r2)这个矩形中有没有点

二维数点问题

离线扫描线+树状数组解决

扫描线 · 二维数点问题及其应用

(ps:强制在线的话可以用主席树)

 代码:

[IOI2018] werewolf 狼人

#include<bits/stdc++.h>
#define reg register int
#define il inline
#define numb (ch^'0')
using namespace std;
typedef long long ll;
il void rd(int &x){
    char ch;x=0;bool fl=false;
    while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*10+numb);
    (fl==true)&&(x=-x);
}
namespace Miracle{
const int M=400000+5;
const int N=400000+5;
const int inf=0x3f3f3f3f;
int n,m,Q;
struct edge{
    int x,y;
    int val;
}b[M];
bool cmp0(edge a,edge b){
    return a.val<b.val;
}
bool cmp1(edge a,edge b){
    return a.val>b.val;
}
int fafa[2*N];

struct kruskal{
    struct node{
        int nxt,to;
    }e[2*N];
    int hd[2*N],cnt;
    int fin(int x){
        return fafa[x]==x?x:fafa[x]=fin(fafa[x]);
    }
    void add(int x,int y){
        e[++cnt].nxt=hd[x];
        e[cnt].to=y;
        hd[x]=cnt;
    }
    int tot;
    void build(int typ){
        for(reg i=1;i<=n;++i){
            if(typ) val[i]=inf;
            else val[i]=-inf;
        }
        tot=n;
        for(reg i=1;i<=m;++i){
            int k1=fin(b[i].x),k2=fin(b[i].y);
    //        cout<<" edge "<<b[i].x<<" "<<b[i].y<<" :: "<<k1<<" "<<k2<<endl;
            if(k1!=k2){
                ++tot;
                fafa[tot]=tot;
                fafa[k1]=tot;
                fafa[k2]=tot;
                val[tot]=b[i].val;
                add(tot,k1);
                add(tot,k2);
            }
        }
    }
    int l[N],r[N];
    int val[N];
    int fa[N][20];
    int df;
    void dfs(int x){
    //    cout<<" xx "<<x<<endl;
        int son=0;
        r[x]=-inf;l[x]=inf;
        for(reg i=hd[x];i;i=e[i].nxt){
            int y=e[i].to;
            ++son;
            dfs(y);
            fa[y][0]=x;
            r[x]=max(r[x],r[y]);
            l[x]=min(l[x],l[y]);
        }
        if(!son){
            l[x]=r[x]=++df;
        }
    }
    void pre(){
        dfs(tot);
        for(reg j=1;j<=19;++j){
            for(reg i=1;i<=tot;++i){
                fa[i][j]=fa[fa[i][j-1]][j-1];
            }
        }
    }
    int fin(int x,int lim,int typ){//beizeng go val
        int p=x;
        if(!typ){//go <=lim
            for(reg j=19;j>=0;--j){
                if(fa[p][j]){
                    if(val[fa[p][j]]<=lim) p=fa[p][j];
                }
            }
            return p;
        }else{//go >=lim
            for(reg j=19;j>=0;--j){
                if(fa[p][j]){
                    if(val[fa[p][j]]>=lim) p=fa[p][j];
                }
            }
            return p;
        }
    }
}kt[2];//0:min tree;1:max tree;

int num;
struct po{
    int x,y;
    bool friend operator <(po a,po b){
        return a.x<b.x;
    }
}p[N];
int ans[N];

int tot;
struct que{
    int id,x,typ,y1,y2;
    bool friend operator <(que a,que b){
        return a.x<b.x;
    }
}q[N*2];


struct binarytree{
    int f[N];
    void upda(int x){
        for(;x<=n;x+=x&(-x)) f[x]++;
    }
    int query(int x){
        int ret=0;
        for(;x;x-=x&(-x)) ret+=f[x];
        return ret;
    }
}t;
int main(){
    rd(n);rd(m);rd(Q);
    for(reg i=1;i<=m;++i){
        rd(b[i].x);rd(b[i].y);
        
        ++b[i].x;++b[i].y;//warning!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        
        b[i].val=max(b[i].x,b[i].y);
    }
    sort(b+1,b+m+1,cmp0);
    for(reg i=1;i<=2*n;++i){
        fafa[i]=i;
    }
    kt[0].build(0);
    
    kt[0].pre();
//    cout<<" after build small "<<endl;
    for(reg i=1;i<=m;++i){
        b[i].val=min(b[i].x,b[i].y);
    }
    sort(b+1,b+m+1,cmp1);
    for(reg i=1;i<=2*n;++i){
        fafa[i]=i;
    }
    kt[1].build(1);
    kt[1].pre();
    
    int st,nd,L,R;
    for(reg i=1;i<=Q;++i){
        rd(st);rd(nd);rd(L);rd(R);
        ++L;++R;
        ++st;++nd;//warning!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        
        int ptr=kt[1].fin(st,L,1);
        q[++tot].id=i;
        q[tot].y1=kt[1].l[ptr];
        q[tot].y2=kt[1].r[ptr];
        
        q[++tot].id=i;
        q[tot].y1=kt[1].l[ptr];
        q[tot].y2=kt[1].r[ptr];
        
        ptr=kt[0].fin(nd,R,0);
        q[tot-1].x=kt[0].l[ptr]-1;
        q[tot].x=kt[0].r[ptr];
        
        q[tot-1].typ=-1;
        q[tot].typ=1;
    }
    sort(q+1,q+tot+1);
    
    for(reg i=1;i<=n;++i){
        p[i].x=kt[0].l[i];
        p[i].y=kt[1].l[i];
    }
    sort(p+1,p+n+1);
    
    int ptp=1,ptq=1;
    for(reg i=1;i<=n;++i){
        while(ptp<=n&&p[ptp].x<i) ++ptp;
        if(p[ptp].x==i){
            while(ptp<=n&&p[ptp].x==i){
                t.upda(p[ptp].y);
                ++ptp;
            }
        }
        
        while(ptq<=tot&&q[ptq].x<i) ++ptq;
        if(q[ptq].x==i){
            while(ptq<=tot&&q[ptq].x==i){
                ans[q[ptq].id]+=q[ptq].typ*(t.query(q[ptq].y2)-t.query(q[ptq].y1-1));
                ++ptq;
            }
        }
    }
    
    for(reg i=1;i<=Q;++i){
        puts(ans[i]?"1":"0");
    }
    return 0;
}

}
signed main(){
    Miracle::main();
    return 0;
}

/*
   Author: *Miracle*
   Date: 2019/2/10 15:50:00
*/
View Code

 

 

posted @ 2019-02-04 12:27  *Miracle*  阅读(1387)  评论(0编辑  收藏  举报