## Educational Codeforces Round 43 (Rated for Div. 2) ABCDE

A. Minimum Binary Number
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

String can be called correct if it consists of characters "0" and "1" and there are no redundant leading zeroes. Here are some examples: "0", "10", "1001".

You are given a correct string s.

You can perform two different operations on this string:

1. swap any pair of adjacent characters (for example, "101"  "110");
2. replace "11" with "1" (for example, "110"  "10").

Let val(s) be such a number that s is its binary representation.

Correct string a is less than some other correct string b iff val(a) < val(b).

Your task is to find the minimum correct string that you can obtain from the given one using the operations described above. You can use these operations any number of times in any order (or even use no operations at all).

Input

The first line contains integer number n (1 ≤ n ≤ 100) — the length of string s.

The second line contains the string s consisting of characters "0" and "1". It is guaranteed that the string s is correct.

Output

Print one string — the minimum correct string that you can obtain from the given one.

Examples
input
Copy
`41001`
output
Copy
`100`
input
Copy
`11`
output
Copy
`1`
Note

In the first example you can obtain the answer by the following sequence of operations: "1001"  "1010"  "1100"  "100".

In the second example you can't obtain smaller answer no matter what operations you use.

``` 1 #include<bits/stdc++.h>
2 #define clr(x) memset(x,0,sizeof(x))
3 #define mod 1000000007
4 #define clr_1(x) memset(x,-1,sizeof(x))
5 #define INF 0x3f3f3f3f
6 #define LL long long
7 #define pb push_back
8 #define pbk pop_back
9 using namespace std;
10 const int N=1e5+10;
11 char s[N];
12 int n,m,zero,one;
13 int main()
14 {
15     scanf("%d",&n);
16     scanf("%s",s);
17     for(int i=0;s[i];i++)
18     {
19         if(s[i]=='0')
20             zero++;
21         else
22             one++;
23     }
24     if(n==1 && zero==1)
25     {
26         printf("0\n");
27         return 0;
28     }
29     else
30     {
31         printf("1");
32         while(zero)
33         {
34             printf("0");
35             zero--;
36         }
37         printf("\n");
38     }
39     return 0;
40 }```
View Code
B. Lara Croft and the New Game
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You might have heard about the next game in Lara Croft series coming out this year. You also might have watched its trailer. Though you definitely missed the main idea about its plot, so let me lift the veil of secrecy.

Lara is going to explore yet another dangerous dungeon. Game designers decided to use good old 2D environment. The dungeon can be represented as a rectangle matrix of n rows and m columns. Cell (x, y) is the cell in the x-th row in the y-th column. Lara can move between the neighbouring by side cells in all four directions.

Moreover, she has even chosen the path for herself to avoid all the traps. She enters the dungeon in cell (1, 1), that is top left corner of the matrix. Then she goes down all the way to cell (n, 1) — the bottom left corner. Then she starts moving in the snake fashion — all the way to the right, one cell up, then to the left to the cell in 2-nd column, one cell up. She moves until she runs out of non-visited cells. nand m given are such that she always end up in cell (1, 2).

Lara has already moved to a neighbouring cell k times. Can you determine her current position?

Input

The only line contains three integers nm and k (2 ≤ n, m ≤ 109, n is always even, 0 ≤ k < n·m). Note that k doesn't fit into 32-bit integer type!

Output

Print the cell (the row and the column where the cell is situated) where Lara ends up after she moves k times.

Examples
input
Copy
`4 3 0`
output
Copy
`1 1`
input
Copy
`4 3 11`
output
Copy
`1 2`
input
Copy
`4 3 7`
output
Copy
`3 2`

