Problem:
Problem H:
あみだくじ
なつめは大のねこ好きである。なつめは今日も日課としている野良ねこのブラッシングをするために，いつも野良ねこが集まってくる校庭の一角に向かうことにした。
そのスポットに今日は
n
匹のねこが集まってきた。なつめは全員をブラッシングしてやりたかったのだが，ちょうどそこに来る直前に突然用事が出来てしまい，時間的に一匹しかブラッシングしてやれないことになってしまった。ブラッシングはどのねこも楽しみにしているので，一匹だけやると他のねこが嫉妬してしまう。そこでねこたちを納得させるために，どのねこをブラッシングするかをあみだくじで決めることにした。
あみだくじは
n
本の縦線とあらかじめ引いた
m
本の横線からなる。横線はとなりあう2本の縦線をそれらと垂直になるように結ばなければならない。また，横線同士が端点を共有してはいけない。ある1本の縦線の下端には当たりのマークがつけてある。これらの条件を満たすあみだくじの例を図に示す（これらはサンプル入力の例と対応している）。
図: 問題の条件をみたすあみだくじの例
ねこたちはそれぞれ縦線の上端からどれか1つを選ぶ。そしてあみだくじを辿った結果，当たりをひいたねこが，今日のブラッシングをしてもらう権利を手に入れることができる，というルールである。なつめは早速あみだくじを作成した。縦線・横線・当たりを書き込み，横線が見えないように隠した。
いよいよねこたちに選んでもらおうという時になって，なつめは
n
匹のねこの中に，普段は顔を見せない野良ねこのアクタガワがいることに気がついた。アクタガワはもう一ヶ月ほどブラッシングをしておらず，毛がごわごわしている。
なつめは他のねこたちには申し訳ないと思いながらも，ズルをしてアクタガワをブラッシングするように仕組むことにした。まず，ねこたちにそれぞれ普通通り縦線を選んでもらう。全員が選び終わったらなつめはこっそりといくつかの横線を追加し，アクタガワが当たるようにあみだくじを変更するのだ。
しかし，アクタガワが選んだ縦線によってはアクタガワを当たりにするために新たに引かなければならない横線が多すぎて，細工をしている間にねこたちに計画がバレてしまうかもしれない。そこでなつめはまずそれぞれの縦線について，アクタガワがそれを選んだ場合に何本の横線を引けば当たりにすることができるかを求めることにした。
なお，新たに引く横線も，となりあう2本の縦線をそれらと垂直に結ばなければならず，横線同士が端点を共有しないように引かなければならない。
Input
入力データは以下の形式で与えられる。
n
m
k
h
1
x
1
h
2
x
2
...
h
m
x
m
入力の一行目には縦線の本数
n
(1 ≤
n
≤ 100000)，すでに引かれている横線の本数
m
(0 ≤
m
≤ 100000)，当たりの縦線の番号
k
(1 ≤
k
≤
n
) が与えられる。ここで，縦線の番号は，左から順に，1, 2, ...,
n
とする。
続く
m
行には横線の情報が与えられる。各行は一つの横線の情報を表す二つの整数
h
(1 ≤
h
≤ 1000000) 及び
x
(1 ≤
x
≤
n
- 1) が与えられる。
h
は縦線の下端からの距離，
x
は横線によって結ばれる縦線のうち，左側の縦線の番号である。つまり，この横線は
x
番目と
x
+1 番目の縦線を結ぶことになる。
なお、入力では横線は整数高さの位置にしか存在しないが、新たに追加する横棒の位置は必ずしも整数高さでなくてもよい。
Output
n
行の文字列を出力せよ。
i
(1 ≤
i
≤
n
) 行目には，アクタガワが
i
番目の縦線を選んだときに，アクタガワを当たりにするために追加する必要がある横線の最小本数を出力せよ。
Notes on Submission
上記形式で複数のデータセットが与えられます。入力データの 1 行目にデータセットの数が与えられます。各データセットに対する出力を上記形式で順番に出力するプログラムを作成して下さい。
Sample Input
4
3 2 1
20 1
10 2
5 7 3
70 1
60 4
50 2
40 4
30 1
20 3
10 2
1 0 1
4 2 1
10 1
10 3
Output for the Sample Input
1
0
1
1
0
1
1
2
0
1
0
1
2

