QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#69475#3275. 小明的树myee100 ✓2706ms71012kbC++113.0kb2022-12-27 18:07:252022-12-27 18:07:28

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2022-12-27 18:07:28]
  • 评测
  • 测评结果:100
  • 用时:2706ms
  • 内存:71012kb
  • [2022-12-27 18:07:25]
  • 提交

answer

// 那就是希望。
// 即便需要取模,也是光明。

#include <algorithm>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
struct Info{int minv;uint cnt;ullt sum;};
Info operator+(Info a,Info b){return a.minv==b.minv?Info{a.minv,a.cnt+b.cnt,a.sum+b.sum}:(a.minv<b.minv?a:b);}
Info tag(Info a,int b,ullt c){return{a.minv+b,a.cnt,a.sum+a.cnt*c};}
struct Seg{
    Seg*L,*R;uint len;Info v;int tag1;ullt tag2;
    Seg(uint n):L(NULL),R(NULL),len(n),v{0,n,0},tag1(0),tag2(0){if(n>1)L=new Seg(n>>1),R=new Seg(n-(n>>1));}
    voi addtag1(uint l,uint r,int w){
        if(l>=r)return;
        if(!l&&r==len){v=tag(v,w,0),tag1+=w;return;}
        if(l<(len>>1))
            if(r<=(len>>1))L->addtag1(l,r,w);
            else L->addtag1(l,len>>1,w),R->addtag1(0,r-(len>>1),w);
        else R->addtag1(l-(len>>1),r-(len>>1),w);
        v=tag(L->v+R->v,tag1,tag2);
    }
    voi addtag2(uint l,uint r,ullt w){
        if(l>=r)return;
        if(!l&&r==len){v=tag(v,0,w),tag2+=w;return;}
        if(l<(len>>1))
            if(r<=(len>>1))L->addtag2(l,r,w);
            else L->addtag2(l,len>>1,w),R->addtag2(0,r-(len>>1),w);
        else R->addtag2(l-(len>>1),r-(len>>1),w);
        v=tag(L->v+R->v,tag1,tag2);
    }
};
uint T[500005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint n,q;scanf("%u%u",&n,&q);Seg S(n-1);
    for(uint i=0;i<n;i++)S.addtag1(0,i,1),S.addtag2(i,n-1,1);
    {
        std::vector<std::pair<uint,uint> >E(n-1);
        for(auto&e:E)scanf("%u%u",&e.first,&e.second);
        T[0]=n-1;for(uint i=0,p;i<n-1;i++)scanf("%u",&p),T[p-1]=i;
        for(auto e:E){
            uint u=T[e.first-1],v=T[e.second-1];if(u>v)std::swap(u,v);
            S.addtag1(0,u,-1),S.addtag2(v,n-1,-1);
        }
    }
    auto get=[&]{return S.v.minv==1?S.v.sum:0llu;};
    printf("%llu\n",get());
    while(q--){
        uint u,v;
        scanf("%u%u",&u,&v),u=T[u-1],v=T[v-1];if(u>v)std::swap(u,v);
        S.addtag1(0,u,1),S.addtag2(v,n-1,1);
        scanf("%u%u",&u,&v),u=T[u-1],v=T[v-1];if(u>v)std::swap(u,v);
        S.addtag1(0,u,-1),S.addtag2(v,n-1,-1);
        printf("%llu\n",get());
    }
    return 0;
}

// 那就是希望。
// 即便需要取模,也是光明。

Details

Tip: Click on the bar to expand more detailed information

Subtask #1:

score: 10
Accepted

Test #1:

score: 10
Accepted
time: 944ms
memory: 71012kb

input:

500000 0
2 1
3 2
4 2
5 4
6 1
7 1
8 4
9 3
10 9
11 3
12 8
13 5
14 7
15 10
16 10
17 13
18 14
19 18
20 14
21 13
22 3
23 2
24 2
25 10
26 19
27 13
28 16
29 7
30 11
31 13
32 28
33 30
34 10
35 26
36 5
37 34
38 20
39 7
40 35
41 30
42 11
43 40
44 10
45 5
46 23
47 15
48 23
49 16
50 5
51 13
52 23
53 47
54 3
55 ...

output:

237

result:

ok 1 number(s): "237"

Subtask #2:

score: 20
Accepted

Test #2:

score: 20
Accepted
time: 10ms
memory: 4144kb

input:

8000 8000
2 1
3 2
4 1
5 4
6 3
7 4
8 3
9 3
10 8
11 6
12 7
13 11
14 11
15 7
16 4
17 11
18 7
19 8
20 19
21 18
22 17
23 2
24 15
25 23
26 13
27 10
28 1
29 7
30 17
31 11
32 18
33 2
34 1
35 29
36 5
37 21
38 6
39 7
40 26
41 19
42 3
43 9
44 39
45 23
46 41
47 38
48 12
49 4
50 30
51 1
52 41
53 17
54 41
55 53
5...

output:

16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
11
...

result:

ok 8001 numbers

Test #3:

score: 0
Accepted
time: 23ms
memory: 4072kb

input:

8000 8000
2 1
3 2
4 3
5 1
6 1
7 2
8 6
9 7
10 5
11 8
12 1
13 3
14 9
15 7
16 11
17 15
18 17
19 16
20 8
21 9
22 16
23 8
24 17
25 23
26 11
27 22
28 16
29 11
30 14
31 27
32 23
33 24
34 7
35 26
36 10
37 35
38 7
39 21
40 7
41 11
42 32
43 11
44 17
45 9
46 4
47 5
48 24
49 25
50 15
51 32
52 41
53 28
54 34
55 ...