``` 1 #include<bits/stdc++.h>
2 #define clr(x) memset(x,0,sizeof(x))
3 #define mod 1000000007
4 #define clr_1(x) memset(x,-1,sizeof(x))
5 #define INF 0x3f3f3f3f
6 #define LL long long
7 #define pb push_back
8 #define pbk pop_back
9 using namespace std;
10 const int N=1e5+10;
11 LL n,m,k,s,row,col,t;
12 int main()
13 {
14     scanf("%I64d%I64d%I64d",&n,&m,&k);
15     if(k<n)
16     {
17         printf("%I64d 1\n",k+1);
18         return 0;
19     }
20     k-=n-1;
21     m--;
22     s=k%m;
23     t=k/m;
24     if(s==0)
25     {
26         row=n-t+1;
27         col=(t&1)?m+1:2;
28     }
29     else
30     {
31         row=n-t;
32         col=(t&1)?m+2-s:1+s;
33     }
34     printf("%I64d %I64d\n",row,col);
35     return 0;
36 }```
View Code
C. Nested Segments
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given a sequence a1, a2, ..., an of one-dimensional segments numbered 1 through n. Your task is to find two distinct indices iand j such that segment ai lies within segment aj.

Segment [l1, r1] lies within segment [l2, r2] iff l1 ≥ l2 and r1 ≤ r2.

Print indices i and j. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

Input

The first line contains one integer n (1 ≤ n ≤ 3·105) — the number of segments.

Each of the next n lines contains two integers li and ri (1 ≤ li ≤ ri ≤ 109) — the i-th segment.

Output

Print two distinct indices i and j such that segment ai lies within segment aj. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

Examples
input
Copy
`51 102 93 92 32 9`
output
Copy
`2 1`
input
Copy
`31 52 66 20`
output
Copy
`-1 -1`

``` 1 #include<bits/stdc++.h>
2 #define clr(x) memset(x,0,sizeof(x))
3 #define mod 1000000007
4 #define clr_1(x) memset(x,-1,sizeof(x))
5 #define INF 0x3f3f3f3f
6 #define LL long long
7 #define pb push_back
8 #define pbk pop_back
9 using namespace std;
10 const int N=3e5+10;
11 struct sem
12 {
13     int l,r,id;
14 }seg[N];
15 bool cmp(sem a,sem b)
16 {
17     if(a.l==b.l) return a.r>b.r;
18     return a.l<b.l;
19 }
20 int u,v,n,maxr,id;
21 int main()
22 {
23     scanf("%d",&n);
24     for(int i=1;i<=n;i++)
25     {
26         scanf("%d%d",&seg[i].l,&seg[i].r);
27         seg[i].id=i;
28     }
29     sort(seg+1,seg+n+1,cmp);
30     for(int i=2;i<=n;i++)
31     {
32         if(seg[i].l==seg[i-1].l)
33         {
34             printf("%d %d\n",seg[i].id,seg[i-1].id);
35             return 0;
36         }
37         else if(seg[i].r<=seg[i-1].r)
38         {
39             printf("%d %d\n",seg[i].id,seg[i-1].id);
40             return 0;
41         }
42     }
43     printf("-1 -1\n");
44     return 0;
45 }```
View Code
D. Degree Set
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given a sequence of n positive integers d1, d2, ..., dn (d1 < d2 < ... < dn). Your task is to construct an undirected graph such that:

• there are exactly dn + 1 vertices;
• there are no self-loops;
• there are no multiple edges;
• there are no more than 106 edges;
• its degree set is equal to d.

Vertices should be numbered 1 through (dn + 1).

Degree sequence is an array a with length equal to the number of vertices in a graph such that ai is the number of vertices adjacent toi-th vertex.

Degree set is a sorted in increasing order sequence of all distinct values from the degree sequence.

It is guaranteed that there exists such a graph that all the conditions hold, and it contains no more than 106 edges.

Print the resulting graph.

Input

The first line contains one integer n (1 ≤ n ≤ 300) — the size of the degree set.

The second line contains n integers d1, d2, ..., dn (1 ≤ di ≤ 1000, d1 < d2 < ... < dn) — the degree set.

Output

In the first line print one integer m (1 ≤ m ≤ 106) — the number of edges in the resulting graph. It is guaranteed that there exists such a graph that all the conditions hold and it contains no more than 106 edges.

Each of the next m lines should contain two integers vi and ui (1 ≤ vi, ui ≤ dn + 1) — the description of the i-th edge.

Examples
input
Copy
`32 3 4`
output
Copy
`83 14 24 52 55 13 22 15 3`
input
Copy
`31 2 3`
output
Copy
`41 21 31 42 3`