Submitted solutions:

code_snippet: #include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

#define fr first
#define sc second

const int INF=1000000000;

struct SEG{
    int siz;
    int s[1<<18];
    void init(){
        siz = 1<<17;
        for(int i=0;i<2*siz-1;i++){
            s[i]=INF;
        }
    }
    void updata(int a,int b,int x,int k,int l,int r){
        if(b <= l || r <= a)return;
        if(a <= l && r <= b){
            s[k] = min ( s[k] , x );
            return;
        }
        updata(a,b,x,2*k+1,l,(l+r)/2);
        updata(a,b,x,2*k+2,(l+r)/2,r);
    }
    void _updata(int a,int x,int k,int l,int r){
        if(a+1 <= l || r <= a)return;
        if(a==l&&r==a+1){
            s[k] = x;
            return;
        }
        updata(l,r,s[k],2*k+1,l,(l+r)/2);
        updata(l,r,s[k],2*k+2,(l+r)/2,r);
        s[k] = INF;
        _updata(a,x,2*k+1,l,(l+r)/2);
        _updata(a,x,2*k+2,(l+r)/2,r);
    }
    int query(int a){
        a += siz-1;
        int ret = s[a];
        while(a > 0){
            a = (a-1)/2;
            ret = min ( ret , s[a] );
        }
        return ret;
    }
}dp[2];

int main(){
    int T;
    scanf("%d",&T);
    for(int test=0;test<T;test++){
        static int n,m,k;
        static int h[100010],x[100010];
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<m;i++){
            scanf("%d%d",&h[i],&x[i]);
        }
        
        pair<int,int> p[100010];
        for(int i=0;i<m;i++){
            p[i]=pair<int,int>(h[i],x[i]);
        }
        sort(p,p+m);
        
        dp[0].init();
        dp[1].init();
        dp[0].updata(k,n+1,-k,0,0,dp[0].siz);
        dp[1].updata(1,k+1,k,0,0,dp[1].siz);
        
        int t=0;
        int now=k;
        for(int i=0;i<m;i++){
            int c[2] = {1,-1};
            if(p[i].sc == now)now++;
            else if(p[i].sc+1 == now)now--;
            for(int j=0;j<2;j++){
                int memo=dp[j].query(p[i].sc);
                dp[j]._updata(p[i].sc,min(dp[j].query(p[i].sc+1)+c[j],abs(now-p[i].sc)-p[i].sc*c[j]),0,0,dp[j].siz);
                dp[j]._updata(p[i].sc+1,min(memo-c[j],abs(now-p[i].sc-1)-(p[i].sc+1)*c[j]),0,0,dp[j].siz);
            }
            
            if(i+1<m&&p[i].fr==p[i+1].fr)continue;
            for(;t<=i;t++){
                dp[0].updata(p[t].sc+1,n+1,min(dp[0].query(p[t].sc+1),dp[1].query(p[t].sc+1)-2*(p[t].sc+1)),0,0,dp[0].siz);
                //dp[1].updata(1,p[t].sc+2,min(dp[0].query(p[t].sc+1)+2*(p[t].sc+1),dp[1].query(p[t].sc+1)),0,0,dp[0].siz);
                //dp[0].updata(p[t].sc,n+1,min(dp[0].query(p[t].sc),dp[1].query(p[t].sc)-2*p[t].sc),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+1,min(dp[0].query(p[t].sc)+2*p[t].sc,dp[1].query(p[t].sc)),0,0,dp[1].siz);
                dp[0].updata(p[t].sc-1,n+1,min(dp[0].query(p[t].sc-1),dp[1].query(p[t].sc-1)-2*(p[t].sc-1)),0,0,dp[0].siz);
                //dp[1].updata(1,p[t].sc,min(dp[0].query(p[t].sc-1)+2*(p[t].sc-1),dp[1].query(p[t].sc-1)),0,0,dp[0].siz);
                //dp[0].updata(p[t].sc+2,n+1,min(dp[0].query(p[t].sc+2),dp[1].query(p[t].sc+2)-2*(p[t].sc+2)),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+3,min(dp[0].query(p[t].sc+2)+2*(p[t].sc+2),dp[1].query(p[t].sc+2)),0,0,dp[1].siz);
            }
        }
        
        for(int i=1;i<=n;i++){
            printf("%d%c",min(dp[0].query(i)+i,dp[1].query(i)-i),10);
        }
    }
}
accuracy: 1
time_ms: 600
memory_kb: 6808
final_rank: 2