output:

12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
12
...

result:

ok 8001 numbers

Subtask #3:

score: 70
Accepted

Dependency #1:

100%
Accepted

Dependency #2:

100%
Accepted

Test #4:

score: 70
Accepted
time: 2456ms
memory: 70948kb

input:

500000 500000
2 1
3 2
4 1
5 2
6 1
7 6
8 7
9 1
10 7
11 8
12 11
13 6
14 4
15 4
16 6
17 9
18 8
19 14
20 11
21 15
22 9
23 11
24 16
25 6
26 19
27 15
28 7
29 10
30 18
31 5
32 30
33 27
34 15
35 22
36 23
37 13
38 21
39 12
40 12
41 38
42 8
43 42
44 37
45 43
46 17
47 14
48 41
49 20
50 20
51 44
52 39
53 23
54 ...

output:

262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
262
...

result:

ok 500001 numbers

Test #5:

score: 0
Accepted
time: 2438ms
memory: 71012kb

input:

500000 500000
2 1
3 1
4 2
5 3
6 2
7 3
8 1
9 3
10 2
11 8
12 6
13 8
14 7
15 12
16 8
17 11
18 10
19 12
20 12
21 7
22 6
23 16
24 1
25 21
26 13
27 8
28 19
29 3
30 26
31 27
32 21
33 21
34 23
35 16
36 28
37 31
38 3
39 17
40 9
41 8
42 37
43 15
44 40
45 8
46 44
47 31
48 46
49 27
50 17
51 9
52 13
53 29
54 6
5...

output:

415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
415
...

result:

ok 500001 numbers

Test #6:

score: 0
Accepted
time: 2492ms
memory: 70928kb

input:

500000 500000
2 1
3 2
4 1
5 4
6 3
7 1
8 5
9 6
10 7
11 5
12 5
13 12
14 2
15 6
16 15
17 9
18 17
19 17
20 5
21 9
22 19
23 5
24 15
25 11
26 4
27 11
28 19
29 28
30 5
31 30
32 21
33 10
34 8
35 3
36 14
37 10
38 26
39 12
40 1
41 27
42 34
43 20
44 14
45 33
46 3
47 19
48 45
49 35
50 32
51 1
52 42
53 9
54 7
55...

output:

57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
57
...

result:

ok 500001 numbers

Test #7:

score: 0
Accepted
time: 2536ms
memory: 70928kb

input:

500000 500000
2 1
3 2
4 3
5 1
6 5
7 6
8 3
9 6
10 8
11 2
12 4
13 4
14 9
15 10
16 5
17 10
18 11
19 8
20 18
21 18
22 5
23 4
24 7
25 10
26 21
27 25
28 8
29 2
30 20
31 28
32 16
33 32
34 20
35 34
36 3
37 9
38 25
39 21
40 35
41 13
42 20
43 3
44 34
45 2
46 17
47 8
48 12
49 17
50 17
51 49
52 15
53 48
54 27
5...

output:

198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
198
...

result:

ok 500001 numbers

Test #8:

score: 0
Accepted
time: 2448ms
memory: 70924kb

input:

500000 500000
2 1
3 2
4 2
5 2
6 3
7 2
8 2
9 4
10 1
11 2
12 10
13 6
14 8
15 5
16 13
17 7
18 1
19 16
20 7
21 9
22 15
23 20
24 6
25 2
26 10
27 6
28 2
29 27
30 6
31 24
32 2
33 4
34 5
35 4
36 31
37 5
38 5
39 17
40 19
41 30
42 40
43 2
44 14
45 25
46 37
47 6
48 46
49 19
50 33
51 11
52 1
53 27
54 7
55 47
56...

output:

290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
290
...

result:

ok 500001 numbers

Test #9:

score: 0
Accepted
time: 2688ms
memory: 70928kb

input:

500000 500000
2 1
3 1
4 2
5 1
6 5
7 5
8 1
9 8
10 5
11 8
12 4
13 9
14 11
15 10
16 11
17 7
18 17
19 12
20 17
21 9
22 9
23 8
24 21
25 17
26 13
27 5
28 10
29 18
30 4
31 19
32 6
33 18
34 10
35 12
36 19
37 13
38 5
39 10
40 33
41 16
42 18
43 20
44 26
45 19
46 1
47 15
48 17
49 48
50 43
51 40
52 29
53 45
54 ...

output:

40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
40
...

result:

ok 500001 numbers

Test #10:

score: 0
Accepted
time: 2706ms
memory: 71012kb

input:

500000 500000
2 1
3 2
4 2
5 4
6 2
7 1
8 1
9 5
10 9
11 3
12 3
13 1
14 9
15 6
16 8
17 3
18 9
19 5
20 5
21 5
22 15
23 15
24 7
25 7
26 9
27 26
28 9
29 1
30 28
31 2
32 20
33 28
34 26
35 16
36 7
37 29
38 33
39 13
40 34
41 35
42 27
43 24
44 10
45 12
46 19
47 11
48 38
49 12
50 18
51 19
52 23
53 6
54 33
55 1...

output:

20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
20
...

result:

ok 500001 numbers