Codeforces Round #310 (Div. 2) A B C

A. Case of the Zeros and Ones

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Andrewid the Android is a galaxy-famous detective. In his free time he likes to think about strings containing zeros and ones.

Once he thought about a string of length n consisting of zeroes and ones. Consider the following operation: we choose any two adjacent positions in the string, and if one them contains 0, and the other contains 1, then we are allowed to remove these two digits from the string, obtaining a string of length n - 2 as a result.

Now Andreid thinks about what is the minimum length of the string that can remain after applying the described operation several times (possibly, zero)? Help him to calculate this number.

Input

First line of the input contains a single integer n (1 ≤ n ≤ 2·10⁵), the length of the string that Andreid has.

The second line contains the string of length n consisting only from zeros and ones.

Output

Output the minimum length of the string that may remain after applying the described operations several times.

Examples

Input

4
1100

Output

0

Input

5
01010

Output

1

Input

8
11101111

Output

6

Note

In the first sample test it is possible to change the string like the following: .

In the second sample test it is possible to change the string like the following: .

In the third sample test it is possible to change the string like the following: .

题意：

题解：

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 #include<bits/stdc++.h>
 #include<map>
 #include<set>
 #include<cmath>
 #include<queue>
 #include<bitset>
 #include<math.h>
 #include<vector>
 #include<string>
 #include<stdio.h>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #pragma comment(linker, "/STACK:102400000,102400000")
 using namespace std;
 #define  A first
 #define B second
 const int N=;
 const int mod=;
 const int MOD1=;
 const int MOD2=;
 const double EPS=0.00000001;
 //typedef long long ll;
 typedef __int64 ll;
 const ll MOD=;
 const int INF=;
 const ll MAX=1ll<<;
 const double eps=1e-;
 const double inf=~0u>>;
 const double pi=acos(-1.0);
 typedef double db;
 typedef unsigned int uint;
 typedef unsigned long long ull;
 int n;
 char  a[];
 int main()
 {
     scanf("%d",&n);
     scanf("%s",a+);
     int jishu1=;
     int jishu2=;
     for(int i=;i<=n;i++)
     {
         if(a[i]=='')
             jishu1++;
         else
             jishu2++;
     }
     cout<<n-*min(jishu1,jishu2)<<endl;
     return ;
 }

B. Case of Fake Numbers

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Andrewid the Android is a galaxy-famous detective. He is now investigating a case of frauds who make fake copies of the famous Stolp's gears, puzzles that are as famous as the Rubik's cube once was.

Its most important components are a button and a line of n similar gears. Each gear has n teeth containing all numbers from 0 to n - 1 in the counter-clockwise order. When you push a button, the first gear rotates clockwise, then the second gear rotates counter-clockwise, the the third gear rotates clockwise an so on.

Besides, each gear has exactly one active tooth. When a gear turns, a new active tooth is the one following after the current active tooth according to the direction of the rotation. For example, if n = 5, and the active tooth is the one containing number 0, then clockwise rotation makes the tooth with number 1 active, or the counter-clockwise rotating makes the tooth number 4 active.

Andrewid remembers that the real puzzle has the following property: you can push the button multiple times in such a way that in the end the numbers on the active teeth of the gears from first to last form sequence 0, 1, 2, ..., n - 1. Write a program that determines whether the given puzzle is real or fake.

Input

The first line contains integer n (1 ≤ n ≤ 1000) — the number of gears.

The second line contains n digits a₁, a₂, ..., a_n (0 ≤ a_i ≤ n - 1) — the sequence of active teeth: the active tooth of the i-th gear contains number a_i.

Output

In a single line print "Yes" (without the quotes), if the given Stolp's gears puzzle is real, and "No" (without the quotes) otherwise.

Examples

Input

3
1 0 0

Output

Yes

Input

5
4 2 1 4 3

Output

Yes

Input

4
0 2 3 1

Output

No

Note

In the first sample test when you push the button for the first time, the sequence of active teeth will be 2 2 1, when you push it for the second time, you get 0 1 2.

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 #include<bits/stdc++.h>
 #include<map>
 #include<set>
 #include<cmath>
 #include<queue>
 #include<bitset>
 #include<math.h>
 #include<vector>
 #include<string>
 #include<stdio.h>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #pragma comment(linker, "/STACK:102400000,102400000")
 using namespace std;
 #define  A first
 #define B second
 const int N=;
 const int mod=;
 const int MOD1=;
 const int MOD2=;
 const double EPS=0.00000001;
 //typedef long long ll;
 typedef __int64 ll;
 const ll MOD=;
 const int INF=;
 const ll MAX=1ll<<;
 const double eps=1e-;
 const double inf=~0u>>;
 const double pi=acos(-1.0);
 typedef double db;
 typedef unsigned int uint;
 typedef unsigned long long ull;
 int n;
 int a[];
 int b[];
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
         scanf("%d",&a[i]);
     for(int i=;i<=n;i++)
     {
         if(i%)
             b[i]=(i--a[i]+n)%n;
         else
             b[i]=(a[i]-(i-)+n)%n;
     }
     for(int i=;i<n;i++)
     {
         if(b[i]!=b[i+])
         {
             cout<<"No"<<endl;
             return ;
         }
     }
     cout<<"Yes"<<endl;
     return ;
 }