code_snippet: #include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

#define fr first
#define sc second

const int INF=1000000000;

struct SEG{
    int siz;
    int s[1<<18];
    void init(){
        siz = 1<<17;
        for(int i=0;i<2*siz-1;i++){
            s[i]=INF;
        }
    }
    void updata(int a,int b,int x,int k,int l,int r){
        if(b <= l || r <= a)return;
        if(a <= l && r <= b){
            s[k] = min ( s[k] , x );
            return;
        }
        updata(a,b,x,2*k+1,l,(l+r)/2);
        updata(a,b,x,2*k+2,(l+r)/2,r);
    }
    void _updata(int a,int x,int k,int l,int r){
        if(a+1 <= l || r <= a)return;
        if(a==l&&r==a+1){
            s[k] = x;
            return;
        }
        updata(l,r,s[k],2*k+1,l,(l+r)/2);
        updata(l,r,s[k],2*k+2,(l+r)/2,r);
        s[k] = INF;
        _updata(a,x,2*k+1,l,(l+r)/2);
        _updata(a,x,2*k+2,(l+r)/2,r);
    }
    /*void _updata(int a,int x){
        int l=a,r=a+1,m=a;
        a += siz-1;
        s[a] = x;
        while(a > 0){
            if(a%2 == 0){
                l -= r-l;
            }
            else {
                r += r-l;
            }
            a = (a-1)/2;
            updata(l,m,s[a],a,l,r);
            updata(m+1,r,s[a],a,l,r);
            s[a] = INF;
        }
    }*/
    int query(int a){
        a += siz-1;
        int ret = s[a];
        while(a > 0){
            a = (a-1)/2;
            ret = min ( ret , s[a] );
        }
        return ret;
    }
}dp[2];

