Submission details
Task:Interview
Sender:tykkipeli
Submission time:2018-09-27 17:24:34 +0300
Language:C++
Status:READY
Result:
Test results
testverdicttime
#1ACCEPTED0.02 sdetails
#2ACCEPTED0.02 sdetails
#3ACCEPTED0.01 sdetails
#4ACCEPTED0.02 sdetails
#5ACCEPTED0.08 sdetails
#6ACCEPTED0.09 sdetails
#7ACCEPTED0.08 sdetails
#8ACCEPTED0.08 sdetails
#90.08 sdetails
#100.09 sdetails
#110.07 sdetails
#120.08 sdetails
#130.08 sdetails
#140.09 sdetails
#150.09 sdetails
#160.08 sdetails
#170.08 sdetails
#180.02 sdetails
#19ACCEPTED0.02 sdetails
#20ACCEPTED0.01 sdetails
#21ACCEPTED0.02 sdetails
#22ACCEPTED0.01 sdetails
#23ACCEPTED0.01 sdetails
#24ACCEPTED0.01 sdetails
#250.01 sdetails
#260.02 sdetails
#270.01 sdetails
#280.02 sdetails
#290.02 sdetails
#300.02 sdetails
#310.02 sdetails
#320.02 sdetails
#330.03 sdetails
#340.04 sdetails
#350.05 sdetails
#360.05 sdetails
#37ACCEPTED0.10 sdetails

Code

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF (1000000000)
#define nINF (-1000000000)

int n;
int m = 1;
int arr[10101010];
bool possible;

ll solve(int a, int b) {
    if(!possible) {
        return -1;
    }
   if (a+1 == b) return ((arr[a] > arr[b]) ? 1 : 0); 
   int mid = (a+b)/2;
   int maxA = nINF;
   int minA = INF;
   int maxB = nINF;
   int minB = INF;
   for (int i = a; i <= mid; i++) {
        maxA = max(maxA, arr[i]);
        minA = min(minA, arr[i]);
   }
   for (int i = mid+1; i <= b; i++) {
        maxB = max(maxB, arr[i]);
        minB = min(minB, arr[i]);
   }
//   cout << maxA << " " << minA << " " << maxB << " " << minB << endl;
   if (maxA >= maxB && minA >= minB) {
       if (minA < maxB) {
           possible = false; 
           return -1;
       }
       return 1 + solve(a,mid) + solve(mid+1,b);
   }
   if (maxB >= maxA && minB >= minA) {
       if (minB < maxA) {
           possible = false; 
           return -1;
       }
       return solve(a,mid) + solve(mid+1,b);
   }
   possible = false;
   return -1;
}

int main() {
    cin >> n;
    while (n > 0) {
        m *= 2;
        n--;
    }
    for (int i = 0; i < m; i++) {
        cin >> arr[i];
    }
    possible = true;
    ll res = solve(0,m-1);
    if (res < 0) {
        cout << "QAQ\n";
    } else {
        cout << res << "\n";
    }
}

Test details

Test 1

Verdict: ACCEPTED

input
3
5 6 6 7 2 1 4 5

correct output
2

user output
2

Test 2

Verdict: ACCEPTED

input
2
1000 100 10 1

correct output
3

user output
3

Test 3

Verdict: ACCEPTED

input
2
1 4 2 3

correct output
QAQ

user output
QAQ

Test 4

Verdict: ACCEPTED

input
4
38 48 31 29 9 2 25 23 60 63 67...

correct output
7

user output
7

Test 5

Verdict: ACCEPTED

input
17
125327615 125311457 125338848 ...

correct output
58869

user output
58869

Test 6

Verdict: ACCEPTED

input
17
528159436 528155011 528165801 ...

correct output
70714

user output
70714

Test 7

Verdict: ACCEPTED

input
17
514083812 514081465 514080093 ...

correct output
82479

user output
82479

Test 8

Verdict: ACCEPTED

input
17
642975535 642974649 642980533 ...

correct output
94267

user output
94267

Test 9

Verdict:

input
17
999999983 999999983 999999983 ...

correct output
352

user output
65356

Test 10

Verdict:

input
17
999999965 999999965 999999965 ...

correct output
265

user output
65264

Test 11

Verdict:

input
17
999999951 999999951 999999951 ...

correct output
202

user output
65205

Test 12

Verdict:

input
17
999999989 999999989 999999989 ...

correct output
135

user output
65127

Test 13

Verdict:

input
17
999999950 999999950 999999950 ...

correct output
58

user output
65053

Test 14

Verdict:

input
17
999999994 999999994 999999994 ...

correct output
96

user output
65496

Test 15

Verdict:

input
17
999999993 999999993 999999993 ...

correct output
70

user output
65478

Test 16

Verdict:

input
17
999999991 999999991 999999991 ...

correct output
44

user output
65452

Test 17

Verdict:

input
17
999999990 999999990 999999990 ...

correct output
14

user output
65414

Test 18

Verdict:

input
0
7

correct output
0

user output
QAQ

Test 19

Verdict: ACCEPTED

input
1
8 63

correct output
0

user output
0

Test 20

Verdict: ACCEPTED

input
2
45 34 61 72

correct output
1

user output
1

Test 21

Verdict: ACCEPTED

input
3
21 27 66 68 81 73 91 95

correct output
1

user output
1

Test 22

Verdict: ACCEPTED

input
4
9 2 20 25 28 26 49 39 74 58 50...

correct output
7

user output
7

Test 23

Verdict: ACCEPTED

input
5
32 27 36 34 42 49 38 39 4 5 9 ...

correct output
11

user output
11

Test 24

Verdict: ACCEPTED

input
6
71 70 66 70 64 65 62 62 59 59 ...

correct output
28

user output
28

Test 25

Verdict:

input
7
16 14 17 19 22 22 20 20 23 23 ...

correct output
30

user output
35

Test 26

Verdict:

input
8
78 78 76 76 78 78 78 78 82 83 ...

correct output
73

user output
83

Test 27

Verdict:

input
9
3 3 4 4 4 4 4 4 6 6 6 6 5 5 5 ...

correct output
84

user output
150

Test 28

Verdict:

input
10
28 28 28 28 28 28 28 28 28 29 ...

correct output
119

user output
353

Test 29

Verdict:

input
11
93 93 93 93 93 93 93 93 93 93 ...

correct output
161

user output
804

Test 30

Verdict:

input
12
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 ...

correct output
192

user output
1754

Test 31

Verdict:

input
13
21 21 21 21 21 21 21 21 21 21 ...

correct output
260

user output
3756

Test 32

Verdict:

input
14
13 13 13 13 13 13 13 13 13 13 ...

correct output
303

user output
7829

Test 33

Verdict:

input
15
90 90 90 90 90 90 90 90 90 90 ...

correct output
332

user output
15949

Test 34

Verdict:

input
16
37 37 37 37 37 37 37 37 37 37 ...

correct output
354

user output
32264

Test 35

Verdict:

input
17
10 10 10 10 10 10 10 10 10 10 ...

correct output
399

user output
64953

Test 36

Verdict:

input
17
30 30 30 30 30 30 30 30 30 30 ...

correct output
QAQ

user output
32544

Test 37

Verdict: ACCEPTED

input
17
530333517 530335373 530344723 ...

correct output
QAQ

user output
QAQ