C. Case of Matryoshkas

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Andrewid the Android is a galaxy-famous detective. He is now investigating the case of vandalism at the exhibition of contemporary art.

The main exhibit is a construction of n matryoshka dolls that can be nested one into another. The matryoshka dolls are numbered from 1 to n. A matryoshka with a smaller number can be nested in a matryoshka with a higher number, two matryoshkas can not be directly nested in the same doll, but there may be chain nestings, for example, 1 → 2 → 4 → 5.

In one second, you can perform one of the two following operations:

• Having a matryoshka a that isn't nested in any other matryoshka and a matryoshka b, such that b doesn't contain any other matryoshka and is not nested in any other matryoshka, you may put a in b;
• Having a matryoshka a directly contained in matryoshka b, such that b is not nested in any other matryoshka, you may get a out of b.

According to the modern aesthetic norms the matryoshka dolls on display were assembled in a specific configuration, i.e. as several separate chains of nested matryoshkas, but the criminal, following the mysterious plan, took out all the dolls and assembled them into a single large chain (1 → 2 → ... → n). In order to continue the investigation Andrewid needs to know in what minimum time it is possible to perform this action.

Input

The first line contains integers n (1 ≤ n ≤ 10⁵) and k (1 ≤ k ≤ 10⁵) — the number of matryoshkas and matryoshka chains in the initial configuration.

The next k lines contain the descriptions of the chains: the i-th line first contains number m_i (1 ≤ m_i ≤ n), and then m_i numbers a_i1, a_i2, ..., a_imi — the numbers of matryoshkas in the chain (matryoshka a_i1 is nested into matryoshka a_i2, that is nested into matryoshka a_i3, and so on till the matryoshka a_imi that isn't nested into any other matryoshka).

It is guaranteed that m₁ + m₂ + ... + m_k = n, the numbers of matryoshkas in all the chains are distinct, in each chain the numbers of matryoshkas follow in the ascending order.

Output

In the single line print the minimum number of seconds needed to assemble one large chain from the initial configuration.

Examples

Input

3 2
2 1 2
1 3

Output

1

Input

7 3
3 1 3 7
2 2 5
2 4 6

Output

10

Note

In the first sample test there are two chains: 1 → 2 and 3. In one second you can nest the first chain into the second one and get 1 → 2 → 3.

In the second sample test you need to disassemble all the three chains into individual matryoshkas in 2 + 1 + 1 = 4 seconds and then assemble one big chain in 6 seconds.

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 #include<bits/stdc++.h>
 #include<map>
 #include<set>
 #include<cmath>
 #include<queue>
 #include<bitset>
 #include<math.h>
 #include<vector>
 #include<string>
 #include<stdio.h>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #pragma comment(linker, "/STACK:102400000,102400000")
 using namespace std;
 #define  A first
 #define B second
 const int mod=;
 const int MOD1=;
 const int MOD2=;
 const double EPS=0.00000001;
 //typedef long long ll;
 typedef __int64 ll;
 const ll MOD=;
 const int INF=;
 const ll MAX=1ll<<;
 const double eps=1e-;
 const double inf=~0u>>;
 const double pi=acos(-1.0);
 typedef double db;
 typedef unsigned int uint;
 typedef unsigned long long ull;
 int n,k;
 int m,exm;
 vector<int >ve[];
 int main()
 {
     scanf("%d %d",&n,&k);
     for(int i=;i<=k;i++)
     {
         scanf("%d",&exm);
         for(int j=;j<=exm;j++)
         {
             scanf("%d",&m);
             ve[i].push_back(m);
         }
     }
     int ans=;
     for(int i=;i<=k;i++)
     {
         if(ve[i][]==)
         {

          for(int j=;j<ve[i].size();j++)
          {
              if(ve[i][j]==ve[i][j-]+)
                 ans++;
                 else
             break;
          }
         }
     }
     cout<<(n-k-ans)+(n--ans)<<endl;
     return ;
 }