int main(){
    int T;
    scanf("%d",&T);
    for(int test=0;test<T;test++){
        static int n,m,k;
        static int h[100010],x[100010];
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<m;i++){
            scanf("%d%d",&h[i],&x[i]);
        }
        
        pair<int,int> p[100010];
        for(int i=0;i<m;i++){
            p[i]=pair<int,int>(h[i],x[i]);
        }
        sort(p,p+m);
        
        dp[0].init();
        dp[1].init();
        dp[0].updata(k,n+1,-k,0,0,dp[0].siz);
        dp[1].updata(1,k+1,k,0,0,dp[1].siz);
        
        int t=0;
        int now=k;
        for(int i=0;i<m;i++){
            int c[2] = {1,-1};
            if(p[i].sc == now)now++;
            else if(p[i].sc+1 == now)now--;
            for(int j=0;j<2;j++){
                int memo=dp[j].query(p[i].sc);
                dp[j]._updata(p[i].sc,min(dp[j].query(p[i].sc+1)+c[j],abs(now-p[i].sc)-p[i].sc*c[j]),0,0,dp[j].siz);
                dp[j]._updata(p[i].sc+1,min(memo-c[j],abs(now-p[i].sc-1)-(p[i].sc+1)*c[j]),0,0,dp[j].siz);
            }
            
            if(i+1<m&&p[i].fr==p[i+1].fr)continue;
            for(;t<=i;t++){
                dp[0].updata(p[t].sc+1,n+1,min(dp[0].query(p[t].sc+1),dp[1].query(p[t].sc+1)-2*(p[t].sc+1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc+2,min(dp[0].query(p[t].sc+1)+2*(p[t].sc+1),dp[1].query(p[t].sc+1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc,n+1,min(dp[0].query(p[t].sc),dp[1].query(p[t].sc)-2*p[t].sc),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+1,min(dp[0].query(p[t].sc)+2*p[t].sc,dp[1].query(p[t].sc)),0,0,dp[1].siz);
                dp[0].updata(p[t].sc-1,n+1,min(dp[0].query(p[t].sc-1),dp[1].query(p[t].sc-1)-2*(p[t].sc-1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc,min(dp[0].query(p[t].sc-1)+2*(p[t].sc-1),dp[1].query(p[t].sc-1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc+2,n+1,min(dp[0].query(p[t].sc+2),dp[1].query(p[t].sc+2)-2*(p[t].sc+2)),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+3,min(dp[0].query(p[t].sc+2)+2*(p[t].sc+2),dp[1].query(p[t].sc+2)),0,0,dp[1].siz);
            }
        }
        
        for(int i=1;i<=n;i++){
            printf("%d%c",min(dp[0].query(i)+i,dp[1].query(i)-i),10);
        }
    }
}
accuracy: 1
time_ms: 890
memory_kb: 6780
final_rank: 1

code_snippet: #include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

#define fr first
#define sc second

const int INF=1000000000;

struct SEG{
    int siz;
    int s[1<<18];
    void init(){
        siz = 1<<17;
        for(int i=0;i<2*siz-1;i++){
            s[i]=INF;
        }
    }
    void updata(int a,int b,int x,int k,int l,int r){
        if(b <= l || r <= a)return;
        if(a <= l && r <= b){
            s[k] = min ( s[k] , x );
            return;
        }
        updata(a,b,x,2*k+1,l,(l+r)/2);
        updata(a,b,x,2*k+2,(l+r)/2,r);
    }
    void _updata(int a,int x){
        int l=a,r=a+1,m=a;
        a += siz-1;
        s[a] = x;
        while(a > 0){
            if(a%2 == 0){
                l -= r-l;
            }
            else {
                r += r-l;
            }
            a = (a-1)/2;
            updata(l,m,s[a],a,l,r);
            updata(m+1,r,s[a],a,l,r);
            s[a] = INF;
        }
    }
    int query(int a){
        a += siz-1;
        int ret = s[a];
        while(a > 0){
            a = (a-1)/2;
            ret = min ( ret , s[a] );
        }
        return ret;
    }
}dp[2];

int main(){
    int T;
    scanf("%d",&T);
    for(int test=0;test<T;test++){
        static int n,m,k;
        static int h[100010],x[100010];
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<m;i++){
            scanf("%d%d",&h[i],&x[i]);
        }
        
        pair<int,int> p[100010];
        for(int i=0;i<m;i++){
            p[i]=pair<int,int>(h[i],x[i]);
        }
        sort(p,p+m);
        
        dp[0].init();
        dp[1].init();
        dp[0].updata(k,n+1,-k,0,0,dp[0].siz);
        dp[1].updata(1,k+1,k,0,0,dp[1].siz);
        
        
        /*static vector<int> G[100010];
        static int a[100010];
        a[0]=0;     G[0].clear();
        a[n+1]=n+1; G[n+1].clear();
        for(int i=1;i<=n;i++){
            a[i]=i;
            G[i].clear();
            G[i].push_back(i-1);
            G[i].push_back(i+1);
        }*/
        
        int t=0;
        int now=k;
        for(int i=0;i<m;i++){
            int c[2] = {1,-1};
            if(p[i].sc == now)now++;
            else if(p[i].sc+1 == now)now--;
            for(int j=0;j<2;j++){
                int memo=dp[j].query(p[i].sc);
                dp[j]._updata(p[i].sc,min(dp[j].query(p[i].sc+1)+c[j],abs(now-p[i].sc)-p[i].sc*c[j]));
                dp[j]._updata(p[i].sc+1,min(memo-c[j],abs(now-p[i].sc-1)-(p[i].sc+1)*c[j]));
            }
            
            if(i+1<m&&p[i].fr==p[i+1].fr)continue;
            for(;t<=i;t++){
                dp[0].updata(p[t].sc+1,n+1,min(dp[0].query(p[t].sc+1),dp[1].query(p[t].sc+1)-2*(p[t].sc+1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc+2,min(dp[0].query(p[t].sc+1)+2*(p[t].sc+1),dp[1].query(p[t].sc+1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc,n+1,min(dp[0].query(p[t].sc),dp[1].query(p[t].sc)-2*p[t].sc),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+1,min(dp[0].query(p[t].sc)+2*p[t].sc,dp[1].query(p[t].sc)),0,0,dp[1].siz);
                dp[0].updata(p[t].sc-1,n+1,min(dp[0].query(p[t].sc-1),dp[1].query(p[t].sc-1)-2*(p[t].sc-1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc,min(dp[0].query(p[t].sc-1)+2*(p[t].sc-1),dp[1].query(p[t].sc-1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc+2,n+1,min(dp[0].query(p[t].sc+2),dp[1].query(p[t].sc+2)-2*(p[t].sc+2)),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+3,min(dp[0].query(p[t].sc+2)+2*(p[t].sc+2),dp[1].query(p[t].sc+2)),0,0,dp[1].siz);
            }
        }
        
        /*for(int i=1;i<=n;i++){
                dp[0].updata(i,n+1,min(dp[0].query(i)+i,dp[1].query(i)-i)-i,0,0,dp[0].siz);
                dp[1].updata(1,i+1,min(dp[0].query(i)+i,dp[1].query(i)-i)+i,0,0,dp[1].siz);
        }*/
        
        for(int i=1;i<=n;i++){
            printf("%d%c",min(dp[0].query(i)+i,dp[1].query(i)-i),10);
        }
        /*for(int i=0;i<100010;i++){
            ans[i]=100010;
        }
        ans[a[k]]=0;
        
        queue<int> que;
        que.push(a[k]);
        while(!que.empty()){
            int s=que.front(); que.pop();
            for(int i=0;i<G[s].size();i++){
                if(ans[G[s][i]]==100010){
                    ans[G[s][i]]=ans[s]+1;
                    que.push(G[s][i]);
                }
            }
        }
        
        for(int i=1;i<=n;i++){
            printf("%d%c",ans[i],10);
        }*/
    }
}
accuracy: 1
time_ms: 2710
memory_kb: 6828
final_rank: 4

code_snippet: #include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

#define fr first
#define sc second

const int INF=1000000000;

struct SEG{
    int siz;
    int s[1<<18];
    void init(){
        siz = 1<<17;
        for(int i=0;i<2*siz-1;i++){
            s[i]=INF;
        }
    }
    void updata(int a,int b,int x,int k,int l,int r){
        if(b <= l || r <= a)return;
        if(a <= l && r <= b){
            s[k] = min ( s[k] , x );
            return;
        }
        updata(a,b,x,2*k+1,l,(l+r)/2);
        updata(a,b,x,2*k+2,(l+r)/2,r);
    }
    void _updata(int a,int x){
        int l=a,r=a+1,m=a;
        a += siz-1;
        s[a] = x;
        while(a > 0){
            if(a%2 == 0){
                l -= r-l;
            }
            else {
                r += r-l;
            }
            a = (a-1)/2;
            updata(l,m,s[a],a,l,r);
            updata(m+1,r,s[a],a,l,r);
            s[a] = INF;
        }
    }
    int query(int a){
        a += siz-1;
        int ret = s[a];
        while(a > 0){
            a = (a-1)/2;
            ret = min ( ret , s[a] );
        }
        return ret;
    }
}dp[2];

int main(){
    int T;
    scanf("%d",&T);
    for(int test=0;test<T;test++){
        static int n,m,k;
        static int h[100010],x[100010];
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<m;i++){
            scanf("%d%d",&h[i],&x[i]);
        }
        
        pair<int,int> p[100010];
        for(int i=0;i<m;i++){
            p[i]=pair<int,int>(h[i],x[i]);
        }
        sort(p,p+m);
        
        dp[0].init();
        dp[1].init();
        dp[0].updata(k,n+1,-k,0,0,dp[0].siz);
        dp[1].updata(1,k+1,k,0,0,dp[1].siz);
        
        
        /*static vector<int> G[100010];
        static int a[100010];
        a[0]=0;     G[0].clear();
        a[n+1]=n+1; G[n+1].clear();
        for(int i=1;i<=n;i++){
            a[i]=i;
            G[i].clear();
            G[i].push_back(i-1);
            G[i].push_back(i+1);
        }*/
        
        int t=0;
        int now=k;
        for(int i=0;i<m;i++){
            int c[2] = {1,-1};
            if(p[i].sc == now)now++;
            else if(p[i].sc+1 == now)now--;
            for(int j=0;j<2;j++){
                //int memo=min(dp[j].query(p[i].sc),dp[j].query(p[i].sc+1)+c[j]);
                //dp[j].updata(p[i].sc,p[i].sc+1,memo,0,0,dp[j].siz);
                //dp[j].updata(p[i].sc+2,p[i].sc+1,memo-c[j],0,0,dp[j].siz);
                int memo=dp[j].query(p[i].sc);
                dp[j]._updata(p[i].sc,min(dp[j].query(p[i].sc+1)+c[j],abs(now-p[i].sc)-p[i].sc*c[j]));
                dp[j]._updata(p[i].sc+1,min(memo-c[j],abs(now-p[i].sc-1)-(p[i].sc+1)*c[j]));
                //if(j == 1)cout << p[i].sc+1 << " " << memo-c[j] << endl;
            }
            
            /*for(int j=1;j<=n;j++){
                printf("%d ",dp[0].query(j)+j);
                cout << endl;
            }
            for(int j=1;j<=n;j++){
                printf("%d ",dp[1].query(j)-j);
                cout << endl;
            }*/
            
            if(i+1<m&&p[i].fr==p[i+1].fr)continue;
            for(;t<=i;t++){
                dp[0].updata(p[t].sc+1,n+1,min(dp[0].query(p[t].sc+1),dp[1].query(p[t].sc+1)-2*(p[t].sc+1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc+2,min(dp[0].query(p[t].sc+1)+2*(p[t].sc+1),dp[1].query(p[t].sc+1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc,n+1,min(dp[0].query(p[t].sc),dp[1].query(p[t].sc)-2*p[t].sc),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+1,min(dp[0].query(p[t].sc)+2*p[t].sc,dp[1].query(p[t].sc)),0,0,dp[1].siz);
                dp[0].updata(p[t].sc-1,n+1,min(dp[0].query(p[t].sc-1),dp[1].query(p[t].sc-1)-2*(p[t].sc-1)),0,0,dp[0].siz);
                dp[1].updata(1,p[t].sc,min(dp[0].query(p[t].sc-1)+2*(p[t].sc-1),dp[1].query(p[t].sc-1)),0,0,dp[0].siz);
                dp[0].updata(p[t].sc+2,n+1,min(dp[0].query(p[t].sc+2),dp[1].query(p[t].sc+2)-2*(p[t].sc+2)),0,0,dp[1].siz);
                dp[1].updata(1,p[t].sc+3,min(dp[0].query(p[t].sc+2)+2*(p[t].sc+2),dp[1].query(p[t].sc+2)),0,0,dp[1].siz);
            }
            
            /*G[a[p[i].sc-1]].push_back(a[p[i].sc]);
            G[a[p[i].sc]].push_back(a[p[i].sc-1]);
            G[a[p[i].sc+1]].push_back(a[p[i].sc+2]);
            G[a[p[i].sc+2]].push_back(a[p[i].sc+1]);*/
        }
        
        for(int i=1;i<=n;i++){
            //if(dp[0].query(i)+i==0){
                dp[0].updata(i,n+1,min(dp[0].query(i)+i,dp[1].query(i)-i)-i,0,0,dp[0].siz);
                dp[1].updata(1,i+1,min(dp[0].query(i)+i,dp[1].query(i)-i)+i,0,0,dp[1].siz);
            //}
        }
        
        for(int i=1;i<=n;i++){
            printf("%d%c",min(dp[0].query(i)+i,dp[1].query(i)-i),10);
        }
        /*for(int i=0;i<100010;i++){
            ans[i]=100010;
        }
        ans[a[k]]=0;
        
        queue<int> que;
        que.push(a[k]);
        while(!que.empty()){
            int s=que.front(); que.pop();
            for(int i=0;i<G[s].size();i++){
                if(ans[G[s][i]]==100010){
                    ans[G[s][i]]=ans[s]+1;
                    que.push(G[s][i]);
                }
            }
        }
        
        for(int i=1;i<=n;i++){
            printf("%d%c",ans[i],10);
        }*/
    }
}
accuracy: 1
time_ms: 2940
memory_kb: 6780
final_rank: 3