text
stringlengths 424
69.5k
|
|---|
### Prompt
Develop a solution in Cpp to the problem described below:
Hanh is a famous biologist. He loves growing trees and doing experiments on his own garden.
One day, he got a tree consisting of n vertices. Vertices are numbered from 1 to n. A tree with n vertices is an undirected connected graph with n-1 edges. Initially, Hanh sets the value of every vertex to 0.
Now, Hanh performs q operations, each is either of the following types:
* Type 1: Hanh selects a vertex v and an integer d. Then he chooses some vertex r uniformly at random, lists all vertices u such that the path from r to u passes through v. Hanh then increases the value of all such vertices u by d.
* Type 2: Hanh selects a vertex v and calculates the expected value of v.
Since Hanh is good at biology but not math, he needs your help on these operations.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 150 000) — the number of vertices on Hanh's tree and the number of operations he performs.
Each of the next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n), denoting that there is an edge connecting two vertices u and v. It is guaranteed that these n - 1 edges form a tree.
Each of the last q lines describes an operation in either formats:
* 1 v d (1 ≤ v ≤ n, 0 ≤ d ≤ 10^7), representing a first-type operation.
* 2 v (1 ≤ v ≤ n), representing a second-type operation.
It is guaranteed that there is at least one query of the second type.
Output
For each operation of the second type, write the expected value on a single line.
Let M = 998244353, it can be shown that the expected value can be expressed as an irreducible fraction p/q, where p and q are integers and q not ≡ 0 \pmod{M}. Output the integer equal to p ⋅ q^{-1} mod M. In other words, output such an integer x that 0 ≤ x < M and x ⋅ q ≡ p \pmod{M}.
Example
Input
5 12
1 2
1 3
2 4
2 5
1 1 1
2 1
2 2
2 3
2 4
2 5
1 2 2
2 1
2 2
2 3
2 4
2 5
Output
1
199648871
399297742
199648871
199648871
598946614
199648873
2
2
2
Note
The image below shows the tree in the example:
<image>
For the first query, where v = 1 and d = 1:
* If r = 1, the values of all vertices get increased.
* If r = 2, the values of vertices 1 and 3 get increased.
* If r = 3, the values of vertices 1, 2, 4 and 5 get increased.
* If r = 4, the values of vertices 1 and 3 get increased.
* If r = 5, the values of vertices 1 and 3 get increased.
Hence, the expected values of all vertices after this query are (1, 0.4, 0.8, 0.4, 0.4).
For the second query, where v = 2 and d = 2:
* If r = 1, the values of vertices 2, 4 and 5 get increased.
* If r = 2, the values of all vertices get increased.
* If r = 3, the values of vertices 2, 4 and 5 get increased.
* If r = 4, the values of vertices 1, 2, 3 and 5 get increased.
* If r = 5, the values of vertices 1, 2, 3 and 4 get increased.
Hence, the expected values of all vertices after this query are (2.2, 2.4, 2, 2, 2).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
long long expo(long long a, long long e) {
if (e == 0) return 1;
long long res = expo(a * a % 998244353, e >> 1);
if (e & 1) {
res *= a;
res %= 998244353;
}
return res;
}
int N, Q, T;
long long iN;
vector<int> edge[500013];
int parent[500013], st[500013], ft[500013], depth[500013], subtree[500013],
ancestor[20][500013];
long long upd[500013], dp[500013];
long long stor[500013];
vector<pair<long long, long long> > upds;
vector<int> ord;
void dfs(int u, int p) {
st[u] = ft[u] = T;
subtree[u] = 1;
T++;
for (int v : edge[u]) {
if (v == p) continue;
parent[v] = u;
depth[v] = depth[u] + 1;
dfs(v, u);
ft[u] = ft[v];
subtree[u] += subtree[v];
}
ord.push_back(u);
}
int kth(int u, int k) {
for (auto i = (18) - 1; i >= (0); i--) {
if (k & (1 << i)) {
u = ancestor[i][u];
}
}
return u;
}
bool insubt(int u, int v) {
if (u == N) return true;
return (st[u] <= st[v] && st[v] <= ft[u]);
}
long long get(long long u, long long v) {
if (u == v) return 0;
if (insubt(u, v)) {
int w = kth(v, depth[v] - depth[u] - 1);
return subtree[w];
}
return N - subtree[u];
}
void rebuild() {
for (auto p : upds) {
upd[p.first] += p.second;
}
for (auto i = (0); i < (N); i++) {
if (upd[i] == 0) continue;
upd[i] %= 998244353;
stor[0] += subtree[i] * upd[i];
stor[0] %= 998244353;
stor[i] += (N - subtree[i]) * upd[i];
stor[i] %= 998244353;
for (int v : edge[i]) {
if (v == parent[i]) continue;
stor[v] -= subtree[v] * upd[i];
stor[v] %= 998244353;
}
}
for (auto i = (N)-1; i >= (0); i--) {
int u = ord[i];
for (int v : edge[u]) {
if (v == parent[u]) continue;
stor[v] += stor[u];
if (stor[v] >= 998244353) stor[v] -= 998244353;
}
}
for (auto i = (0); i < (N); i++) {
dp[i] += stor[i];
dp[i] %= 998244353;
if (dp[i] < 0) dp[i] += 998244353;
upd[i] = 0;
stor[i] = 0;
}
upds.clear();
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
cin >> N >> Q;
for (auto i = (0); i < (N - 1); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
edge[u].push_back(v);
edge[v].push_back(u);
}
iN = expo(N, 998244353 - 2);
dfs(0, N);
for (auto i = (0); i < (20); i++) {
ancestor[i][N] = N;
}
for (auto i = (0); i < (N); i++) {
ancestor[0][i] = parent[i];
}
for (auto i = (1); i < (20); i++) {
for (auto j = (0); j < (N); j++) {
ancestor[i][j] = ancestor[i - 1][ancestor[i - 1][j]];
}
}
for (auto i = (0); i < (Q); i++) {
int qid, u;
cin >> qid >> u;
u--;
if (i % 241 == 0) {
rebuild();
}
if (qid == 2) {
long long ans = dp[u];
for (pair<long long, long long> p : upds) {
ans += (N - get(p.first, u)) * p.second;
ans %= 998244353;
}
cout << ans << '\n';
}
if (qid == 1) {
long long v;
cin >> v;
v *= iN;
v %= 998244353;
upds.push_back({u, v});
}
}
return 0;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
### Response
```cpp
#include <iostream>
#include <stdlib.h>
#include <algorithm>
using namespace std;
int n,l[10],ans=1000000000,i;
int x[4],X[4];
int main(){
cin>>n>>X[1]>>X[2]>>X[3];
for(i=0;i<n;i++) cin>>l[i];
for(i=0;i<1<<(2*n);i++){
int tmp=0;
for(int j=0;j<4;j++)x[j]=0;
for(int j=0;j<2*n;j+=2){
x[(i>>j)&3]+=l[j/2];
if((i>>j)&3)tmp+=10;
}
if(!(x[1]&&x[2]&&x[3])) continue;
for(int j=1;j<4;j++)tmp+=abs(X[j]-x[j]);
ans=min(ans,tmp-30);
}
cout<<ans<<endl;
return 0;
}
```
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
One day n friends met at a party, they hadn't seen each other for a long time and so they decided to make a group photo together.
Simply speaking, the process of taking photos can be described as follows. On the photo, each photographed friend occupies a rectangle of pixels: the i-th of them occupies the rectangle of width wi pixels and height hi pixels. On the group photo everybody stands in a line, thus the minimum pixel size of the photo including all the photographed friends, is W × H, where W is the total sum of all widths and H is the maximum height of all the photographed friends.
As is usually the case, the friends made n photos — the j-th (1 ≤ j ≤ n) photo had everybody except for the j-th friend as he was the photographer.
Print the minimum size of each made photo in pixels.
Input
The first line contains integer n (2 ≤ n ≤ 200 000) — the number of friends.
Then n lines follow: the i-th line contains information about the i-th friend. The line contains a pair of integers wi, hi (1 ≤ wi ≤ 10, 1 ≤ hi ≤ 1000) — the width and height in pixels of the corresponding rectangle.
Output
Print n space-separated numbers b1, b2, ..., bn, where bi — the total number of pixels on the minimum photo containing all friends expect for the i-th one.
Examples
Input
3
1 10
5 5
10 1
Output
75 110 60
Input
3
2 1
1 2
2 1
Output
6 4 6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long K = 1;
int main() {
int W = 0, H1 = 0, H2 = 0, n, i;
vector<pair<int, int> > v;
cin >> n;
v.resize(n);
for (i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
W += v[i].first;
if (v[i].second >= H1) {
H2 = H1;
H1 = v[i].second;
} else if (v[i].second > H2) {
H2 = v[i].second;
}
}
for (i = 0; i < n; i++) {
if (v[i].second == H1)
cout << (W - v[i].first) * H2 << ' ';
else
cout << (W - v[i].first) * H1 << ' ';
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
Salem gave you n sticks with integer positive lengths a_1, a_2, …, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| ≤ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of sticks.
The second line contains n integers a_i (1 ≤ a_i ≤ 100) — the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long solve() {
long long n, a, m = INT_MAX, s;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long i = 1; i < 101; i++) {
a = 0;
for (long long j = 0; j < n; j++) {
if (arr[j] > i)
a = a + arr[j] - i - 1;
else if (arr[j] < i)
a = a + i - arr[j] - 1;
}
if (a < m) {
m = a;
s = i;
}
}
cout << s << " " << m;
return 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Snuke lives at position x on a number line. On this line, there are two stores A and B, respectively at position a and b, that offer food for delivery.
Snuke decided to get food delivery from the closer of stores A and B. Find out which store is closer to Snuke's residence.
Here, the distance between two points s and t on a number line is represented by |s-t|.
Constraints
* 1 \leq x \leq 1000
* 1 \leq a \leq 1000
* 1 \leq b \leq 1000
* x, a and b are pairwise distinct.
* The distances between Snuke's residence and stores A and B are different.
Input
Input is given from Standard Input in the following format:
x a b
Output
If store A is closer, print `A`; if store B is closer, print `B`.
Examples
Input
5 2 7
Output
B
Input
1 999 1000
Output
A
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int x, a, b;
std::cin >> x >> a >> b;
std::cout << (std::abs(a - x) < std::abs(b - x) ? "A\n" : "B\n");
return 0;
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
There were n groups of students which came to write a training contest. A group is either one person who can write the contest with anyone else, or two people who want to write the contest in the same team.
The coach decided to form teams of exactly three people for this training. Determine the maximum number of teams of three people he can form. It is possible that he can't use all groups to form teams. For groups of two, either both students should write the contest, or both should not. If two students from a group of two will write the contest, they should be in the same team.
Input
The first line contains single integer n (2 ≤ n ≤ 2·105) — the number of groups.
The second line contains a sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 2), where ai is the number of people in group i.
Output
Print the maximum number of teams of three people the coach can form.
Examples
Input
4
1 1 2 1
Output
1
Input
2
2 2
Output
0
Input
7
2 2 2 1 1 1 1
Output
3
Input
3
1 1 1
Output
1
Note
In the first example the coach can form one team. For example, he can take students from the first, second and fourth groups.
In the second example he can't make a single team.
In the third example the coach can form three teams. For example, he can do this in the following way:
* The first group (of two people) and the seventh group (of one person),
* The second group (of two people) and the sixth group (of one person),
* The third group (of two people) and the fourth group (of one person).
### Response
```cpp
#include <bits/stdc++.h>
int n;
int book[3];
int main() {
while (~scanf("%d", &n)) {
int x;
memset(book, 0, sizeof(book));
for (int i = 0; i < n; i++) {
scanf("%d", &x);
book[x]++;
}
if (book[1] == 0 && book[2])
printf("0\n");
else if (book[1] && book[2] == 0)
printf("%d\n", book[1] / 3);
else {
if (book[2] < book[1])
printf("%d\n", book[2] + (book[1] - book[2]) / 3);
else if (book[2] >= book[1])
printf("%d\n", book[1]);
}
}
return 0;
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses.
Before the game began, the string is written on a piece of paper, one letter per cell.
<image> An example of the initial situation at s = "abacaba"
A player's move is the sequence of actions:
1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available.
2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|.
<image> An example of making action (i = 4) with string s = «abacaba»
Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.
Input
The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.
Output
If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).
Examples
Input
abacaba
Output
First
2
Input
abcde
Output
Second
Note
In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2.
In the second sample the first player has no available moves.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, num;
int sg[5010], f[5010];
char p[5010];
inline int mex() {
int i;
for (i = 0; f[i] == num; i++)
;
return i;
}
inline int S(int x) { return x < 0 ? 0 : sg[x]; }
inline void prepare() {
int i, j;
for (i = 1; i <= n; i++) {
num++;
for (j = 1; j <= i; j++) f[S(j - 2) ^ S(i - j - 1)] = num;
sg[i] = mex();
}
}
inline void work(int x) {
int i, an = 0, j;
for (i = 2; i < x - 1;) {
for (; i < x - 1 && p[i - 1] != p[i + 1]; i++)
;
if (i == x - 1) break;
for (j = i; j < x - 1 && p[j - 1] == p[j + 1]; j++)
;
an ^= sg[j - i];
i = j;
}
for (i = x + 2; i < n;) {
for (; i < n && p[i - 1] != p[i + 1]; i++)
;
if (i == n) break;
for (j = i; j < n && p[j - 1] == p[j + 1]; j++)
;
an ^= sg[j - i];
i = j;
}
if (!an) {
printf("First\n%d\n", x);
exit(0);
}
}
int main() {
scanf("%s", p + 1);
n = strlen(p + 1);
prepare();
for (i = 2; i <= n - 1; i++)
if (p[i - 1] == p[i + 1]) work(i);
printf("Second\n");
return 0;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
Little Paul wants to learn how to play piano. He already has a melody he wants to start with. For simplicity he represented this melody as a sequence a_1, a_2, …, a_n of key numbers: the more a number is, the closer it is to the right end of the piano keyboard.
Paul is very clever and knows that the essential thing is to properly assign fingers to notes he's going to play. If he chooses an inconvenient fingering, he will then waste a lot of time trying to learn how to play the melody by these fingers and he will probably not succeed.
Let's denote the fingers of hand by numbers from 1 to 5. We call a fingering any sequence b_1, …, b_n of fingers numbers. A fingering is convenient if for all 1≤ i ≤ n - 1 the following holds:
* if a_i < a_{i+1} then b_i < b_{i+1}, because otherwise Paul needs to take his hand off the keyboard to play the (i+1)-st note;
* if a_i > a_{i+1} then b_i > b_{i+1}, because of the same;
* if a_i = a_{i+1} then b_i≠ b_{i+1}, because using the same finger twice in a row is dumb. Please note that there is ≠, not = between b_i and b_{i+1}.
Please provide any convenient fingering or find out that there is none.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) denoting the number of notes.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2⋅10^5) denoting the positions of notes on the keyboard.
Output
If there is no convenient fingering, print -1. Otherwise, print n numbers b_1, b_2, …, b_n, each from 1 to 5, denoting a convenient fingering, separated by spaces.
Examples
Input
5
1 1 4 2 2
Output
1 4 5 4 5
Input
7
1 5 7 8 10 3 1
Output
1 2 3 4 5 4 3
Input
19
3 3 7 9 8 8 8 8 7 7 7 7 5 3 3 3 3 8 8
Output
1 3 4 5 4 5 4 5 4 5 4 5 4 3 5 4 3 5 4
Note
The third sample test is kinda "Non stop" song by Reflex.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 100;
int n;
int a[max_n];
int b[max_n];
int res[max_n];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
if (a[i] > a[i - 1])
b[i - 1] = b[i] = 1;
else if (a[i] < a[i - 1])
b[i - 1] = b[i] = -1;
}
b[0] = -b[1];
for (int i = 1; i <= n; ++i) {
if (b[i] == 1) {
if (b[i - 1] == 1)
a[i - 1] == a[i] ? res[i] = 1 : res[i] = res[i - 1] + 1;
else if (b[i - 1] == -1) {
if (a[i - 1] == a[i])
res[i - 1] == 1 ? res[i] = 2 : res[i] = 1;
else
res[i] = 1;
} else
res[i] = 1;
if (res[i] > 5) {
printf("-1");
return 0;
}
} else if (b[i] == -1) {
if (b[i - 1] == -1)
a[i - 1] == a[i] ? res[i] = 5 : res[i] = res[i - 1] - 1;
else if (b[i - 1] == 1) {
if (a[i - 1] == a[i])
res[i - 1] == 5 ? res[i] = 4 : res[i] = 5;
else
res[i] = 5;
} else
res[i] = 5;
if (res[i] < 1) {
printf("-1");
return 0;
}
}
}
for (int i = 1; i <= n; ++i) {
if (b[i] == 0) {
for (int j = 1; j <= 5; ++j)
if (j != res[i - 1] && j != res[i + 1]) res[i] = j;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", res[i]);
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
Takahashi the Jumbo will practice golf.
His objective is to get a carry distance that is a multiple of K, while he can only make a carry distance of between A and B (inclusive).
If he can achieve the objective, print `OK`; if he cannot, print `NG`.
Constraints
* All values in input are integers.
* 1 \leq A \leq B \leq 1000
* 1 \leq K \leq 1000
Input
Input is given from Standard Input in the following format:
K
A B
Output
If he can achieve the objective, print `OK`; if he cannot, print `NG`.
Examples
Input
7
500 600
Output
OK
Input
4
5 7
Output
NG
Input
1
11 11
Output
OK
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int k,a,b;
cin >> k >> a >>b;
if((b/k)*k >= a && (b/k)*k<=b) cout <<"OK";
else cout << "NG";
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 ≤ pi ≤ n for 1 ≤ i ≤ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 ≤ ai ≤ 109) — elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 ≤ bi ≤ 109) — elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 ≤ pi ≤ n) — the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100007;
const int oo = 0x3f3f3f3f;
const long long loo = 4223372036854775807ll;
const long long mod = 1e9 + 7;
struct Fuck {
int num;
int k;
Fuck() {}
Fuck(int _a, int _b) {
num = _a;
k = _b;
}
bool operator<(const Fuck &t) const { return num > t.num; }
} f[MAXN];
int b[MAXN];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> f[i].num;
f[i].k = i + 1;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
sort(f, f + n);
vector<int> vec;
vec.push_back(f[0].k);
for (int i = 1; i < n; i += 2) {
if (n % 2 == 0 && i == n - 1) {
vec.push_back(f[i].k);
continue;
}
if (b[f[i].k] > b[f[i + 1].k])
vec.push_back(f[i].k);
else
vec.push_back(f[i + 1].k);
}
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i == vec.size() - 1)
cout << '\n';
else
cout << ' ';
}
}
return 0;
}
```
|
### Prompt
Generate a cpp solution to the following problem:
Vitaly is a very weird man. He's got two favorite digits a and b. Vitaly calls a positive integer good, if the decimal representation of this integer only contains digits a and b. Vitaly calls a good number excellent, if the sum of its digits is a good number.
For example, let's say that Vitaly's favourite digits are 1 and 3, then number 12 isn't good and numbers 13 or 311 are. Also, number 111 is excellent and number 11 isn't.
Now Vitaly is wondering, how many excellent numbers of length exactly n are there. As this number can be rather large, he asks you to count the remainder after dividing it by 1000000007 (109 + 7).
A number's length is the number of digits in its decimal representation without leading zeroes.
Input
The first line contains three integers: a, b, n (1 ≤ a < b ≤ 9, 1 ≤ n ≤ 106).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
1 3 3
Output
1
Input
2 3 10
Output
165
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long fact[1000010];
long long m = 1e9 + 7;
long long me(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans = (ans % m * a % m) % m;
}
a = (a * a) % m;
b /= 2;
}
return ans % m;
}
bool check(long long x, long long a, long long b) {
while (x > 0) {
int dg = x % 10;
if (dg != a && dg != b) return false;
x /= 10;
}
return true;
}
long long ncr(long long n, long long r) {
long long fn = fact[n];
long long tf = fact[r] * fact[n - r];
tf = tf % m;
tf = me(tf, m - 2, m);
fn = (tf % m * fn % m) % m;
return fn % m;
}
int main() {
fact[0] = 1;
for (long long i = 1; i <= 1000001; i++) {
fact[i] = (fact[i - 1] * i) % m;
}
int n, a, b;
cin >> a >> b >> n;
if (a == b) {
if (check(n * a, a, b)) {
cout << "1\n";
} else
cout << "0\n";
return 0;
}
long long ans = 0;
for (long long i = 0; i <= n; i++) {
long long tmp = i * a + (n - i) * b;
if (check(tmp, a, b)) {
ans += ncr(n, i);
ans %= m;
}
}
cout << ans << "\n";
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
There are n shovels in Polycarp's shop. The i-th shovel costs i burles, that is, the first shovel costs 1 burle, the second shovel costs 2 burles, the third shovel costs 3 burles, and so on. Polycarps wants to sell shovels in pairs.
Visitors are more likely to buy a pair of shovels if their total cost ends with several 9s. Because of this, Polycarp wants to choose a pair of shovels to sell in such a way that the sum of their costs ends with maximum possible number of nines. For example, if he chooses shovels with costs 12345 and 37454, their total cost is 49799, it ends with two nines.
You are to compute the number of pairs of shovels such that their total cost ends with maximum possible number of nines. Two pairs are considered different if there is a shovel presented in one pair, but not in the other.
Input
The first line contains a single integer n (2 ≤ n ≤ 109) — the number of shovels in Polycarp's shop.
Output
Print the number of pairs of shovels such that their total cost ends with maximum possible number of nines.
Note that it is possible that the largest number of 9s at the end is 0, then you should count all such ways.
It is guaranteed that for every n ≤ 109 the answer doesn't exceed 2·109.
Examples
Input
7
Output
3
Input
14
Output
9
Input
50
Output
1
Note
In the first example the maximum possible number of nines at the end is one. Polycarp cah choose the following pairs of shovels for that purpose:
* 2 and 7;
* 3 and 6;
* 4 and 5.
In the second example the maximum number of nines at the end of total cost of two shovels is one. The following pairs of shovels suit Polycarp:
* 1 and 8;
* 2 and 7;
* 3 and 6;
* 4 and 5;
* 5 and 14;
* 6 and 13;
* 7 and 12;
* 8 and 11;
* 9 and 10.
In the third example it is necessary to choose shovels 49 and 50, because the sum of their cost is 99, that means that the total number of nines is equal to two, which is maximum possible for n = 50.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n;
long long cur = 0;
long long cate(long long s) {
long long ma = min(s - 1, n);
long long mi = (s + 2) / 2;
if (mi <= ma) {
return ma - mi + 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
while (10 * cur + 9 <= 2 * n - 1) {
cur = 10 * cur + 9;
}
long long add = cur + 1;
long long ans = 0;
for (long long i = 1; i <= 9; i++) {
ans += cate(cur);
cur += add;
}
cout << ans << "\n";
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters `A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12, 13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`, `C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger?
Constraints
* Each X and Y is `A`, `B`, `C`, `D`, `E` or `F`.
Input
Input is given from Standard Input in the following format:
X Y
Output
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal, print `=`.
Examples
Input
A B
Output
<
Input
E C
Output
>
Input
F F
Output
=
### Response
```cpp
#include <stdio.h>
int main(){
char a,b;scanf("%c %c",&a,&b);
if(a>b) putchar('>');else if(a<b) putchar('<');else putchar('=');return putchar('\n'),0;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets k⋅ b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1≤ t≤ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1≤ a, b, c, d≤ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long f(long long a, long long b, long long c, long long x) {
return (a * x * x + b * x + c);
}
long long BF(long long a, long long b, long long c, int left, int right) {
long long tmp;
while (left <= right) {
int mid = (left + right) / 2;
if (f(a, b, c, mid) > f(a, b, c, mid + 1)) {
tmp = f(a, b, c, mid);
right = mid - 1;
} else
left = mid + 1;
}
return tmp;
}
int main() {
int t;
long long a, b, c, d;
long long res;
scanf("%d", &t);
for (int test = 1; test <= t; test++) {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
long long vt1 = a - b * c;
if (vt1 > 0)
res = -1;
else {
int tmp = c / d;
res = BF(-d * b, -d * b + 2 * a, 2 * a, 0, tmp) / 2;
}
cout << res << endl;
}
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
A and B are preparing themselves for programming contests.
After several years of doing sports programming and solving many problems that require calculating all sorts of abstract objects, A and B also developed rather peculiar tastes.
A likes lowercase letters of the Latin alphabet. He has assigned to each letter a number that shows how much he likes that letter (he has assigned negative numbers to the letters he dislikes).
B likes substrings. He especially likes the ones that start and end with the same letter (their length must exceed one).
Also, A and B have a string s. Now they are trying to find out how many substrings t of a string s are interesting to B (that is, t starts and ends with the same letter and its length is larger than one), and also the sum of values of all letters (assigned by A), except for the first and the last one is equal to zero.
Naturally, A and B have quickly found the number of substrings t that are interesting to them. Can you do it?
Input
The first line contains 26 integers xa, xb, ..., xz ( - 105 ≤ xi ≤ 105) — the value assigned to letters a, b, c, ..., z respectively.
The second line contains string s of length between 1 and 105 characters, consisting of Lating lowercase letters— the string for which you need to calculate the answer.
Output
Print the answer to the problem.
Examples
Input
1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 7 1 1 1 8 1 1 1 1 1 1
xabcab
Output
2
Input
1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 7 1 1 1 8 1 1 1 1 1 1
aaa
Output
2
Note
In the first sample test strings satisfying the condition above are abca and bcab.
In the second sample test strings satisfying the condition above are two occurences of aa.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, len, alpha[26];
for (i = 0; i < 26; i++) cin >> alpha[i];
long long ans = 0, sum = 0;
string str;
cin >> str;
len = str.length();
map<long long, long long> m[26];
for (i = 0; i < len; i++) {
int x = str[i] - 'a';
ans += m[x][sum];
m[x][sum += alpha[x]]++;
}
cout << ans << endl;
return 0;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
Arkady needs your help again! This time he decided to build his own high-speed Internet exchange point. It should consist of n nodes connected with minimum possible number of wires into one network (a wire directly connects two nodes). Exactly k of the nodes should be exit-nodes, that means that each of them should be connected to exactly one other node of the network, while all other nodes should be connected to at least two nodes in order to increase the system stability.
Arkady wants to make the system as fast as possible, so he wants to minimize the maximum distance between two exit-nodes. The distance between two nodes is the number of wires a package needs to go through between those two nodes.
Help Arkady to find such a way to build the network that the distance between the two most distant exit-nodes is as small as possible.
Input
The first line contains two integers n and k (3 ≤ n ≤ 2·105, 2 ≤ k ≤ n - 1) — the total number of nodes and the number of exit-nodes.
Note that it is always possible to build at least one network with n nodes and k exit-nodes within the given constraints.
Output
In the first line print the minimum possible distance between the two most distant exit-nodes. In each of the next n - 1 lines print two integers: the ids of the nodes connected by a wire. The description of each wire should be printed exactly once. You can print wires and wires' ends in arbitrary order. The nodes should be numbered from 1 to n. Exit-nodes can have any ids.
If there are multiple answers, print any of them.
Examples
Input
3 2
Output
2
1 2
2 3
Input
5 3
Output
3
1 2
2 3
3 4
3 5
Note
In the first example the only network is shown on the left picture.
In the second example one of optimal networks is shown on the right picture.
Exit-nodes are highlighted.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long val = (n - k);
val--;
long long val1 = val / k;
long long val2 = val % k;
long long ans = 0;
ans += 2 * (val1 + 1);
if (val2) {
if (val2 == 1) {
ans++;
} else {
ans += 2;
}
}
cout << ans << '\n';
long long l = 2;
long long r;
long long j;
for (long long i = 0; i < val2; i++) {
cout << 1 << " " << l << '\n';
for (j = l; j < l + val1 + 1; j++) {
cout << j << " " << j + 1 << '\n';
r = j + 1;
}
l = j + 1;
}
for (long long i = 0; i < k - val2; i++) {
cout << 1 << " " << l << '\n';
for (j = l; j < l + val1; j++) {
cout << j << " " << j + 1 << '\n';
}
l = j + 1;
}
return 0;
}
```
|
### Prompt
Generate a cpp solution to the following problem:
For his computer science class, Jacob builds a model tree with sticks and balls containing n nodes in the shape of a tree. Jacob has spent ai minutes building the i-th ball in the tree.
Jacob's teacher will evaluate his model and grade Jacob based on the effort he has put in. However, she does not have enough time to search his whole tree to determine this; Jacob knows that she will examine the first k nodes in a DFS-order traversal of the tree. She will then assign Jacob a grade equal to the minimum ai she finds among those k nodes.
Though Jacob does not have enough time to rebuild his model, he can choose the root node that his teacher starts from. Furthermore, he can rearrange the list of neighbors of each node in any order he likes. Help Jacob find the best grade he can get on this assignment.
A DFS-order traversal is an ordering of the nodes of a rooted tree, built by a recursive DFS-procedure initially called on the root of the tree. When called on a given node v, the procedure does the following:
1. Print v.
2. Traverse the list of neighbors of the node v in order and iteratively call DFS-procedure on each one. Do not call DFS-procedure on node u if you came to node v directly from u.
Input
The first line of the input contains two positive integers, n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n) — the number of balls in Jacob's tree and the number of balls the teacher will inspect.
The second line contains n integers, ai (1 ≤ ai ≤ 1 000 000), the time Jacob used to build the i-th ball.
Each of the next n - 1 lines contains two integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi) representing a connection in Jacob's tree between balls ui and vi.
Output
Print a single integer — the maximum grade Jacob can get by picking the right root of the tree and rearranging the list of neighbors.
Examples
Input
5 3
3 6 1 4 2
1 2
2 4
2 5
1 3
Output
3
Input
4 2
1 5 5 5
1 2
1 3
1 4
Output
1
Note
In the first sample, Jacob can root the tree at node 2 and order 2's neighbors in the order 4, 1, 5 (all other nodes have at most two neighbors). The resulting preorder traversal is 2, 4, 1, 3, 5, and the minimum ai of the first 3 nodes is 3.
In the second sample, it is clear that any preorder traversal will contain node 1 as either its first or second node, so Jacob cannot do better than a grade of 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
vector<int> val, adj[N];
int sz[N], big[N], p[N], mm[N], mn[N], ok[N], a[N], ans[N], mx[N], found, n, k,
lim;
void get(int u, int sum, int root) {
if (a[u] < lim) return;
if (2 + sum + mx[root] >= k) found = 1;
for (int v : adj[u]) get(v, sum + 1 + ans[u] - ok[v] * (ans[v] + 1), root);
}
void add(int u, int sum, int root) {
if (a[u] < lim) return;
mx[root] = max(mx[root], sum + 1);
for (int v : adj[u]) add(v, sum + ans[u] - ok[v] * (ans[v] + 1), root);
}
void dsu(int u) {
if (found) return;
for (int v : adj[u]) {
if (v == big[u]) continue;
dsu(v);
if (ans[v] == sz[v] - 1 && a[v] >= lim)
ok[v] = 1, ans[u] += ans[v] + 1;
else
ok[v] = 0;
}
if (big[u]) {
dsu(big[u]);
if (ans[big[u]] == sz[big[u]] - 1 && a[big[u]] >= lim)
ok[big[u]] = 1, ans[u] += ans[big[u]] + 1;
else
ok[big[u]] = 0;
}
if (a[u] >= lim) {
mx[u] = mx[big[u]] - ok[big[u]] * (ans[big[u]] + 1);
if (mn[u] >= lim) ans[u] += (n - sz[u]);
if (ans[u] + 1 >= k || 1 + ans[u] + mx[u] >= k) found = 1;
for (int v : adj[u]) {
if (v == big[u] || a[v] < lim) continue;
if (mx[u] + ans[u] - ok[v] * (ans[v] + 1) + 1 + mx[v] >= k) found = 1;
mx[u] = max(mx[u], mx[v] - ok[v] * (ans[v] + 1));
}
if (mn[u] >= lim) ans[u] -= (n - sz[u]);
mx[u] += (ans[u] + 1);
} else
ans[u] = mx[u] = 0;
if (mx[u] >= k) found = 1;
}
bool check() {
found = 0;
fill_n(ans, n + 1, 0);
fill_n(mx, n + 1, 0);
dsu(1);
return found;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
if (fopen("test"
".inp",
"r")) {
freopen(
"test"
".inp",
"r", stdin);
freopen(
"test"
".out",
"w", stdout);
}
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i], val.emplace_back(a[i]);
sort(val.begin(), val.end());
val.erase(unique(val.begin(), val.end()), val.end());
if (k == 1) return cout << val.back(), 0;
for (int u, v, i = 1; i < n; ++i) {
cin >> u >> v;
adj[u].emplace_back(v), adj[v].emplace_back(u);
}
function<void(int, int)> dfs = [&](int u, int par) {
sz[u] = 1, big[u] = 0, p[u] = par;
mm[u] = a[u];
for (int& v : adj[u]) {
if (v == par) swap(v, adj[u].back());
if (v == par) continue;
dfs(v, u);
sz[u] += sz[v];
mm[u] = min(mm[u], mm[v]);
if (sz[big[u]] < sz[v]) big[u] = v;
}
if (par != -1) adj[u].pop_back();
};
mn[1] = 1e9;
function<void(int)> minimize = [&](int u) {
int tmp = min(a[u], mn[u]);
for (int v : adj[u]) {
mn[v] = tmp;
tmp = min(tmp, mm[v]);
}
reverse(adj[u].begin(), adj[u].end());
tmp = min(a[u], mn[u]);
for (int v : adj[u]) {
mn[v] = min(mn[v], tmp);
tmp = min(tmp, mm[v]);
minimize(v);
}
};
dfs(1, -1), minimize(1);
int low = 0, mid, high = val.size() - 1;
while (low <= high) {
mid = low + high >> 1;
lim = val[mid];
if (check())
low = mid + 1;
else
high = mid - 1;
}
cout << val[high];
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
Shrimpy Duc is a fat and greedy boy who is always hungry. After a while of searching for food to satisfy his never-ending hunger, Shrimpy Duc finds M&M candies lying unguarded on a L × L grid. There are n M&M candies on the grid, the i-th M&M is currently located at (x_i + 0.5, y_i + 0.5), and has color c_i out of a total of k colors (the size of M&Ms are insignificant).
Shrimpy Duc wants to steal a rectangle of M&Ms, specifically, he wants to select a rectangle with integer coordinates within the grid and steal all candies within the rectangle. Shrimpy Duc doesn't need to steal every single candy, however, he would like to steal at least one candy for each color.
In other words, he wants to select a rectangle whose sides are parallel to the coordinate axes and whose left-bottom vertex (X_1, Y_1) and right-top vertex (X_2, Y_2) are points with integer coordinates satisfying 0 ≤ X_1 < X_2 ≤ L and 0 ≤ Y_1 < Y_2 ≤ L, so that for every color 1 ≤ c ≤ k there is at least one M&M with color c that lies within that rectangle.
How many such rectangles are there? This number may be large, so you only need to find it modulo 10^9 + 7.
Input
The first line contains three positive integers n, k, L (1 ≤ k ≤ n ≤ 2 ⋅ 10^3, 1 ≤ L ≤ 10^9 ) — the number of M&Ms, the number of colors and the length of the grid respectively.
The following n points describe the M&Ms. Each line contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i < L, 1 ≤ c_i ≤ k) — the coordinates and color of the i-th M&M respectively.
Different M&Ms have different coordinates (x_i ≠ x_j or y_i ≠ y_j for every i ≠ j), and for every 1 ≤ c ≤ k there is at least one M&M with color c.
Output
Output a single integer — the number of rectangles satisfying Shrimpy Duc's conditions, modulo 10^9 + 7.
Examples
Input
4 2 4
3 2 2
3 1 1
1 1 1
1 2 1
Output
20
Input
5 3 10
6 5 3
5 3 1
7 9 1
2 3 2
5 0 2
Output
300
Input
10 4 10
5 4 4
0 0 3
6 0 1
3 9 2
8 7 1
8 1 3
2 1 3
6 3 2
3 5 3
4 3 4
Output
226
Note
Grid for the first sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 5;
const int MAXD = 2e3 + 5;
const int mod = 1e9 + 7;
inline void add_mod(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
struct Solver {
set<pair<int, int> > t;
int res;
Solver(void) : res(0) {}
inline int chose2(int l, int r) {
return l > r ? 0 : ((long long)(r - l + 1) * (r - l + 1 + 1) / 2) % mod;
}
inline void update(set<pair<int, int> >::iterator it, int k) {
set<pair<int, int> >::iterator pre = it, nxt = it;
++nxt;
if (it != t.begin())
--pre, res = (res - (long long)k * chose2(it->first, -pre->second)) % mod;
if (nxt != t.end())
res = (res - (long long)k * chose2(nxt->first, -it->second)) % mod;
if (it != t.begin() && nxt != t.end())
res = (res + (long long)k * chose2(nxt->first, -pre->second)) % mod;
res = (res + (long long)k * chose2(it->first, -it->second)) % mod;
if (res < 0) res += mod;
}
inline int query(void) { return res; }
inline void erase(set<pair<int, int> >::iterator it) {
update(it, -1);
t.erase(it);
}
inline void insert(int l, int r) {
if (l > r) return;
pair<int, int> cur = make_pair(l, -r);
set<pair<int, int> >::iterator it = t.lower_bound(cur);
while (it != t.end() && -it->second <= r)
erase(it), it = t.lower_bound(cur);
if (it != t.begin() && -((--it)->second) >= r) return;
update(t.insert(cur).first, 1);
}
};
struct Node {
int x, y, clr;
} p[MAXN];
inline bool cmp_x(const Node &p, const Node &q) { return p.x < q.x; }
int main(void) {
int n, d, L;
scanf("%d%d%d", &n, &d, &L);
for (int i = 1; i <= n; ++i)
scanf("%d%d%d", &p[i].x, &p[i].y, &p[i].clr), ++p[i].x, ++p[i].y;
sort(p + 1, p + n + 1, cmp_x);
p[n + 1].x = L + 1;
long long tot = ((long long)L * (L + 1) / 2) % mod;
long long ans = 0;
for (int k = 1; k <= n; ++k)
if (p[k].x != p[k + 1].x) {
static multiset<int> t[MAXD];
for (int i = 1; i <= d; ++i)
t[i].clear(), t[i].insert(0), t[i].insert(L + 1);
for (int i = 1; i <= k; ++i) t[p[i].clr].insert(p[i].y);
Solver solver;
bool flag = 1;
for (int i = 1; i <= d; ++i) {
if ((int)t[i].size() <= 2) {
flag = 0;
break;
}
multiset<int>::iterator it = t[i].begin();
while (*it <= L) {
int l = *it + 1;
++it;
solver.insert(l, *it - 1);
}
}
if (!flag) continue;
for (int i = 1; i <= k; ++i) {
if (p[i].x != p[i - 1].x) {
long long res = (tot + mod - solver.query()) % mod;
if (!res) break;
ans = (ans +
res * (p[k + 1].x - p[k].x) % mod * (p[i].x - p[i - 1].x)) %
mod;
}
multiset<int> &tt = t[p[i].clr];
multiset<int>::iterator it = tt.lower_bound(p[i].y), pre = it, nxt = it;
--pre;
++nxt;
tt.erase(it);
solver.insert(*pre + 1, *nxt - 1);
}
}
printf("%lld\n", ans);
return 0;
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Old MacDonald has a farm and a large potato field, (1010 + 1) × (1010 + 1) square meters in size. The field is divided into square garden beds, each bed takes up one square meter.
Old McDonald knows that the Colorado potato beetle is about to invade his farm and can destroy the entire harvest. To fight the insects, Old McDonald wants to spray some beds with insecticides.
So Old McDonald went to the field, stood at the center of the central field bed and sprayed this bed with insecticides. Now he's going to make a series of movements and spray a few more beds. During each movement Old McDonald moves left, right, up or down the field some integer number of meters. As Old McDonald moves, he sprays all the beds he steps on. In other words, the beds that have any intersection at all with Old McDonald's trajectory, are sprayed with insecticides.
When Old McDonald finished spraying, he wrote out all his movements on a piece of paper. Now he wants to know how many beds won't be infected after the invasion of the Colorado beetles.
It is known that the invasion of the Colorado beetles goes as follows. First some bed on the field border gets infected. Than any bed that hasn't been infected, hasn't been sprayed with insecticides and has a common side with an infected bed, gets infected as well. Help Old McDonald and determine the number of beds that won't be infected by the Colorado potato beetle.
Input
The first line contains an integer n (1 ≤ n ≤ 1000) — the number of Old McDonald's movements.
Next n lines contain the description of Old McDonald's movements. The i-th of these lines describes the i-th movement. Each movement is given in the format "di xi", where di is the character that determines the direction of the movement ("L", "R", "U" or "D" for directions "left", "right", "up" and "down", correspondingly), and xi (1 ≤ xi ≤ 106) is an integer that determines the number of meters in the movement.
Output
Print a single integer — the number of beds that won't be infected by the Colorado potato beetle.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
R 8
U 9
L 9
D 8
L 2
Output
101
Input
7
R 10
D 2
L 7
U 9
D 2
R 3
D 10
Output
52
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void read(int &digit) {
digit = 0;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
bool type = false;
if (c == '-') type = true, c = getchar();
for (; c >= '0' && c <= '9'; digit = digit * 10 + c - '0', c = getchar())
;
if (type == true) digit = -digit;
}
int n;
int bo[4010][4010];
int numx[4010], cx;
int numy[4010], cy;
int posx[4010];
int posy[4010];
int lx[4010], rx[4010];
int ly[4010], ry[4010];
int cnt_x;
int cnt_y;
int x[4010], y[4010], tot;
queue<pair<int, int> > Q;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int main() {
read(n);
int _x = 0, _y = 0;
cx = 1, cy = 1;
tot = 1;
for (int i = 1; i <= n; i++) {
char ch = getchar();
int op;
while (ch != 'L' && ch != 'R' && ch != 'U' && ch != 'D') ch = getchar();
read(op);
if (ch == 'L') {
_x -= op;
numx[++cx] = _x;
} else if (ch == 'R') {
_x += op;
numx[++cx] = _x;
} else if (ch == 'U') {
_y += op;
numy[++cy] = _y;
} else if (ch == 'D') {
_y -= op;
numy[++cy] = _y;
}
tot++;
x[tot] = _x, y[tot] = _y;
}
sort(numx + 1, numx + cx + 1);
cx = unique(numx + 1, numx + cx + 1) - (numx + 1);
sort(numy + 1, numy + cy + 1);
cy = unique(numy + 1, numy + cy + 1) - (numy + 1);
cnt_x = 2;
lx[1] = rx[1] = numx[1] - 1;
lx[2] = rx[2] = numx[1];
posx[1] = 2;
for (int i = 2; i <= cx; i++) {
if (numx[i] != numx[i - 1] + 1) {
cnt_x++;
lx[cnt_x] = numx[i - 1] + 1;
rx[cnt_x] = numx[i] - 1;
}
cnt_x++;
lx[cnt_x] = numx[i];
rx[cnt_x] = numx[i];
posx[i] = cnt_x;
}
cnt_x++;
lx[cnt_x] = rx[cnt_x] = numx[cx] + 1;
cnt_y = 2;
ly[1] = ry[1] = numy[1] - 1;
ly[2] = ry[2] = numy[1];
posy[1] = 2;
for (int i = 2; i <= cy; i++) {
if (numy[i] != numy[i - 1] + 1) {
cnt_y++;
ly[cnt_y] = numy[i - 1] + 1;
ry[cnt_y] = numy[i] - 1;
}
cnt_y++;
ly[cnt_y] = numy[i];
ry[cnt_y] = numy[i];
posy[i] = cnt_y;
}
cnt_y++;
ly[cnt_y] = ry[cnt_y] = numy[cy] + 1;
for (int i = 1; i <= tot; i++) {
int _x = lower_bound(numx + 1, numx + cx + 1, x[i]) - numx;
int _y = lower_bound(numy + 1, numy + cy + 1, y[i]) - numy;
x[i] = posx[_x], y[i] = posy[_y];
}
bo[x[1]][y[1]] = 1;
for (int i = 2; i <= tot; i++) {
if (x[i] == x[i - 1]) {
int _y = y[i], _y2 = y[i - 1];
if (_y > _y2) swap(_y, _y2);
for (int j = _y; j <= _y2; j++) bo[x[i]][j] = 1;
} else {
int _x = x[i], _x2 = x[i - 1];
if (_x > _x2) swap(_x, _x2);
for (int j = _x; j <= _x2; j++) bo[j][y[i]] = 1;
}
}
bo[1][1] = -1;
Q.push(make_pair(1, 1));
while (!Q.empty()) {
int x = Q.front().first, y = Q.front().second;
Q.pop();
for (int i = 0; i < 4; i++) {
_x = x + dx[i];
_y = y + dy[i];
if (_x <= cnt_x && _x >= 1 && _y <= cnt_y && _y >= 1)
if (bo[_x][_y] == 0) {
bo[_x][_y] = -1;
Q.push(make_pair(_x, _y));
}
}
}
long long mjy = 0;
for (int i = 1; i <= cnt_x; i++)
for (int j = 1; j <= cnt_y; j++)
if (bo[i][j] != -1)
mjy += 1LL * (rx[i] - lx[i] + 1) * (ry[j] - ly[j] + 1);
printf("%I64d\n", mjy);
return 0;
}
```
|
### Prompt
Construct a Cpp code solution to the problem outlined:
Let's call a string a phone number if it has length 11 and fits the pattern "8xxxxxxxxxx", where each "x" is replaced by a digit.
For example, "80123456789" and "80000000000" are phone numbers, while "8012345678" and "79000000000" are not.
You have n cards with digits, and you want to use them to make as many phone numbers as possible. Each card must be used in at most one phone number, and you don't have to use all cards. The phone numbers do not necessarily have to be distinct.
Input
The first line contains an integer n — the number of cards with digits that you have (1 ≤ n ≤ 100).
The second line contains a string of n digits (characters "0", "1", ..., "9") s_1, s_2, …, s_n. The string will not contain any other characters, such as leading or trailing spaces.
Output
If at least one phone number can be made from these cards, output the maximum number of phone numbers that can be made. Otherwise, output 0.
Examples
Input
11
00000000008
Output
1
Input
22
0011223344556677889988
Output
2
Input
11
31415926535
Output
0
Note
In the first example, one phone number, "8000000000", can be made from these cards.
In the second example, you can make two phone numbers from the cards, for example, "80123456789" and "80123456789".
In the third example you can't make any phone number from the given cards.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '8') count++;
}
if (n < 11)
cout << "0" << endl;
else {
cout << min(count, n / 11) << endl;
}
return 0;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given a and b.
Constraints
* 0 < a, b ≤ 2,000,000,000
* LCM(a, b) ≤ 2,000,000,000
* The number of data sets ≤ 50
Input
Input consists of several data sets. Each data set contains a and b separated by a single space in a line. The input terminates with EOF.
Output
For each data set, print GCD and LCM separated by a single space in a line.
Example
Input
8 6
50000000 30000000
Output
2 24
10000000 150000000
### Response
```cpp
#include <iostream>
using namespace std;
int gcd(int a, int b) {
return a % b ? gcd(b, a % b) : b;
}
int lcm(int a, int b) {
return a / gcd(a,b) * b;
}
int main() {
int a, b;
while(cin >> a >> b) {
cout << gcd(a,b) << " " << lcm(a,b) << endl;
}
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
Nowadays the one-way traffic is introduced all over the world in order to improve driving safety and reduce traffic jams. The government of Berland decided to keep up with new trends. Formerly all n cities of Berland were connected by n two-way roads in the ring, i. e. each city was connected directly to exactly two other cities, and from each city it was possible to get to any other city. Government of Berland introduced one-way traffic on all n roads, but it soon became clear that it's impossible to get from some of the cities to some others. Now for each road is known in which direction the traffic is directed at it, and the cost of redirecting the traffic. What is the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other?
Input
The first line contains integer n (3 ≤ n ≤ 100) — amount of cities (and roads) in Berland. Next n lines contain description of roads. Each road is described by three integers ai, bi, ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 100) — road is directed from city ai to city bi, redirecting the traffic costs ci.
Output
Output single integer — the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other.
Examples
Input
3
1 3 1
1 2 1
3 2 1
Output
1
Input
3
1 3 1
1 2 5
3 2 1
Output
2
Input
6
1 5 4
5 3 8
2 4 15
1 6 16
2 3 23
4 6 42
Output
39
Input
4
1 2 9
2 3 8
3 4 7
4 1 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
set<int> in, x;
long totalCost(0), cost(0);
while (n--) {
int a, b, c;
scanf("%d %d %d\n", &a, &b, &c);
totalCost += c;
if (in.count(a) || x.count(b)) {
cost += c;
x.insert(a);
in.insert(b);
} else {
in.insert(a);
x.insert(b);
}
}
if (totalCost - cost < cost) {
cost = totalCost - cost;
}
printf("%ld\n", cost);
return 0;
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
The ICPC committee would like to have its meeting as soon as possible to address every little issue of the next contest. However, members of the committee are so busy maniacally developing (possibly useless) programs that it is very difficult to arrange their schedules for the meeting. So, in order to settle the meeting date, the chairperson requested every member to send back a list of convenient dates by E-mail. Your mission is to help the chairperson, who is now dedicated to other issues of the contest, by writing a program that chooses the best date from the submitted lists. Your program should find the date convenient for the most members. If there is more than one such day, the earliest is the best.
Input
The input has multiple data sets, each starting with a line containing the number of committee members and the quorum of the meeting.
> N Q
Here, N, meaning the size of the committee, and Q meaning the quorum, are positive integers. N is less than 50, and, of course, Q is less than or equal to N.
N lines follow, each describing convenient dates for a committee member in the following format.
> M Date1 Date2 ... DateM
Here, M means the number of convenient dates for the member, which is an integer greater than or equal to zero. The remaining items in the line are his/her dates of convenience, which are positive integers less than 100, that is, 1 means tomorrow, 2 means the day after tomorrow, and so on. They are in ascending order without any repetition and separated by a space character. Lines have neither leading nor trailing spaces.
A line containing two zeros indicates the end of the input.
Output
For each data set, print a single line containing the date number convenient for the largest number of committee members. If there is more than one such date, print the earliest. However, if no dates are convenient for more than or equal to the quorum number of members, print 0 instead.
Example
Input
3 2
2 1 4
0
3 3 4 8
3 2
4 1 5 8 9
3 2 5 9
5 2 4 5 7 9
3 3
2 1 4
3 2 5 9
2 2 4
3 3
2 1 2
3 1 2 9
2 2 4
0 0
Output
4
5
0
2
### Response
```cpp
#include <iostream>
#include <map>
using namespace std;
int N, Q;
int main() {
while (cin >> N >> Q) {
if (N == 0) break;
map<int,int> ma;
for (int i = 0; i < N; ++i) {
int M; cin >> M;
for (int j = 0; j < M; ++j) {
int a; cin >> a;
ma[a]++;
}
}
int Max = -1, pMax = -1;
for (map<int,int>::iterator it = ma.begin(); it != ma.end(); ++it) {
if (it->second > Max && it->second >= Q) {
Max = it->second;
pMax = it->first;
}
}
cout << (pMax != -1 ? pMax : 0) << endl;
}
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a simple undirected graph with N vertices and M edges. The vertices are numbered 1 through N, and the edges are numbered 1 through M. Edge i connects Vertex U_i and V_i. Also, Vertex i has two predetermined integers A_i and B_i. You will play the following game on this graph.
First, choose one vertex and stand on it, with W yen (the currency of Japan) in your pocket. Here, A_s \leq W must hold, where s is the vertex you choose. Then, perform the following two kinds of operations any number of times in any order:
* Choose one vertex v that is directly connected by an edge to the vertex you are standing on, and move to vertex v. Here, you need to have at least A_v yen in your pocket when you perform this move.
* Donate B_v yen to the vertex v you are standing on. Here, the amount of money in your pocket must not become less than 0 yen.
You win the game when you donate once to every vertex. Find the smallest initial amount of money W that enables you to win the game.
Constraints
* 1 \leq N \leq 10^5
* N-1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq 10^9
* 1 \leq U_i < V_i \leq N
* The given graph is connected and simple (there is at most one edge between any pair of vertices).
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_N B_N
U_1 V_1
U_2 V_2
:
U_M V_M
Output
Print the smallest initial amount of money W that enables you to win the game.
Examples
Input
4 5
3 1
1 2
4 1
6 2
1 2
2 3
2 4
1 4
3 4
Output
6
Input
5 8
6 4
15 13
15 19
15 1
20 7
1 3
1 4
1 5
2 3
2 4
2 5
3 5
4 5
Output
44
Input
9 10
131 2
98 79
242 32
231 38
382 82
224 22
140 88
209 70
164 64
6 8
1 6
1 4
1 3
4 7
4 9
3 7
3 9
5 9
2 5
Output
582
### Response
```cpp
#include<bits/stdc++.h>
#define LL long long
#define clr(x,i) memset(x,i,sizeof(x))
using namespace std;
const int N=100007;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
vector<int> G[N];
int n,m,a[N],b[N],fa[N],rk[N],vis[N];
LL f[N],sum[N],ans;
bool cmp(int x,int y)
{
return a[x]<a[y];
}
int getfa(int x)
{
return fa[x]==x ? x : fa[x]=getfa(fa[x]);
}
int main()
{
n=read();m=read();
for(int i=1;i<=n;i++){
a[i]=read(),b[i]=read();
a[i]=max(a[i]-b[i],0);
}
for(int i=1;i<=m;i++){
int u=read(),v=read();
G[u].push_back(v);G[v].push_back(u);
}
for(int i=1;i<=n;i++){
rk[i]=fa[i]=i; f[i]=a[i]; sum[i]=b[i];
}
sort(rk+1,rk+n+1,cmp);
for(int i=1;i<=n;i++)
{
int u=rk[i]; vis[u]=1;
for(int j=0;j<G[u].size();j++)
{
int v=G[u][j];
if(!vis[v]) continue;
int x=getfa(u),y=getfa(v);
if(x!=y){
fa[y]=x; sum[x]+=sum[y];
// f[x]=min(f[x],f[y]+max(f[y],a[x]-sum[y]));
f[x]=min(f[x],max(f[y],a[x]-sum[y]));
}
}
}
int rt=getfa(1);
printf("%lld\n",f[rt]+sum[rt]);
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
Alice wants to send an important message to Bob. Message a = (a1, ..., an) is a sequence of positive integers (characters).
To compress the message Alice wants to use binary Huffman coding. We recall that binary Huffman code, or binary prefix code is a function f, that maps each letter that appears in the string to some binary string (that is, string consisting of characters '0' and '1' only) such that for each pair of different characters ai and aj string f(ai) is not a prefix of f(aj) (and vice versa). The result of the encoding of the message a1, a2, ..., an is the concatenation of the encoding of each character, that is the string f(a1)f(a2)... f(an). Huffman codes are very useful, as the compressed message can be easily and uniquely decompressed, if the function f is given. Code is usually chosen in order to minimize the total length of the compressed message, i.e. the length of the string f(a1)f(a2)... f(an).
Because of security issues Alice doesn't want to send the whole message. Instead, she picks some substrings of the message and wants to send them separately. For each of the given substrings ali... ari she wants to know the minimum possible length of the Huffman coding. Help her solve this problem.
Input
The first line of the input contains the single integer n (1 ≤ n ≤ 100 000) — the length of the initial message. The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000) — characters of the message.
Next line contains the single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Then follow q lines with queries descriptions. The i-th of these lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the position of the left and right ends of the i-th substring respectively. Positions are numbered from 1. Substrings may overlap in any way. The same substring may appear in the input more than once.
Output
Print q lines. Each line should contain a single integer — the minimum possible length of the Huffman encoding of the substring ali... ari.
Example
Input
7
1 2 1 3 1 2 1
5
1 7
1 3
3 5
2 4
4 4
Output
10
3
3
5
0
Note
In the first query, one of the optimal ways to encode the substring is to map 1 to "0", 2 to "10" and 3 to "11".
Note that it is correct to map the letter to the empty substring (as in the fifth query from the sample).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
}
void et() {
puts("-1");
exit(0);
}
int SZ;
struct mb {
int l, r, id;
void rd(int i) {
scanf("%d%d", &l, &r);
l--;
r--;
id = i;
}
bool operator<(const mb &o) const {
if (l / SZ == o.l / SZ) {
return (l / SZ) & 1 ? r > o.r : r < o.r;
}
return l / SZ < o.l / SZ;
}
} q[100005];
int a[100005], cnt[100005], fre[100005], tfre[100005];
long long ans[100005];
vector<int> big;
void add(int val, int c) {
fre[cnt[val]]--;
cnt[val] += c;
fre[cnt[val]]++;
}
void fmain() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", a + i);
SZ = sqrt(n) * max(1, (int)log(n));
for (int(i) = 0; (i) < (int)(n); (i)++) {
cnt[a[i]]++;
if (cnt[a[i]] == SZ) big.push_back(a[i]);
}
memset(cnt, 0, sizeof cnt);
scanf("%d", &m);
for (int(i) = 1; (i) <= (int)(m); (i)++) q[i].rd(i);
sort(q, q + m);
int L = q[1].l, R = q[1].l - 1;
for (int(i) = 1; (i) <= (int)(m); (i)++) {
while (R < q[i].r) add(a[++R], 1);
while (L > q[i].l) add(a[--L], 1);
while (R > q[i].r) add(a[R--], -1);
while (L < q[i].l) add(a[L++], -1);
long long tmp = 0;
priority_queue<int, std::vector<int>, std::greater<int>> qu;
for (int b : big)
if (cnt[b] >= SZ) qu.push(cnt[b]);
int pre = -1;
for (int(j) = 0; (j) < (int)(SZ); (j)++) tfre[j] = fre[j];
for (int j = 1; j < SZ; j++)
if (tfre[j] > 0) {
if (pre != -1) {
tmp += pre + j;
tfre[j]--;
if (pre + j < SZ)
tfre[pre + j]++;
else
qu.push(pre + j);
pre = -1;
}
if (tfre[j] & 1) {
tfre[j]--;
pre = j;
}
tmp += tfre[j] * j;
if (j + j < SZ) {
tfre[j + j] += tfre[j] / 2;
} else {
for (int(z) = 0; (z) < (int)(tfre[j] / 2); (z)++) qu.push(j + j);
}
}
if (pre != -1) qu.push(pre);
while (qu.size() > 1) {
int x = qu.top();
qu.pop();
x += qu.top();
qu.pop();
tmp += x;
qu.push(x);
}
ans[q[i].id] = tmp;
}
for (int(i) = 1; (i) <= (int)(m); (i)++) printf("%lld\n", ans[i]);
}
int main() {
fmain();
return 0;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
Sig has built his own keyboard. Designed for ultimate simplicity, this keyboard only has 3 keys on it: the `0` key, the `1` key and the backspace key.
To begin with, he is using a plain text editor with this keyboard. This editor always displays one string (possibly empty). Just after the editor is launched, this string is empty. When each key on the keyboard is pressed, the following changes occur to the string:
* The `0` key: a letter `0` will be inserted to the right of the string.
* The `1` key: a letter `1` will be inserted to the right of the string.
* The backspace key: if the string is empty, nothing happens. Otherwise, the rightmost letter of the string is deleted.
Sig has launched the editor, and pressed these keys several times. You are given a string s, which is a record of his keystrokes in order. In this string, the letter `0` stands for the `0` key, the letter `1` stands for the `1` key and the letter `B` stands for the backspace key. What string is displayed in the editor now?
Constraints
* 1 ≦ |s| ≦ 10 (|s| denotes the length of s)
* s consists of the letters `0`, `1` and `B`.
* The correct answer is not an empty string.
Input
The input is given from Standard Input in the following format:
s
Output
Print the string displayed in the editor in the end.
Examples
Input
01B0
Output
00
Input
0BB1
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
string a;
string b("");
int i;
cin>>a;
for(i=0;i<a.size();i++){
if(a[i]=='B'){
if(b!=""){
b.erase(b.size()-1);
}
}else{
b=b+a[i];
}
}
cout<<b<<endl;
return 0;
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
### Response
```cpp
#include <bits/stdc++.h>
char s[1001][1001];
int main() {
int n, q, i, num[1001], sum = 0, k, j, max;
scanf("%d%d", &n, &q);
for (i = 0; i < n; i++) {
scanf("%s", &s[i]);
}
for (i = 0; i < q; i++) {
scanf("%d", &num[i]);
}
for (j = 0; j < q; j++) {
int a[10] = {0};
for (i = 0; i < n; i++) {
if (s[i][j] == 'A') {
a[1]++;
} else if (s[i][j] == 'B') {
a[2]++;
} else if (s[i][j] == 'C') {
a[3]++;
} else if (s[i][j] == 'D') {
a[4]++;
} else if (s[i][j] == 'E') {
a[5]++;
}
}
for (k = 1, max = 0; k <= 5; k++) {
if (a[k] > max) {
max = a[k];
}
}
sum += max * num[j];
}
printf("%d", sum);
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
Alice and Bob decided to eat some fruit. In the kitchen they found a large bag of oranges and apples. Alice immediately took an orange for herself, Bob took an apple. To make the process of sharing the remaining fruit more fun, the friends decided to play a game. They put multiple cards and on each one they wrote a letter, either 'A', or the letter 'B'. Then they began to remove the cards one by one from left to right, every time they removed a card with the letter 'A', Alice gave Bob all the fruits she had at that moment and took out of the bag as many apples and as many oranges as she had before. Thus the number of oranges and apples Alice had, did not change. If the card had written letter 'B', then Bob did the same, that is, he gave Alice all the fruit that he had, and took from the bag the same set of fruit. After the last card way removed, all the fruit in the bag were over.
You know how many oranges and apples was in the bag at first. Your task is to find any sequence of cards that Alice and Bob could have played with.
Input
The first line of the input contains two integers, x, y (1 ≤ x, y ≤ 1018, xy > 1) — the number of oranges and apples that were initially in the bag.
Output
Print any sequence of cards that would meet the problem conditions as a compressed string of characters 'A' and 'B. That means that you need to replace the segments of identical consecutive characters by the number of repetitions of the characters and the actual character. For example, string AAABAABBB should be replaced by string 3A1B2A3B, but cannot be replaced by 2A1A1B2A3B or by 3AB2A3B. See the samples for clarifications of the output format. The string that you print should consist of at most 106 characters. It is guaranteed that if the answer exists, its compressed representation exists, consisting of at most 106 characters. If there are several possible answers, you are allowed to print any of them.
If the sequence of cards that meet the problem statement does not not exist, print a single word Impossible.
Examples
Input
1 4
Output
3B
Input
2 2
Output
Impossible
Input
3 2
Output
1A1B
Note
In the first sample, if the row contained three cards with letter 'B', then Bob should give one apple to Alice three times. So, in the end of the game Alice has one orange and three apples, and Bob has one apple, in total it is one orange and four apples.
In second sample, there is no answer since one card is not enough for game to finish, and two cards will produce at least three apples or three oranges.
In the third sample, cards contain letters 'AB', so after removing the first card Bob has one orange and one apple, and after removal of second card Alice has two oranges and one apple. So, in total it is three oranges and two apples.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int mod = 1000000007;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
long long x, y;
void solve() {
scanf("%I64d%I64d", &x, &y);
if (gcd(x, y) != 1) {
printf("Impossible");
return;
}
bool flag = 1;
while (y != 0) {
long long d = x / y;
x %= y;
swap(x, y);
if (y == 0) d--;
if (d > 0) printf("%I64d%c", d, flag ? 'A' : 'B');
flag ^= 1;
}
}
int main() {
solve();
return 0;
}
```
|
### Prompt
Develop a solution in cpp to the problem described below:
Vasya's telephone contains n photos. Photo number 1 is currently opened on the phone. It is allowed to move left and right to the adjacent photo by swiping finger over the screen. If you swipe left from the first photo, you reach photo n. Similarly, by swiping right from the last photo you reach photo 1. It takes a seconds to swipe from photo to adjacent.
For each photo it is known which orientation is intended for it — horizontal or vertical. Phone is in the vertical orientation and can't be rotated. It takes b second to change orientation of the photo.
Vasya has T seconds to watch photos. He want to watch as many photos as possible. If Vasya opens the photo for the first time, he spends 1 second to notice all details in it. If photo is in the wrong orientation, he spends b seconds on rotating it before watching it. If Vasya has already opened the photo, he just skips it (so he doesn't spend any time for watching it or for changing its orientation). It is not allowed to skip unseen photos.
Help Vasya find the maximum number of photos he is able to watch during T seconds.
Input
The first line of the input contains 4 integers n, a, b, T (1 ≤ n ≤ 5·105, 1 ≤ a, b ≤ 1000, 1 ≤ T ≤ 109) — the number of photos, time to move from a photo to adjacent, time to change orientation of a photo and time Vasya can spend for watching photo.
Second line of the input contains a string of length n containing symbols 'w' and 'h'.
If the i-th position of a string contains 'w', then the photo i should be seen in the horizontal orientation.
If the i-th position of a string contains 'h', then the photo i should be seen in vertical orientation.
Output
Output the only integer, the maximum number of photos Vasya is able to watch during those T seconds.
Examples
Input
4 2 3 10
wwhw
Output
2
Input
5 2 4 13
hhwhh
Output
4
Input
5 2 4 1000
hhwhh
Output
5
Input
3 1 100 10
whw
Output
0
Note
In the first sample test you can rotate the first photo (3 seconds), watch the first photo (1 seconds), move left (2 second), rotate fourth photo (3 seconds), watch fourth photo (1 second). The whole process takes exactly 10 seconds.
Note that in the last sample test the time is not enough even to watch the first photo, also you can't skip it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a, b, T;
long long s[N];
char c[N];
bool check(int x) {
for (int i = 1; i <= x; i++) {
long long s1 = s[i] + s[n] - s[n + i - x];
long long s2 = min(a * (i + x - 2), a * (2 * x - i - 1));
if (s1 + s2 <= T) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d%d", &n, &a, &b, &T);
scanf("%s", c + 1);
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + 1;
if (c[i] == 'w') s[i] += b;
}
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d", l);
return 0;
}
```
|
### Prompt
Construct a cpp code solution to the problem outlined:
Draw a frame which has a height of H cm and a width of W cm. For example, the following figure shows a frame which has a height of 6 cm and a width of 10 cm.
........#
........#
........#
........#
Constraints
* 3 ≤ H ≤ 300
* 3 ≤ W ≤ 300
Input
The input consists of multiple datasets. Each dataset consists of two integers H and W separated by a single space.
The input ends with two 0 (when both H and W are zero).
Output
For each dataset, print the frame made of '#' and '.'.
Print a blank line after each dataset.
Example
Input
3 4
5 6
3 3
0 0
Output
####
#..#
####
######
#....#
#....#
#....#
######
###
#.#
###
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
while(true){
int h,w;
cin >> h >> w;
if(h==0)break;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(i==0 || i==h-1 || j==0 || j==w-1)cout << '#';
else cout << '.';
}
cout << endl;
}
cout << endl;
}
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
Given are a positive integer N and a string S of length N consisting of lowercase English letters.
Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.
Constraints
* 1 \leq N \leq 100
* S consists of lowercase English letters.
* |S| = N
Input
Input is given from Standard Input in the following format:
N
S
Output
If S is a concatenation of two copies of some string, print `Yes`; otherwise, print `No`.
Examples
Input
6
abcabc
Output
Yes
Input
6
abcadc
Output
No
Input
1
z
Output
No
### Response
```cpp
#include<cstdio>
int n;
char S[1010];
int main(){
scanf("%d",&n);
scanf("%s",S+1);
if(n%2==1)return puts("No"),0;
for(int i=1;i<=n/2;i++)
if(S[i]!=S[i+n/2])return puts("No"),0;
puts("Yes");
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
It's now 260 AD. Shapur, being extremely smart, became the King of Persia. He is now called Shapur, His majesty King of kings of Iran and Aniran.
Recently the Romans declared war on Persia. They dreamed to occupy Armenia. In the recent war, the Romans were badly defeated. Now their senior army general, Philip is captured by Shapur and Shapur is now going to capture Valerian, the Roman emperor.
Being defeated, the cowardly Valerian hid in a room at the top of one of his castles. To capture him, Shapur has to open many doors. Fortunately Valerian was too scared to make impenetrable locks for the doors.
Each door has 4 parts. The first part is an integer number a. The second part is either an integer number b or some really odd sign which looks like R. The third one is an integer c and the fourth part is empty! As if it was laid for writing something. Being extremely gifted, after opening the first few doors, Shapur found out the secret behind the locks.
c is an integer written in base a, to open the door we should write it in base b. The only bad news is that this R is some sort of special numbering system that is used only in Roman empire, so opening the doors is not just a piece of cake!
Here's an explanation of this really weird number system that even doesn't have zero:
Roman numerals are based on seven symbols: a stroke (identified with the letter I) for a unit, a chevron (identified with the letter V) for a five, a cross-stroke (identified with the letter X) for a ten, a C (identified as an abbreviation of Centum) for a hundred, etc.:
* I=1
* V=5
* X=10
* L=50
* C=100
* D=500
* M=1000
Symbols are iterated to produce multiples of the decimal (1, 10, 100, 1, 000) values, with V, L, D substituted for a multiple of five, and the iteration continuing: I 1, II 2, III 3, V 5, VI 6, VII 7, etc., and the same for other bases: X 10, XX 20, XXX 30, L 50, LXXX 80; CC 200, DCC 700, etc. At the fourth and ninth iteration, a subtractive principle must be employed, with the base placed before the higher base: IV 4, IX 9, XL 40, XC 90, CD 400, CM 900.
Also in bases greater than 10 we use A for 10, B for 11, etc.
Help Shapur capture Valerian and bring peace back to Persia, especially Armenia.
Input
The first line contains two integers a and b (2 ≤ a, b ≤ 25). Only b may be replaced by an R which indicates Roman numbering system.
The next line contains a single non-negative integer c in base a which may contain leading zeros but its length doesn't exceed 103.
It is guaranteed that if we have Roman numerals included the number would be less than or equal to 300010 and it won't be 0. In any other case the number won't be greater than 101510.
Output
Write a single line that contains integer c in base b. You must omit leading zeros.
Examples
Input
10 2
1
Output
1
Input
16 R
5
Output
V
Input
5 R
4
Output
IV
Input
2 2
1111001
Output
1111001
Input
12 13
A
Output
A
Note
You can find more information about roman numerals here: http://en.wikipedia.org/wiki/Roman_numerals
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char f(long long x) {
string s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
return s[x];
}
long long of(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
} else {
return c - 'A' + 10;
}
}
int main() {
ios::sync_with_stdio(false);
long long a;
string s;
cin >> a >> s;
string x;
cin >> x;
if (s == "R") {
vector<long long> st(x.length());
st[0] = 1;
for (long long i = 1; i < x.length(); i++) {
st[i] = st[i - 1] * a;
}
long long y = 0;
for (long long i = 0; i < x.length(); i++) {
y += of(x[i]) * st[x.length() - i - 1];
}
vector<char> res;
long long t = y / 1000;
y %= 1000;
for (long long i = 0; i < t; i++) {
res.push_back('M');
}
t = y / 100;
y %= 100;
if (t < 4) {
for (long long i = 0; i < t; i++) {
res.push_back('C');
}
} else if (t == 4) {
res.push_back('C');
res.push_back('D');
} else if (t == 5) {
res.push_back('D');
} else if (t < 9) {
res.push_back('D');
t -= 5;
for (long long i = 0; i < t; i++) {
res.push_back('C');
}
} else {
res.push_back('C');
res.push_back('M');
}
t = y / 10;
y %= 10;
if (t < 4) {
for (long long i = 0; i < t; i++) {
res.push_back('X');
}
} else if (t == 4) {
res.push_back('X');
res.push_back('L');
} else if (t == 5) {
res.push_back('L');
} else if (t < 9) {
res.push_back('L');
t -= 5;
for (long long i = 0; i < t; i++) {
res.push_back('X');
}
} else {
res.push_back('X');
res.push_back('C');
}
t = y;
if (t < 4) {
for (long long i = 0; i < t; i++) {
res.push_back('I');
}
} else if (t == 4) {
res.push_back('I');
res.push_back('V');
} else if (t == 5) {
res.push_back('V');
} else if (t < 9) {
res.push_back('V');
t -= 5;
for (long long i = 0; i < t; i++) {
res.push_back('I');
}
} else {
res.push_back('I');
res.push_back('X');
}
for (long long i = 0; i < res.size(); i++) {
cout << res[i];
}
} else {
long long b = 0;
for (long long i = 0; i < s.length(); i++) {
b *= 10;
b += s[i] - '0';
}
vector<long long> st(x.length());
st[0] = 1;
for (long long i = 1; i < x.length(); i++) {
st[i] = st[i - 1] * a;
}
long long y = 0;
for (long long i = 0; i < x.length(); i++) {
y += of(x[i]) * st[x.length() - i - 1];
}
vector<long long> res;
while (y) {
res.push_back(y % b);
y /= b;
}
reverse(res.begin(), res.end());
if (res.size() == 0) {
cout << 0;
return 0;
}
for (long long i = 0; i < res.size(); i++) {
cout << f(res[i]);
}
}
return 0;
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a directed graph with N vertices and M edges. The vertices are numbered 1, 2, ..., N, and the edges are numbered 1, 2, ..., M. Edge i points from Vertex a_i to Vertex b_i.
For each edge, determine whether the reversion of that edge would change the number of the strongly connected components in the graph.
Here, the reversion of Edge i means deleting Edge i and then adding a new edge that points from Vertex b_i to Vertex a_i.
Constraints
* 2 \leq N \leq 1000
* 1 \leq M \leq 200,000
* 1 \leq a_i, b_i \leq N
* a_i \neq b_i
* If i \neq j, then a_i \neq a_j or b_i \neq b_j.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
a_2 b_2
:
a_M b_M
Output
Print M lines. In the i-th line, if the reversion of Edge i would change the number of the strongly connected components in the graph, print `diff`; if it would not, print `same`.
Examples
Input
3 3
1 2
1 3
2 3
Output
same
diff
same
Input
2 2
1 2
2 1
Output
diff
diff
Input
5 9
3 2
3 1
4 1
4 2
3 5
5 3
3 4
1 2
2 5
Output
same
same
same
same
same
diff
diff
diff
diff
### Response
```cpp
#include <cstdio>
#include <algorithm>
#include <vector>
const int MN = 1005, MM = 200005;
int N, M, eu[MM], ev[MM], Ans[MM];
std::vector<int> G[MN];
bool vis[MN], rch[MN][MN]; int col[MN];
void DFS(int u, int c) {
vis[u] = 1, col[u] ^= c;
for (auto i : G[u]) if (!vis[ev[i]]) DFS(ev[i], c);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; ++i) {
scanf("%d%d", &eu[i], &ev[i]);
G[eu[i]].push_back(i);
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) vis[j] = 0;
DFS(i, 0);
for (int j = 1; j <= N; ++j) if (vis[j]) rch[i][j] = 1;
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) col[j] = vis[j] = 0; vis[i] = 1;
for (auto j : G[i]) if (!vis[ev[j]]) DFS(ev[j], ev[j]);
std::reverse(G[i].begin(), G[i].end());
for (int j = 1; j <= N; ++j) vis[j] = 0; vis[i] = 1;
for (auto j : G[i]) if (!vis[ev[j]]) DFS(ev[j], ev[j]);
for (auto j : G[i]) Ans[j] = rch[ev[j]][i] ^ !!col[ev[j]];
}
for (int i = 1; i <= M; ++i) puts(Ans[i] ? "diff" : "same");
return 0;
}
```
|
### Prompt
Your task is to create a CPP solution to the following problem:
E: Binary Sequence-Binary Sequence-
story
I love binaries Bonald.Brvin.Bnuth! He is known as Uncle Bnuth, who is studying the nature of binary sequences at Offtunford University! By the way, if my name "Bonald.Brvin.Bnuth" is binarized from ASCII code, it will be "1000010 1101111 1101110 1100001 1101100 1100100 101110 1000010 1110010 1110110 1101001 1101110 101110 1000010 1101110 1110101 1110100 1101000"! It's fun!
I'm looking forward to it from the morning because my disciples are going to do some interesting experiments today! What are you doing?
What! I want to discover some properties by continuing to rewrite binary strings! HM! This is the scent of an important discovery! Let's start the experiment! Let's summarize more detailed settings as sentences!
problem
Given a binary sequence of length n x = (x_1, ..., x_n) (x_i \ in \\ {0,1 \\}, i = 1, ..., n). For the binary string x, we define two functions f (x) and g (x) as follows.
f (x) = Σ_ {i = 1} ^ {n} x_i = x_1 + x_2 + ... + x_n
g (x) = Σ_ {i = 1} ^ {n-1} x_i x_ {i + 1} = x_1 x_2 + x_2 x_3 + ... x_ {n-1} x_n
Now, perform the following change operation on the binary string x q times. The jth change operation is given by l_j, r_j, b_j (1 \ leq l_j \ leq r_j \ leq n, b_j \ in \\ {0,1 \\}, j = 1, ..., q). This corresponds to the operation of replacing the l_jth to r_jths of the binary string x with b_j. Find f (x) --g (x) after each change operation.
Input format
n
x
q
l_1 r_1 b_1
...
l_q r_q b_q
The first line is given the integer n that represents the length of the binary column. The second line is given a string that represents the binary column x. The third line is given the integer q, which represents the number of queries. In the following q lines, the i-th line is given information about the i-th query l_i, r_i, b_i in this order, separated by blanks.
Constraint
* 2 \ leq n \ leq 100000
* x is a character string consisting of ‘0’ and ‘1’
* | x | = n
* 1 \ leq q \ leq 100000
* 1 \ leq l_j \ leq r_j \ leq n, b_j \ in \\ {0,1 \\}, j = 1, ..., q
Output format
For each i = 1, ..., q, output the value of f (x) --g (x) after processing the i-th query on the i-line.
Input example 1
Ten
0101100110
3
3 3 1
1 6 0
2 5 1
Output example 1
2
1
2
Input example 2
8
00111100
3
8 8 1
4 5 0
7 8 1
Output example 2
2
3
2
Example
Input
10
0101100110
3
3 3 1
1 6 0
2 5 1
Output
2
1
2
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
struct node{
int pc,g,l,r;
node(int a,int b,int c,int d):pc(a),g(b),l(c),r(d){}
node(){pc=g=l=r=-1;}
};
node e;
inline node add(const node &a,const node &b){
if(a.pc==-1)return b;
if(b.pc==-1)return a;
node c;
c.pc=a.pc+b.pc;
c.g=a.g+b.g+a.r*b.l;
c.l=a.l;
c.r=b.r;
return c;
}
struct segtree{
static const int SEG=1<<17;
vector<node>dat;
vector<int>put;
segtree(string &s):dat(SEG*2),put(SEG*2,-1){
for(int i=0;i<s.size();i++){
node d;
int a=s[i]-'0';
d.pc=a;
d.g=0;
d.l=d.r=a;
dat[i+SEG-1]=d;
}
for(int i=SEG-2;i>=0;i--){
dat[i]=add(dat[i*2+1],dat[i*2+2]);
}
}
inline void push(int k,int l,int r){
if(put[k]==-1)return;
dat[k].pc=(r-l)*put[k];
dat[k].g=(r-l-1)*put[k];
dat[k].l=dat[k].r=put[k];
if(k<SEG-1){
put[k*2+1]=put[k*2+2]=put[k];
}
put[k]=-1;
}
void update(int a,int b,int x,int k=0,int l=0,int r=SEG){
push(k,l,r);
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
put[k]=x;
push(k,l,r);
return;
}
update(a,b,x,k*2+1,l,(l+r)/2);
update(a,b,x,k*2+2,(l+r)/2,r);
dat[k]=add(dat[k*2+1],dat[k*2+2]);
}
node query(int a,int b,int k=0,int l=0,int r=SEG){
push(k,l,r);
if(r<=a||b<=l)return e;
if(a<=l&&r<=b)return dat[k];
return add(query(a,b,k*2+1,l,(l+r)/2),query(a,b,k*2+2,(l+r)/2,r));
}
};
signed main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
int N;
string S;
cin>>N>>S;
segtree seg(S);
int Q;cin>>Q;
while(Q--){
int l,r,b;
cin>>l>>r>>b;
l--;
seg.update(l,r,b);
node d=seg.query(0,N);
cout<<d.pc-d.g<<endl;
}
return 0;
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
Programmer Sasha is a student at MIPT (Moscow Institute of Physics and Technology) and he needs to make a laboratory work to pass his finals.
A laboratory unit is a plane with standard coordinate axes marked on it. Physicists from Moscow Institute of Physics and Technology charged the axes by large electric charges: axis X is positive and axis Y is negative.
Experienced laboratory worker marked n points with integer coordinates (xi, yi) on the plane and stopped the time. Sasha should use "atomic tweezers" to place elementary particles in these points. He has an unlimited number of electrons (negatively charged elementary particles) and protons (positively charged elementary particles). He can put either an electron or a proton at each marked point. As soon as all marked points are filled with particles, laboratory worker will turn on the time again and the particles will come in motion and after some time they will stabilize in equilibrium. The objective of the laboratory work is to arrange the particles in such a way, that the diameter of the resulting state (the maximum distance between the pairs of points of the set) is as small as possible.
Since Sasha is a programmer, he naively thinks that all the particles will simply "fall" into their projections on the corresponding axes: electrons will fall on axis X, while protons will fall on axis Y. As we are programmers too, we will consider the same model as Sasha. That is, a particle gets from point (x, y) to point (x, 0) if it is an electron and to point (0, y) if it is a proton.
As the laboratory has high background radiation and Sasha takes care of his laptop, he did not take it with him, and now he can't write a program that computes the minimum possible diameter of the resulting set. Therefore, you will have to do it for him.
Print a square of the minimum possible diameter of the set.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of points marked on the plane.
Each of the next n lines contains two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — the coordinates of the i-th point. It is guaranteed that no two points coincide.
Output
Print a single integer — the square of the minimum possible diameter of the set.
Examples
Input
3
1 10
1 20
1 30
Output
0
Input
2
1 10
10 1
Output
2
Note
In the first sample Sasha puts electrons at all points, all particles eventually fall at a single point (1, 0).
In the second sample Sasha puts an electron at point (1, 10), and a proton at point (10, 1). The result is a set of two points (1, 0) and (0, 1), which has a diameter of <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 200000000;
struct punct {
int x, y;
bool operator<(const punct &aux) const { return x < aux.x; }
} v[100010];
int vmax[100010], vmin[100010], n;
long long solve() {
long long st = 0, dr = 1LL * inf * inf;
while (st <= dr) {
long long mid = (st + dr) / 2;
int maxx = -inf, minn = inf, ok = 0;
for (int i = 1, j = 1; j <= n; j++) {
while (1LL * (v[j].x - v[i].x) * (v[j].x - v[i].x) > mid) {
maxx = max(maxx, v[i].y);
minn = min(minn, v[i].y);
i++;
}
int a = max(maxx, vmax[j + 1]), b = min(minn, vmin[j + 1]);
if (a < b) {
ok = 1;
break;
}
if (1LL * (a - b) * (a - b) > mid) continue;
if (1LL * a * a + 1LL * v[i].x * v[i].x > mid) continue;
if (1LL * a * a + 1LL * v[j].x * v[j].x > mid) continue;
if (1LL * b * b + 1LL * v[i].x * v[i].x > mid) continue;
if (1LL * b * b + 1LL * v[j].x * v[j].x > mid) continue;
ok = 1;
break;
}
if (ok)
dr = mid - 1;
else
st = mid + 1;
}
return st;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &v[i].x, &v[i].y);
sort(v + 1, v + 1 + n);
vmax[n + 1] = -inf;
vmin[n + 1] = inf;
for (int i = n; i; i--) {
vmax[i] = max(vmax[i + 1], v[i].y);
vmin[i] = min(vmin[i + 1], v[i].y);
}
long long sol = min(1LL * (v[n].x - v[1].x) * (v[n].x - v[1].x),
1LL * (vmax[1] - vmin[1]) * (vmax[1] - vmin[1]));
sol = min(sol, solve());
for (int i = 1; i <= n; i++) swap(v[i].x, v[i].y);
sort(v + 1, v + 1 + n);
vmax[n + 1] = -inf;
vmin[n + 1] = inf;
for (int i = n; i; i--) {
vmax[i] = max(vmax[i + 1], v[i].y);
vmin[i] = min(vmin[i + 1], v[i].y);
}
sol = min(sol, solve());
printf("%I64d", sol);
return 0;
}
```
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Let's define a function f(x) (x is a positive integer) as follows: write all digits of the decimal representation of x backwards, then get rid of the leading zeroes. For example, f(321) = 123, f(120) = 21, f(1000000) = 1, f(111) = 111.
Let's define another function g(x) = (x)/(f(f(x))) (x is a positive integer as well).
Your task is the following: for the given positive integer n, calculate the number of different values of g(x) among all numbers x such that 1 ≤ x ≤ n.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Each test case consists of one line containing one integer n (1 ≤ n < 10^{100}). This integer is given without leading zeroes.
Output
For each test case, print one integer — the number of different values of the function g(x), if x can be any integer from [1, n].
Example
Input
5
4
37
998244353
1000000007
12345678901337426966631415
Output
1
2
9
10
26
Note
Explanations for the two first test cases of the example:
1. if n = 4, then for every integer x such that 1 ≤ x ≤ n, (x)/(f(f(x))) = 1;
2. if n = 37, then for some integers x such that 1 ≤ x ≤ n, (x)/(f(f(x))) = 1 (for example, if x = 23, f(f(x)) = 23,(x)/(f(f(x))) = 1); and for other values of x, (x)/(f(f(x))) = 10 (for example, if x = 30, f(f(x)) = 3, (x)/(f(f(x))) = 10). So, there are two different values of g(x).
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll t;
cin>>t;
while(t--){
string s;
cin>>s;
cout<<s.size()<<endl;
}
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
There are n students who have taken part in an olympiad. Now it's time to award the students.
Some of them will receive diplomas, some wiil get certificates, and others won't receive anything. Students with diplomas and certificates are called winners. But there are some rules of counting the number of diplomas and certificates. The number of certificates must be exactly k times greater than the number of diplomas. The number of winners must not be greater than half of the number of all students (i.e. not be greater than half of n). It's possible that there are no winners.
You have to identify the maximum possible number of winners, according to these rules. Also for this case you have to calculate the number of students with diplomas, the number of students with certificates and the number of students who are not winners.
Input
The first (and the only) line of input contains two integers n and k (1 ≤ n, k ≤ 1012), where n is the number of students and k is the ratio between the number of certificates and the number of diplomas.
Output
Output three numbers: the number of students with diplomas, the number of students with certificates and the number of students who are not winners in case when the number of winners is maximum possible.
It's possible that there are no winners.
Examples
Input
18 2
Output
3 6 9
Input
9 10
Output
0 0 9
Input
1000000000000 5
Output
83333333333 416666666665 500000000002
Input
1000000000000 499999999999
Output
1 499999999999 500000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, h;
int main() {
cin >> n >> k;
if (k >= n / 2)
cout << "0 0 " << n;
else if (k == (n / 2 - 1))
cout << 1 << " " << k << " " << n - (k + 1);
else if (k < n / 2) {
h = n / 2;
if (h % (k + 1) != 0) {
h -= h % (k + 1);
}
cout << h / (k + 1) << " " << k * (h / (k + 1)) << " " << n - h;
}
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
For two permutations p and q of the integers from 1 through N, let f(p,q) be the permutation that satisfies the following:
* The p_i-th element (1 \leq i \leq N) in f(p,q) is q_i. Here, p_i and q_i respectively denote the i-th element in p and q.
You are given two permutations p and q of the integers from 1 through N. We will now define a sequence {a_n} of permutations of the integers from 1 through N, as follows:
* a_1=p, a_2=q
* a_{n+2}=f(a_n,a_{n+1}) ( n \geq 1 )
Given a positive integer K, find a_K.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq K \leq 10^9
* p and q are permutations of the integers from 1 through N.
Input
Input is given from Standard Input in the following format:
N K
p_1 ... p_N
q_1 ... q_N
Output
Print N integers, with spaces in between. The i-th integer (1 \leq i \leq N) should be the i-th element in a_K.
Examples
Input
3 3
1 2 3
3 2 1
Output
3 2 1
Input
5 5
4 5 1 2 3
3 2 1 5 4
Output
4 3 2 1 5
Input
10 1000000000
7 10 6 5 4 2 9 1 3 8
4 1 9 2 3 7 8 10 6 5
Output
7 9 4 8 2 5 1 6 10 3
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
vector<int> inv(const vector<int>& p){
vector<int> res(p.size());
for(int i=0;i<p.size();i++) res[p[i]] = i;
return res;
}
vector<int> mul(const vector<int>& p, const vector<int>& q){
vector<int> res(p.size());
for(int i=0;i<p.size();i++) res[i] = p[q[i]];
return res;
}
vector<int> pow(const vector<int>& p, int K){
const int N = p.size();
if(K == 0){
vector<int> res(N);
for(int i=0;i<N;i++) res[i] = i;
return res;
}
auto res = pow(p, K/2);
res = mul(res, res);
if(K%2 == 1) res = mul(res, p);
return res;
}
int main(){
int N, K; cin >> N >> K;
vector<int> p(N), q(N);
for(auto& t : p){ cin >> t; --t; }
for(auto& t : q){ cin >> t; --t; }
auto pInv = inv(p);
auto qInv = inv(q);
auto r = mul(mul(mul(q, pInv), qInv), p);
r = pow(r, (K-1)/6);
auto rInv = inv(r);
auto cur = mul(mul(r, p), rInv);
auto next = mul(mul(r, q), rInv);
int k = (K-1)/6*6+1;
while(k < K){
auto tmp = next;
next = mul(next, inv(cur));
cur = tmp;
++k;
}
for(auto& t : cur) cout << t+1 << " ";
cout << endl;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
Alice and Bob are going to celebrate Christmas by playing a game with a tree of presents. The tree has n nodes (numbered 1 to n, with some node r as its root). There are a_i presents are hanging from the i-th node.
Before beginning the game, a special integer k is chosen. The game proceeds as follows:
* Alice begins the game, with moves alternating each turn;
* in any move, the current player may choose some node (for example, i) which has depth at least k. Then, the player picks some positive number of presents hanging from that node, let's call it m (1 ≤ m ≤ a_i);
* the player then places these m presents on the k-th ancestor (let's call it j) of the i-th node (the k-th ancestor of vertex i is a vertex j such that i is a descendant of j, and the difference between the depth of j and the depth of i is exactly k). Now, the number of presents of the i-th node (a_i) is decreased by m, and, correspondingly, a_j is increased by m;
* Alice and Bob both play optimally. The player unable to make a move loses the game.
For each possible root of the tree, find who among Alice or Bob wins the game.
Note: The depth of a node i in a tree with root r is defined as the number of edges on the simple path from node r to node i. The depth of root r itself is zero.
Input
The first line contains two space-separated integers n and k (3 ≤ n ≤ 10^5, 1 ≤ k ≤ 20).
The next n-1 lines each contain two integers x and y (1 ≤ x, y ≤ n, x ≠ y), denoting an undirected edge between the two nodes x and y. These edges form a tree of n nodes.
The next line contains n space-separated integers denoting the array a (0 ≤ a_i ≤ 10^9).
Output
Output n integers, where the i-th integer is 1 if Alice wins the game when the tree is rooted at node i, or 0 otherwise.
Example
Input
5 1
1 2
1 3
5 2
4 3
0 3 2 4 4
Output
1 0 0 1 1
Note
Let us calculate the answer for sample input with root node as 1 and as 2.
Root node 1
Alice always wins in this case. One possible gameplay between Alice and Bob is:
* Alice moves one present from node 4 to node 3.
* Bob moves four presents from node 5 to node 2.
* Alice moves four presents from node 2 to node 1.
* Bob moves three presents from node 2 to node 1.
* Alice moves three presents from node 3 to node 1.
* Bob moves three presents from node 4 to node 3.
* Alice moves three presents from node 3 to node 1.
Bob is now unable to make a move and hence loses.
Root node 2
Bob always wins in this case. One such gameplay is:
* Alice moves four presents from node 4 to node 3.
* Bob moves four presents from node 5 to node 2.
* Alice moves six presents from node 3 to node 1.
* Bob moves six presents from node 1 to node 2.
Alice is now unable to make a move and hence loses.
### Response
```cpp
using namespace std;
#include <iostream>
#include <vector>
#define MAXN 100005
#define MAXK 45
int N,K,K2,dp[MAXN][MAXK],parent[MAXN];
vector<int> edges[MAXN];
void dfs(int v) {
for(int u : edges[v]) {
if(u == parent[v]) continue;
parent[u] = v;
dfs(u);
for(int i = 0;i < K2;++i) {
dp[v][(i + 1) % K2] ^= dp[u][i];
}
}
return;
}
void dfs2(int v) {
for(int u : edges[v]) {
if(u == parent[v]) continue;
int tmp[MAXK];
for(int i = 0;i < K2;++i) {
tmp[i] = dp[u][i];
}
for(int i = 0;i < K2;++i) {
dp[u][(i + 2) % K2] ^= tmp[i] ^ dp[v][(i + 1) % K2];
}
dfs2(u);
}
return;
}
int main() {
cin >> N >> K;
K2 = 2 * K;
for(int i = 0;i < N - 1;++i) {
int a,b;
cin >> a >> b;
a--;b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
for(int i = 0;i < N;++i) {
cin >> dp[i][0];
}
dfs(0);
dfs2(0);
for(int i = 0;i < N;++i) {
int cur = 0;
for(int j = K;j < K2;++j) {
cur ^= dp[i][j];
}
cout << !!cur << " ";
}
cout << endl;
return 0;
}
```
|
### Prompt
Generate a CPP solution to the following problem:
In computer science, there is a method called "Divide And Conquer By Node" to solve some hard problems about paths on a tree. Let's desribe how this method works by function:
solve(t) (t is a tree):
1. Chose a node x (it's common to chose weight-center) in tree t. Let's call this step "Line A".
2. Deal with all paths that pass x.
3. Then delete x from tree t.
4. After that t becomes some subtrees.
5. Apply solve on each subtree.
This ends when t has only one node because after deleting it, there's nothing.
Now, WJMZBMR has mistakenly believed that it's ok to chose any node in "Line A". So he'll chose a node at random. To make the situation worse, he thinks a "tree" should have the same number of edges and nodes! So this procedure becomes like that.
Let's define the variable totalCost. Initially the value of totalCost equal to 0. So, solve(t) (now t is a graph):
1. totalCost = totalCost + (size of t). The operation "=" means assignment. (Size of t) means the number of nodes in t.
2. Choose a node x in graph t at random (uniformly among all nodes of t).
3. Then delete x from graph t.
4. After that t becomes some connected components.
5. Apply solve on each component.
He'll apply solve on a connected graph with n nodes and n edges. He thinks it will work quickly, but it's very slow. So he wants to know the expectation of totalCost of this procedure. Can you help him?
Input
The first line contains an integer n (3 ≤ n ≤ 3000) — the number of nodes and edges in the graph. Each of the next n lines contains two space-separated integers ai, bi (0 ≤ ai, bi ≤ n - 1) indicating an edge between nodes ai and bi.
Consider that the graph nodes are numbered from 0 to (n - 1). It's guaranteed that there are no self-loops, no multiple edges in that graph. It's guaranteed that the graph is connected.
Output
Print a single real number — the expectation of totalCost. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
5
3 4
2 3
2 4
0 4
1 2
Output
13.166666666666666
Input
3
0 1
1 2
0 2
Output
6.000000000000000
Input
5
0 1
1 2
2 0
3 0
4 1
Output
13.166666666666666
Note
Consider the second example. No matter what we choose first, the totalCost will always be 3 + 2 + 1 = 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int vis[3010];
vector<int> ne[3010];
int n, siz;
int du[3010];
queue<int> q;
double ans;
void dfs(int u, int siza, int sizb, int top) {
if (du[u] == 2)
sizb++;
else
siza++;
vis[u] = top;
if (sizb == siz)
ans += 1.0 / (siza + 2);
else if (sizb <= 2)
ans += 1.0 / (siza + sizb);
else
ans += 1.0 / (siza + sizb) + 1.0 / (siza + siz - sizb + 2) -
1.0 / (siza + siz);
for (int v : ne[u])
if (vis[v] != top) dfs(v, siza, sizb, top);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
ne[x].push_back(y);
ne[y].push_back(x);
du[x]++, du[y]++;
}
for (int i = 1; i <= n; i++)
if (du[i] == 1) q.push(i);
while (q.size()) {
int u = q.front();
q.pop();
for (int v : ne[u])
if ((--du[v]) == 1) q.push(v);
}
for (int i = 1; i <= n; i++)
if (du[i] == 2) siz++;
for (int i = 1; i <= n; i++) dfs(i, 0, 0, i);
printf("%.10f\n", ans);
}
```
|
### Prompt
Generate a cpp solution to the following problem:
In Berland the opposition is going to arrange mass walking on the boulevard. The boulevard consists of n tiles that are lain in a row and are numbered from 1 to n from right to left. The opposition should start walking on the tile number 1 and the finish on the tile number n. During the walk it is allowed to move from right to left between adjacent tiles in a row, and jump over a tile. More formally, if you are standing on the tile number i (i < n - 1), you can reach the tiles number i + 1 or the tile number i + 2 from it (if you stand on the tile number n - 1, you can only reach tile number n). We can assume that all the opposition movements occur instantaneously.
In order to thwart an opposition rally, the Berland bloody regime organized the rain. The tiles on the boulevard are of poor quality and they are rapidly destroyed in the rain. We know that the i-th tile is destroyed after ai days of rain (on day ai tile isn't destroyed yet, and on day ai + 1 it is already destroyed). Of course, no one is allowed to walk on the destroyed tiles! So the walk of the opposition is considered thwarted, if either the tile number 1 is broken, or the tile number n is broken, or it is impossible to reach the tile number n from the tile number 1 if we can walk on undestroyed tiles.
The opposition wants to gather more supporters for their walk. Therefore, the more time they have to pack, the better. Help the opposition to calculate how much time they still have and tell us for how many days the walk from the tile number 1 to the tile number n will be possible.
Input
The first line contains integer n (1 ≤ n ≤ 103) — the boulevard's length in tiles.
The second line contains n space-separated integers ai — the number of days after which the i-th tile gets destroyed (1 ≤ ai ≤ 103).
Output
Print a single number — the sought number of days.
Examples
Input
4
10 3 5 10
Output
5
Input
5
10 2 8 3 5
Output
5
Note
In the first sample the second tile gets destroyed after day three, and the only path left is 1 → 3 → 4. After day five there is a two-tile gap between the first and the last tile, you can't jump over it.
In the second sample path 1 → 3 → 5 is available up to day five, inclusive. On day six the last tile is destroyed and the walk is thwarted.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void in(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
}
void out(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
unsigned long long int expmod(long long int a, long long int n,
long long int M) {
if (n == 0) return 1;
if (n == 1) return a;
unsigned long long int temp = expmod(a, n / 2, M);
if (n % 2 == 0)
return ((temp) * (temp)) % M;
else
return (a * (temp) * (temp)) % M;
}
int main() {
fast();
int tc = 1;
while (tc--) {
long long int n;
cin >> n;
long long int a[n];
in(a, n);
long long int d = a[0];
for (long long int i = 0; i < n - 2;) {
if (a[i + 1] < a[i + 2]) {
d = min(a[i + 2], d);
i++;
i++;
} else {
d = min(a[i + 1], d);
i++;
}
}
cout << min(a[0], min(a[n - 1], d)) << "\n";
}
return 0;
}
```
|
### Prompt
Construct a Cpp code solution to the problem outlined:
We have a grid with N rows and N columns. The cell at the i-th row and j-th column is denoted (i, j).
Initially, M of the cells are painted black, and all other cells are white. Specifically, the cells (a_1, b_1), (a_2, b_2), ..., (a_M, b_M) are painted black.
Snuke will try to paint as many white cells black as possible, according to the following rule:
* If two cells (x, y) and (y, z) are both black and a cell (z, x) is white for integers 1≤x,y,z≤N, paint the cell (z, x) black.
Find the number of black cells when no more white cells can be painted black.
Constraints
* 1≤N≤10^5
* 1≤M≤10^5
* 1≤a_i,b_i≤N
* All pairs (a_i, b_i) are distinct.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
a_2 b_2
:
a_M b_M
Output
Print the number of black cells when no more white cells can be painted black.
Examples
Input
3 2
1 2
2 3
Output
3
Input
2 2
1 1
1 2
Output
4
Input
4 3
1 2
1 3
4 4
Output
3
### Response
```cpp
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<queue>
#define LL long long
using namespace std;
inline int read( )
{
int sum=0;char c=getchar( );bool f=0;
while(c<'0'||c>'9') {if(c=='-') f=1;c=getchar( );}
while(c>='0'&&c<='9') {sum=sum*10+c-'0';c=getchar( );}
if(f) return -sum;
return sum;
}
const int N=100005;
int n,m;
struct ex{int num,next,w;}map[N*2];
int head[N],col[N],len;
inline void link(int x,int y)
{
len++;map[len]=(ex){y,head[x],1};head[x]=len;
len++;map[len]=(ex){x,head[y],2};head[y]=len;
}
bool vis[N],NO;int num[3],tot,bot;
inline void dfs(int k)
{
vis[k]=1;num[col[k]]++;tot++;
int i,x,u=col[k],y;
for(i=head[k];i;i=map[i].next)
{
x=map[i].num;bot++;
y=(u+map[i].w)%3;
if(vis[x]) NO|=(col[x]!=y);
else col[x]=y,dfs(x);
}
}
int main( )
{
int i,x,y;LL ans=0;
n=read( );m=read( );
for(i=1;i<=m;i++) x=read( ),y=read( ),link(x,y);
for(i=1;i<=n;i++)
{
if(vis[i]) continue;
num[0]=num[1]=num[2]=0;
NO=0;tot=0;bot=0;dfs(i);
if(NO) ans+=1LL*tot*tot;
else if(num[0]&&num[1]&&num[2]) ans+=1LL*num[0]*num[1]+1LL*num[1]*num[2]+1LL*num[2]*num[0];
else ans+=bot>>1;
}
printf("%lld",ans);
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
Example
Input
ACM
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
pair<string, string> split(const string &s) {
int p = s.find('=');
string l = s.substr(0, p);
string r = s.substr(p + 1);
return make_pair(l, r);
}
bool check(const string &s) {
int p = s.find('=');
if(p == -1) return false;
pair<string, string> sp = split(s);
if(sp.first.size() == 0 || sp.second.size() == 0) return false;
int k = 0;
for(char c : sp.first) {
if(c == '(') ++k;
if(c == ')') --k;
if(k < 0) return false;
}
if(k != 0) return false;
for(char c : sp.second) {
if(c == '(') ++k;
if(c == ')') --k;
if(k < 0) return false;
}
return true;
}
typedef string::const_iterator iter;
struct Result {
bool valid;
int value;
Result(bool valid_, int value_) : valid(valid_), value(value_) {}
};
Result fail(false, 114514);
bool Q(iter &p);
Result E(iter &p);
Result T(iter &p);
Result F(iter &p);
Result N(iter &p);
Result B(iter &p);
bool Q(iter &p) {
Result l = E(p);
// if(!l.valid) {
// cerr << "l = No" << endl;
// }
// else {
// cerr << "l = " << l.value << endl;
// }
if(!l.valid) return false;
if(*p != '=') return false;
++p;
Result r = E(p);
// if(!l.valid) {
// cerr << "r = No" << endl;
// }
// else {
// cerr << "r = " << r.value << endl;
// }
if(!r.valid) return false;
if(*p != '\0') return false;
return l.value == r.value;
}
Result E(iter &p) {
Result t = T(p);
if(!t.valid) return fail;
while(true) {
if(*p == '+') {
++p;
Result s = T(p);
if(!s.valid) return fail;
t.value += s.value;
}
else if(*p == '-') {
++p;
Result s = T(p);
if(!s.valid) return fail;
t.value -= s.value;
}
else {
break;
}
}
return t;
}
Result T(iter &p) {
Result t = F(p);
if(!t.valid) return fail;
while(true) {
if(*p == '*') {
++p;
Result s = F(p);
if(!s.valid) return fail;
t.value *= s.value;
}
else {
break;
}
}
return t;
}
Result F(iter &p) {
if(*p == '(') {
++p;
Result e = E(p);
if(*p != ')') {
return fail;
}
++p;
return e;
}
else if(*p == '-') {
++p;
Result e = F(p);
if(!e.valid) return fail;
e.value *= -1;
return e;
}
return N(p);
}
Result N(iter &p) {
if(!isdigit(*p)) {
return fail;
}
int n = 0;
int i = 0;
while(isdigit(*p)) {
n *= 2;
if(i > 0 && n == 0) return fail;
n += *p - '0';
++p;
++i;
}
// DEBUG(n);
return Result(true, n);
}
void dbg() {
string S; cin >> S;
iter p = S.cbegin();
bool r = Q(p);
cout << (r ? "Yes" : "No") << endl;
}
signed main() {
ios::sync_with_stdio(false);
if(false) {
dbg();
}
else {
string S; cin >> S;
vector<char> ch;
string ops = "01+-*=()";
sort(ops.begin(), ops.end());
REP(i,S.size()) {
if(ops.find(S[i]) == string::npos) {
ch.push_back(S[i]);
}
}
sort(ch.begin(), ch.end());
ch.erase(unique(ch.begin(), ch.end()), ch.end());
if(ch.size() > 8) {
cout << 0 << endl;
return 0;
}
map<char, int> replacer;
REP(i,ch.size()) {
replacer[ch[i]] = i;
// DEBUG(ch[i]);
}
set<string> ans;
do {
string T = S;
REP(i,T.size()) {
if(replacer.count(T[i])) T[i] = ops[replacer[T[i]]];
}
// if(T == "-0=(0)") DEBUG(T);
iter p = T.cbegin();
bool r = Q(p);
if(r) {
ans.insert(ops.substr(0,ch.size()));
// DEBUG(T);
}
} while(next_permutation(ops.begin(), ops.end()));
cout << ans.size() << endl;
}
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
Vasya used to be an accountant before the war began and he is one of the few who knows how to operate a computer, so he was assigned as the programmer.
We all know that programs often store sets of integers. For example, if we have a problem about a weighted directed graph, its edge can be represented by three integers: the number of the starting vertex, the number of the final vertex and the edge's weight. So, as Vasya was trying to represent characteristics of a recently invented robot in his program, he faced the following problem.
Vasya is not a programmer, so he asked his friend Gena, what the convenient way to store n integers is. Gena used to code in language X-- and so he can use only the types that occur in this language. Let's define, what a "type" is in language X--:
* First, a type is a string "int".
* Second, a type is a string that starts with "pair", then followed by angle brackets listing exactly two comma-separated other types of language X--. This record contains no spaces.
* No other strings can be regarded as types.
More formally: type := int | pair<type,type>. For example, Gena uses the following type for graph edges: pair<int,pair<int,int>>.
Gena was pleased to help Vasya, he dictated to Vasya a type of language X--, that stores n integers. Unfortunately, Gena was in a hurry, so he omitted the punctuation. Now Gena has already left and Vasya can't find the correct punctuation, resulting in a type of language X--, however hard he tries.
Help Vasya and add the punctuation marks so as to receive the valid type of language X--. Otherwise say that the task is impossible to perform.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), showing how many numbers the type dictated by Gena contains.
The second line contains space-separated words, said by Gena. Each of them is either "pair" or "int" (without the quotes).
It is guaranteed that the total number of words does not exceed 105 and that among all the words that Gena said, there are exactly n words "int".
Output
If it is possible to add the punctuation marks so as to get a correct type of language X-- as a result, print a single line that represents the resulting type. Otherwise, print "Error occurred" (without the quotes). Inside the record of a type should not be any extra spaces and other characters.
It is guaranteed that if such type exists, then it is unique.
Note that you should print the type dictated by Gena (if such type exists) and not any type that can contain n values.
Examples
Input
3
pair pair int int int
Output
pair<pair<int,int>,int>
Input
1
pair int
Output
Error occurred
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename A>
string to_string(A* ptr) {
stringstream ss;
ss << "0x" << std::setw(16) << std::setfill('0') << std::hex
<< (uint64_t)(uintptr_t)ptr;
return ss.str();
}
string to_string(char c) { return ((string) "'" + c) + "'"; }
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const string PAIR = "pair";
const string INT = "int";
const string ERR = "Error occurred";
string solve(int n, vector<string> v) {
stringstream res;
int sz = (int)v.size();
vector<int> ST;
for (int idx = 0; idx < sz; idx++) {
42;
const string& s = v[idx];
assert(s == PAIR || s == INT);
if (s == PAIR) {
ST.push_back(0);
res << PAIR << '<';
} else {
res << INT;
while (true) {
if (ST.empty()) {
if (idx == sz - 1)
break;
else
return ERR;
}
ST.back() += 1;
assert(ST.back() == 1 || ST.back() == 2);
if (ST.back() == 1) {
res << ',';
break;
} else {
res << '>';
ST.pop_back();
}
}
if (ST.empty() && idx != sz - 1) return ERR;
}
}
if (!ST.empty()) return ERR;
return res.str();
}
int main() {
int TTT = 1;
for (int ttt = 0; ttt < TTT; ttt++) {
int n;
cin >> n;
vector<string> v;
string s;
while (cin >> s) {
v.push_back(s);
}
42;
42;
cout << solve(n, v);
}
return 0;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
In this problem you will meet the simplified model of game Pudding Monsters.
An important process in developing any game is creating levels. A game field in Pudding Monsters is an n × n rectangular grid, n of its cells contain monsters and some other cells contain game objects. The gameplay is about moving the monsters around the field. When two monsters are touching each other, they glue together into a single big one (as they are from pudding, remember?).
<image>
Statistics showed that the most interesting maps appear if initially each row and each column contains exactly one monster and the rest of map specifics is set up by the correct positioning of the other game objects.
A technique that's widely used to make the development process more efficient is reusing the available resources. For example, if there is a large n × n map, you can choose in it a smaller k × k square part, containing exactly k monsters and suggest it as a simplified version of the original map.
You wonder how many ways there are to choose in the initial map a k × k (1 ≤ k ≤ n) square fragment, containing exactly k pudding monsters. Calculate this number.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 × 105) — the size of the initial field.
Next n lines contain the coordinates of the cells initially containing monsters. The i-th of the next lines contains two numbers ri, ci (1 ≤ ri, ci ≤ n) — the row number and the column number of the cell that initially contains the i-th monster.
It is guaranteed that all ri are distinct numbers and all ci are distinct numbers.
Output
Print the number of distinct square fragments of the original field that can form a new map.
Examples
Input
5
1 1
4 3
3 2
2 4
5 5
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, a[N];
int lmx[N], lmn[N], rmx[N], rmn[N];
int cnt[N << 1];
long long ovo(int l, int r) {
if (l == r) return 1;
int mid = l + r >> 1;
long long ret = ovo(l, mid) + ovo(mid + 1, r);
lmx[mid] = lmn[mid] = a[mid];
for (int i = mid - 1; i >= l; --i) {
lmx[i] = max(lmx[i + 1], a[i]);
lmn[i] = min(lmn[i + 1], a[i]);
}
rmx[mid + 1] = rmn[mid + 1] = a[mid + 1];
for (int i = mid + 2; i <= r; ++i) {
rmx[i] = max(rmx[i - 1], a[i]);
rmn[i] = min(rmn[i - 1], a[i]);
}
for (int i = l, j; i <= mid; ++i) {
j = i + lmx[i] - lmn[i];
if (j > mid && j <= r)
if (rmx[j] < lmx[i] && rmn[j] > lmn[i]) ++ret;
}
for (int i = mid + 1, j; i <= r; ++i) {
j = i - rmx[i] + rmn[i];
if (j <= mid && j >= l)
if (lmx[j] < rmx[i] && lmn[j] > rmn[i]) ++ret;
}
for (int i = mid, u = mid, v = mid + 1; i >= l; --i) {
for (; u < r && rmn[u + 1] > lmn[i]; ++u) ++cnt[rmx[u + 1] - (u + 1) + N];
for (; v <= min(u, r) && rmx[v] < lmx[i]; ++v) --cnt[rmx[v] - v + N];
ret += max(0, cnt[lmn[i] - i + N]);
}
for (int i = mid + 1; i <= r; ++i) cnt[rmx[i] - i + N] = 0;
for (int i = mid, u = mid, v = mid + 1; i >= l; --i) {
for (; u < r && rmx[u + 1] < lmx[i]; ++u) ++cnt[rmn[u + 1] + (u + 1)];
for (; v <= min(u, r) && rmn[v] > lmn[i]; ++v) --cnt[rmn[v] + v];
ret += max(0, cnt[lmx[i] + i]);
}
for (int i = mid + 1; i <= r; ++i) cnt[rmn[i] + i] = 0;
return ret;
}
int main() {
cin >> n;
for (int i = 1, x, y; i <= n; ++i) scanf("%d%d", &x, &y), a[y] = x;
cout << ovo(1, n) << endl;
return 0;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division.
To improve his division skills, Oleg came up with t pairs of integers p_i and q_i and for each pair decided to find the greatest integer x_i, such that:
* p_i is divisible by x_i;
* x_i is not divisible by q_i.
Oleg is really good at division and managed to find all the answers quickly, how about you?
Input
The first line contains an integer t (1 ≤ t ≤ 50) — the number of pairs.
Each of the following t lines contains two integers p_i and q_i (1 ≤ p_i ≤ 10^{18}; 2 ≤ q_i ≤ 10^{9}) — the i-th pair of integers.
Output
Print t integers: the i-th integer is the largest x_i such that p_i is divisible by x_i, but x_i is not divisible by q_i.
One can show that there is always at least one value of x_i satisfying the divisibility conditions for the given constraints.
Example
Input
3
10 4
12 6
179 822
Output
10
4
179
Note
For the first pair, where p_1 = 10 and q_1 = 4, the answer is x_1 = 10, since it is the greatest divisor of 10 and 10 is not divisible by 4.
For the second pair, where p_2 = 12 and q_2 = 6, note that
* 12 is not a valid x_2, since 12 is divisible by q_2 = 6;
* 6 is not valid x_2 as well: 6 is also divisible by q_2 = 6.
The next available divisor of p_2 = 12 is 4, which is the answer, since 4 is not divisible by 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void onami(long long n, long long b, long long a) {
map<long long, long long> m;
map<long long, long long>::iterator it;
while (n % 2 == 0) {
m[2]++;
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
m[i]++;
n = n / i;
}
}
if (n > 2) {
m[n]++;
}
long long xx, y;
xx = 1;
y = 1;
for (it = m.begin(); it != m.end(); it++) {
long long nnn = a;
while (nnn % b == 0) {
nnn = nnn / (*it).first;
}
xx = max(nnn, xx);
}
n = b;
vector<long long> v;
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
v.push_back(i);
} else {
v.push_back(i);
v.push_back(n / i);
}
}
}
sort(v.rbegin(), v.rend());
y = v[1];
cout << max(xx, y);
}
int main() {
int Tt;
cin >> Tt;
for (int i = 0; i < Tt; i++) {
long long a, b, c;
cin >> a;
cin >> b;
if (b <= a && a % b == 0) {
onami(b, b, a);
printf("\n");
} else {
cout << a;
printf("\n");
}
}
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
Give you N cards. Only one natural number is written on each card. However, the same number is never written.
From now on, as a question, I will say an appropriate natural number. Please answer the largest remainder you get when you divide the number on the card you have by the number I said.
For example, suppose you have three cards with 9, 3, and 8, respectively. If I say "4", find the remainder of 9 and 3 and 8 divided by 4, respectively. The remainders are 1, 3, and 0, respectively, but the largest remainder is 3, so 3 is the correct answer.
Let's get started. e? Is it hard to have a lot of cards? It can not be helped. Now let's use the computer to find the largest remainder. Create a program that finds the largest of the remainders of the number on the card divided by the number asked. Ask the question many times, not just once, but never ask the same number more than once.
input
The input consists of one dataset. Input data is given in the following format.
N Q
c1 c2 ... cN
q1
q2
::
qQ
The number of cards N (2 ≤ N ≤ 300000) and the number of questions Q (2 ≤ Q ≤ 100000) are given in the first line, separated by one space, and the number ci (1 ≤ 100000) written on the card in the second line. ci ≤ 300000) is given with one space delimiter. The following Q line is given the number qi (1 ≤ qi ≤ 300000) given as a question.
output
Output the maximum remainder on one line for each question.
Example
Input
3 3
9 3 8
4
6
5
Output
3
3
4
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int n, q, x, s[300003]; bool a[300003];
int sum(int l, int r) {
return s[r - 1] - s[l - 1];
}
int main() {
scanf("%d%d", &n, &q);
for(int i = 0; i < n; i++) scanf("%d", &x), a[x] = true;
for(int i = 1; i <= 300000; i++) s[i] = s[i - 1] + (a[i] ? 1 : 0);
for(int i = 0; i < q; i++) {
scanf("%d", &x);
int ret = 0;
for(int j = x; j <= 300000; j += x) {
if(sum(j - x, j) == 0) continue;
int l = j - x, r = j;
while(r - l > 1) {
int m = (l + r) / 2;
if(sum(m, j) != 0) l = m;
else r = m;
}
ret = max(ret, l - (j - x));
}
printf("%d\n", ret);
}
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
When Petya has free from computer games time, he attends university classes. Every day the lessons on Petya’s faculty consist of two double classes. The floor where the lessons take place is a long corridor with M classrooms numbered from 1 to M, situated along it.
All the students of Petya’s year are divided into N groups. Petya has noticed recently that these groups’ timetable has the following peculiarity: the number of the classroom where the first lesson of a group takes place does not exceed the number of the classroom where the second lesson of this group takes place.
Once Petya decided to count the number of ways in which one can make a lesson timetable for all these groups. The timetable is a set of 2N numbers: for each group the number of the rooms where the first and the second lessons take place. Unfortunately, he quickly lost the track of his calculations and decided to count only the timetables that satisfy the following conditions:
1) On the first lesson in classroom i exactly Xi groups must be present.
2) In classroom i no more than Yi groups may be placed.
Help Petya count the number of timetables satisfying all those conditionsю As there can be a lot of such timetables, output modulo 109 + 7.
Input
The first line contains one integer M (1 ≤ M ≤ 100) — the number of classrooms.
The second line contains M space-separated integers — Xi (0 ≤ Xi ≤ 100) the amount of groups present in classroom i during the first lesson.
The third line contains M space-separated integers — Yi (0 ≤ Yi ≤ 100) the maximal amount of groups that can be present in classroom i at the same time.
It is guaranteed that all the Xi ≤ Yi, and that the sum of all the Xi is positive and does not exceed 1000.
Output
In the single line output the answer to the problem modulo 109 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
36
Input
3
1 1 1
1 1 1
Output
6
Note
In the second sample test the first and the second lessons of each group must take place in the same classroom, that’s why the timetables will only be different in the rearrangement of the classrooms’ numbers for each group, e.g. 3! = 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, x[101], y[101], sum;
long long dp[101][1001], C[1002][1002], mo = 1e9 + 7, f[1001];
long long inv(long long x, long long k) {
if (k == 1ll) return x;
long long tmp = inv(x, k / 2ll);
tmp = (tmp * tmp) % mo;
if (k % 2) tmp *= x, tmp %= mo;
return tmp;
}
int main() {
C[0][0] = 1ll;
f[0] = 1ll;
for (int i = 1; i <= 1000; i++) {
f[i] = (f[i - 1] * i) % mo;
C[i][0] = 1ll;
for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mo;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]), sum += x[i];
for (int i = 1; i <= n; i++) scanf("%d", &y[i]);
dp[0][0] = 1ll;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= sum; j++)
for (int k = 0; k <= y[i]; k++)
if (j >= k && j >= x[i])
dp[i][j - k] += (dp[i - 1][j - x[i]] * C[j][k]) % mo,
dp[i][j - k] %= mo;
}
for (int i = 1; i <= sum; i++) dp[n][0] *= 1ll * i, dp[n][0] %= mo;
for (int i = 1; i <= n; i++) dp[n][0] *= inv(f[x[i]], mo - 2), dp[n][0] %= mo;
printf("%I64d\n", dp[n][0]);
return 0;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
problem
JOI Pizza sells pizza home delivery along the d-meter-long ring road that runs through the city center.
JOI Pizza has n stores S1, ..., Sn on the loop line. The head office is S1. The distance from S1 to Si when moving the loop line clockwise is set to di meters. D2 , ..., dn is an integer greater than or equal to 1 and less than or equal to d -1. D2, ..., dn are all different. Bake and deliver pizza at the shortest store.
The location of the delivery destination is represented by an integer k that is greater than or equal to 0 and less than or equal to d -1. This means that the distance from the head office S1 to the delivery destination in the clockwise direction is k meters. Pizza delivery is done along the loop line and no other road is allowed. However, the loop line may move clockwise or counterclockwise.
For example, if the location of the store and the location of the delivery destination are as shown in the figure below (this example corresponds to Example 1 of "I / O example").
<image>
The store closest to the delivery destination 1 is S2, so the delivery is from store S2. At this time, the distance traveled from the store is 1. Also, the store closest to delivery destination 2 is S1 (main store), so store S1 (main store). ) To deliver to home. At this time, the distance traveled from the store is 2.
Total length of the loop line d, Number of JOI pizza stores n, Number of orders m, N --1 integer representing a location other than the main store d2, ..., dn, Integer k1, .. representing the location of the delivery destination Given ., km, create a program to find the sum of all orders for each order by the distance traveled during delivery (ie, the distance from the nearest store to the delivery destination).
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line is a positive integer d (2 ≤ d ≤ 1000000000 = 109) that represents the total length of the loop line, the second line is a positive integer n (2 ≤ n ≤ 100000) that represents the number of stores, and the third line is A positive integer m (1 ≤ m ≤ 10000) is written to represent the number of orders. The n --1 lines after the 4th line are integers d2, d3, ..., dn that represent the location of stores other than the main store. (1 ≤ di ≤ d -1) is written in this order, and the integers k1, k2, ..., km (0 ≤ ki ≤ d) representing the delivery destination location are in the m lines after the n + 3rd line. --1) are written in this order.
Of the scoring data, for 40% of the points, n ≤ 10000 is satisfied. For 40% of the points, the total distance traveled and the value of d are both 1000000 or less. In the scoring data, the total distance traveled is 1000000000 = 109 or less.
When d is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each data set, one integer representing the total distance traveled during delivery is output on one line.
Examples
Input
8
3
2
3
1
4
6
20
4
4
12
8
16
7
7
11
8
0
Output
3
3
Input
None
Output
None
### Response
```cpp
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
int i,j;
int a[100001],d,m,n,p;
int sm;
while(cin>>d&&d){
cin>>m>>n;
a[0]=0;
for(i=1;i<m;i++)
cin>>a[i];
a[i]=d;
sort(a,a+m+1);
sm=0;
for(i=0;i<n;i++){
cin>>p;
for(j=0;a[j]>p||p>=a[j+1];j++);
sm+=min(p-a[j],a[j+1]-p);
}
cout<<sm<<endl;
}
return 0;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters.
In Taknese, the plural form of a noun is spelled based on the following rules:
* If a noun's singular form does not end with `s`, append `s` to the end of the singular form.
* If a noun's singular form ends with `s`, append `es` to the end of the singular form.
You are given the singular form S of a Taknese noun. Output its plural form.
Constraints
* S is a string of length 1 between 1000, inclusive.
* S contains only lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the plural form of the given Taknese word.
Examples
Input
apple
Output
apples
Input
bus
Output
buses
Input
box
Output
boxs
### Response
```cpp
#include<iostream>
#include<string>
int main(){
std::string s;
std::cin >> s;
s += s.back() != 's' ? "s" : "es";
std::cout << s << "\n";
return 0;
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long int p, q, r;
cin >> n >> p >> q >> r;
long long int dp[n][3];
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
dp[0][0] = p * arr[0];
for (int i = 1; i < n; i++) dp[i][0] = max(dp[i - 1][0], p * arr[i]);
dp[0][1] = dp[0][0] + q * arr[0];
for (int i = 1; i < n; i++)
dp[i][1] = max(dp[i - 1][1], dp[i][0] + q * arr[i]);
dp[0][2] = dp[0][1] + r * arr[0];
for (int i = 1; i < n; i++)
dp[i][2] = max(dp[i - 1][2], dp[i][1] + r * arr[i]);
cout << dp[n - 1][2] << endl;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Farmer John is hosting a tennis tournament with his n cows. Each cow has a skill level si, and no two cows having the same skill level. Every cow plays every other cow exactly once in the tournament, and each cow beats every cow with skill level lower than its own.
However, Farmer John thinks the tournament will be demoralizing for the weakest cows who lose most or all of their matches, so he wants to flip some of the results. In particular, at k different instances, he will take two integers ai, bi (ai < bi) and flip all the results between cows with skill level between ai and bi inclusive. That is, for any pair x, y <image> he will change the result of the match on the final scoreboard (so if x won the match, the scoreboard will now display that y won the match, and vice versa). It is possible that Farmer John will change the result of a match multiple times. It is not guaranteed that ai and bi are equal to some cow's skill level.
Farmer John wants to determine how balanced he made the tournament results look. In particular, he wants to count the number of triples of cows (p, q, r) for which the final leaderboard shows that cow p beats cow q, cow q beats cow r, and cow r beats cow p. Help him determine this number.
Note that two triples are considered different if they do not contain the same set of cows (i.e. if there is a cow in one triple that is not in the other).
Input
On the first line are two space-separated integers, n and k (3 ≤ n ≤ 105; 0 ≤ k ≤ 105). On the next line are n space-separated distinct integers, s1, s2, ..., sn (1 ≤ si ≤ 109), denoting the skill levels of the cows. On the next k lines are two space separated integers, ai and bi (1 ≤ ai < bi ≤ 109) representing the changes Farmer John made to the scoreboard in the order he makes it.
Output
A single integer, containing the number of triples of cows (p, q, r) for which the final leaderboard shows that cow p beats cow q, cow q beats cow r, and cow r beats cow p.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 2
1 2 3
1 2
2 3
Output
1
Input
5 3
5 9 4 1 7
1 7
2 8
3 9
Output
3
Note
In the first sample, cow 3 > cow 1, cow 3 > cow 2, and cow 2 > cow 1. However, the results between cows 1 and 2 and cows 2 and 3 are flipped, so now FJ's results show that cow 1 > cow 2, cow 2 > cow 3, and cow 3 > cow 1, so cows 1, 2, and 3 form a balanced triple.
### Response
```cpp
#include <bits/stdc++.h>
const int MaxN = 100010;
int n, m;
int val[MaxN];
int left[MaxN], right[MaxN];
int node[MaxN * 4], lazy[MaxN * 4];
struct list_t {
int total;
int head[MaxN], next[MaxN], point[MaxN];
void add_edge(int u, int v) {
point[++total] = v;
next[total] = head[u];
head[u] = total;
}
} list_a, list_b;
void reverse(int now, int head, int tail, int a, int b) {
int l = now << 1, r = l + 1;
if (head == a && tail == b) {
lazy[now] ^= 1;
if (a == b) {
node[now] = lazy[now];
} else {
node[now] = node[l] + node[r];
if (lazy[now]) node[now] = b - a + 1 - node[now];
}
return;
}
int m = (head + tail) >> 1;
int flag = true;
if (b <= m) {
reverse(l, head, m, a, b);
flag = false;
}
if (m < a) {
reverse(r, m + 1, tail, a, b);
flag = false;
}
if (flag) {
reverse(l, head, m, a, m);
reverse(r, m + 1, tail, m + 1, b);
}
node[now] = node[l] + node[r];
if (lazy[now]) node[now] = tail - head + 1 - node[now];
}
int ask(int now, int head, int tail, int a, int b, int lz) {
if (head == a && tail == b) {
if (lz) return b - a + 1 - node[now];
return node[now];
}
int m = (head + tail) >> 1;
int l = now << 1, r = l + 1;
lz ^= lazy[now];
if (b <= m) return ask(l, head, m, a, b, lz);
if (m < a) return ask(r, m + 1, tail, a, b, lz);
return ask(l, head, m, a, m, lz) + ask(r, m + 1, tail, m + 1, b, lz);
}
int main() {
std::scanf("%d %d", &n, &m);
for (int i = 0; i != n; ++i) std::scanf("%d", val + i);
std::sort(val, val + n);
val[n] = ~0u >> 1;
int count = 0;
for (int i = 0; i != m; ++i) {
int a, b;
std::scanf("%d %d", &a, &b);
if (b <= val[0] || a >= val[n - 1] || a == b) continue;
int l = 0, r = n;
while (l < r) {
int m = (l + r) >> 1;
if (val[m] >= a)
r = m;
else
l = m + 1;
}
left[count] = l + 1;
l = 0, r = n;
while (l < r) {
int m = (l + r) >> 1;
if (val[m] > b)
r = m;
else
l = m + 1;
}
right[count] = l;
if (left[count] >= right[count]) continue;
list_a.add_edge(left[count], right[count]);
list_b.add_edge(right[count], left[count]);
++count;
}
long long ans = (long long)n * (n - 1) * (n - 2) / 6;
for (int i = 1; i <= n; ++i) {
for (int k = list_a.head[i]; k; k = list_a.next[k])
reverse(1, 1, n, i, list_a.point[k]);
for (int k = list_b.head[i - 1]; k; k = list_b.next[k])
reverse(1, 1, n, list_b.point[k], i - 1);
long long tmp = 0;
if (i != 1) tmp += ask(1, 1, n, 1, i - 1, 0);
if (i != n) tmp += n - i - ask(1, 1, n, i + 1, n, 0);
ans -= tmp * (tmp - 1) / 2;
}
std::printf("%I64d", ans);
return 0;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
Everything red frightens Nian the monster. So do red paper and... you, red on Codeforces, potential or real.
Big Banban has got a piece of paper with endless lattice points, where lattice points form squares with the same area. His most favorite closed shape is the circle because of its beauty and simplicity. Once he had obtained this piece of paper, he prepares it for paper-cutting.
<image>
He drew n concentric circles on it and numbered these circles from 1 to n such that the center of each circle is the same lattice point and the radius of the k-th circle is <image> times the length of a lattice edge.
Define the degree of beauty of a lattice point as the summation of the indices of circles such that this lattice point is inside them, or on their bounds. Banban wanted to ask you the total degree of beauty of all the lattice points, but changed his mind.
Defining the total degree of beauty of all the lattice points on a piece of paper with n circles as f(n), you are asked to figure out <image>.
Input
The first line contains one integer m (1 ≤ m ≤ 1012).
Output
In the first line print one integer representing <image>.
Examples
Input
5
Output
387
Input
233
Output
788243189
Note
A piece of paper with 5 circles is shown in the following.
<image>
There are 5 types of lattice points where the degree of beauty of each red point is 1 + 2 + 3 + 4 + 5 = 15, the degree of beauty of each orange point is 2 + 3 + 4 + 5 = 14, the degree of beauty of each green point is 4 + 5 = 9, the degree of beauty of each blue point is 5 and the degree of beauty of each gray point is 0. Therefore, f(5) = 5·15 + 4·14 + 4·9 + 8·5 = 207.
Similarly, f(1) = 5, f(2) = 23, f(3) = 50, f(4) = 102 and consequently <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inv2 = (mod + 1) / 2, inv3 = (mod + 1) / 3,
inv5 = (mod * 2 + 1) / 5, inv6 = inv2 * inv3 % mod,
inv7 = (mod + 1) / 7;
long long n, ans;
inline long long mul(long long x, long long y) {
return (x % mod) * (y % mod) % mod;
}
inline void add(long long &x, long long y) {
x = (x + y >= mod ? x + y - mod : x + y);
}
inline void dec(long long &x, long long y) {
x = (x - y < 0) ? x - y + mod : x - y;
}
inline long long power(long long x, long long t) {
if (t == 1) return x % mod;
return mul(x, power(x, t - 1));
}
inline long long sum2(long long x) {
return mul(x, mul(x + 1, 2 * x + 1)) * inv6 % mod;
}
inline long long sum4(long long x) {
return mul(x, mul(x + 1, mul(2 * x + 1, 3 * mul(x, x) + 3 * x - 1))) * inv5 %
mod * inv6 % mod;
}
inline long long sum6(long long x) {
long long rs = 0;
add(rs, x * inv6 % mod * inv7 % mod);
dec(rs, power(x, 3) * inv6 % mod);
add(rs, power(x, 5) * inv2 % mod);
add(rs, power(x, 6) * inv2 % mod);
add(rs, power(x, 7) * inv7 % mod);
return rs;
}
int main() {
cin >> n;
long long cnt = 0;
for (long long x = 1; x * x < n; ++x) {
long long y = sqrt(n - x * x);
add(cnt, y);
add(ans, power(mul(x, x), 3) * y % mod * 2 % mod);
add(ans, power(mul(x, x), 2) * sum2(y) % mod * 6 % mod);
add(ans, power(mul(x, x), 1) * sum4(y) % mod * 6 % mod);
add(ans, sum6(y) * 2 % mod);
dec(ans, power(mul(x, x), 2) * y % mod * ((3 * n + 6) % mod) % mod);
dec(ans, power(mul(x, x), 1) * sum2(y) % mod * ((3 * n + 6) % mod) % mod *
2 % mod);
dec(ans, sum4(y) * ((3 * n + 6) % mod) % mod);
add(ans, power(mul(x, x), 1) * y % mod * ((3 * n + 4) % mod) % mod);
add(ans, sum2(y) * ((3 * n + 4) % mod) % mod);
add(ans, mul(power(n, 3), y));
add(ans, mul(power(n, 2) * 3, y));
add(ans, mul(n * 2, y));
}
ans = ans * 4 % mod;
cnt = cnt * 4 % mod;
long long rs = 0, cc = 0;
for (long long x = 1; x * x <= n; ++x) {
add(ans, 8 * power(mul(x, x), 3) % mod);
dec(ans, mul(mul(3 * n + 6, power(mul(x, x), 2)), 4));
add(ans, mul(mul(3 * n + 4, mul(x, x)), 4));
add(ans, 4 * power(n, 3) % mod);
add(ans, 4 * power(n, 2) * 3 % mod);
add(ans, 4 * n * 2 % mod);
}
add(ans, power(n, 3) % mod);
add(ans, power(n, 2) * 3 % mod);
add(ans, n * 2 % mod);
ans = ans * inv6 % mod;
cout << ans << endl;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Due to atheistic Soviet past, Christmas wasn't officially celebrated in Russia for most of the twentieth century. As a result, the Russian traditions for Christmas and New Year mixed into one event celebrated on the New Year but including the tree, a Santa-like 'Grandfather Frost', presents and huge family reunions and dinner parties all over the country. Bying a Tree at the New Year and installing it in the house is a tradition. Usually the whole family decorates the tree on the New Year Eve. We hope that Codeforces is a big and loving family, so in this problem we are going to decorate a tree as well.
So, our decoration consists of n pieces, each piece is a piece of colored paper, its border is a closed polyline of a special shape. The pieces go one by one as is shown on the picture. The i-th piece is a polyline that goes through points: (0, 0), (0, y0), (1, y1), (2, y2), ..., (k, yk), (k, 0). The width of each piece equals k.
<image> The figure to the left shows the decoration, the figure to the right shows the individual pieces it consists of.
The piece number 1 (shown red on the figure) is the outer piece (we see it completely), piece number 2 (shown yellow) follows it (we don't see it completely as it is partially closed by the first piece) and so on. The programmers are quite curious guys, so the moment we hung a decoration on the New Year tree we started to wonder: what area of each piece can people see?
Input
The first line contains two integers, n and k (1 ≤ n, k ≤ 300). Each of the following n lines contains k + 1 integers — the description of the polyline. If the i-th line contains ontegers yi, 0, yi, 1, ..., yi, k, that means that the polyline of the i-th piece goes through points (0, 0), (0, yi, 0), (1, yi, 1), (2, yi, 2), ..., (k, yi, k), (k, 0) (1 ≤ yi, j ≤ 1000).
Output
Print n real numbers — for each polyline, the area of its visible part.
The answer will be considered correct if its relative or absolute error do not exceed 10 - 4.
Examples
Input
2 2
2 1 2
1 2 1
Output
3.000000000000
0.500000000000
Input
1 1
1 1
Output
1.000000000000
Input
4 1
2 7
7 2
5 5
6 4
Output
4.500000000000
1.250000000000
0.050000000000
0.016666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
int n, k, m, y[310];
long double h[310][1235];
int main() {
scanf("%d%d", &n, &k);
m = 1234;
long double la = 0, res;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) scanf("%d", y + j);
res = 0;
for (int j = 0; j < k; j++) {
long double ly = y[j], d = (long double)(y[j] - y[j + 1]) / m;
for (int u = 1; u <= m; u++) {
long double h0 = (ly + ly - d) / 2;
h[j][u] = max(h[j][u], h0);
res += h[j][u] / m;
ly -= d;
}
}
printf("%.7f\n", (double)(res - la));
la = res;
}
return 0;
}
```
|
### Prompt
Please provide a CPP coded solution to the problem described below:
You have a simple undirected graph consisting of n vertices and m edges. The graph doesn't contain self-loops, there is at most one edge between a pair of vertices. The given graph can be disconnected.
Let's make a definition.
Let v_1 and v_2 be two some nonempty subsets of vertices that do not intersect. Let f(v_{1}, v_{2}) be true if and only if all the conditions are satisfied:
1. There are no edges with both endpoints in vertex set v_1.
2. There are no edges with both endpoints in vertex set v_2.
3. For every two vertices x and y such that x is in v_1 and y is in v_2, there is an edge between x and y.
Create three vertex sets (v_{1}, v_{2}, v_{3}) which satisfy the conditions below;
1. All vertex sets should not be empty.
2. Each vertex should be assigned to only one vertex set.
3. f(v_{1}, v_{2}), f(v_{2}, v_{3}), f(v_{3}, v_{1}) are all true.
Is it possible to create such three vertex sets? If it's possible, print matching vertex set for each vertex.
Input
The first line contains two integers n and m (3 ≤ n ≤ 10^{5}, 0 ≤ m ≤ min(3 ⋅ 10^{5}, (n(n-1))/(2))) — the number of vertices and edges in the graph.
The i-th of the next m lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. The graph doesn't contain self-loops, there is at most one edge between a pair of vertices. The given graph can be disconnected.
Output
If the answer exists, print n integers. i-th integer means the vertex set number (from 1 to 3) of i-th vertex. Otherwise, print -1.
If there are multiple answers, print any.
Examples
Input
6 11
1 2
1 3
1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6
Output
1 2 2 3 3 3
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
-1
Note
In the first example, if v_{1} = \{ 1 \}, v_{2} = \{ 2, 3 \}, and v_{3} = \{ 4, 5, 6 \} then vertex sets will satisfy all conditions. But you can assign vertices to vertex sets in a different way; Other answers like "2 3 3 1 1 1" will be accepted as well.
<image>
In the second example, it's impossible to make such vertex sets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
if (y == 0) {
return 1;
}
long long p = power(x, y / 2);
p = (p * p);
return (y % 2 == 0) ? p : (x * p);
}
long long powm(long long x, long long y, long long m) {
long long ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long lar = max(a, b);
long long small = min(a, b);
for (long long i = lar;; i += lar) {
if (i % small == 0) {
return i;
}
}
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
bool sortbydec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
void dex(int a) {
if (a == 1) {
cout << "YES";
}
if (a == 2) {
cout << "NO";
}
if (a == 3) {
cout << "Yes";
}
if (a == 4) {
cout << "No";
}
}
void line(long long x) {
for (long long i = 1; i <= x; i++) {
cout << "-";
}
cout << '\n';
}
const long long N = (long long)(300005);
const long long MOD = (long long)(1e9 + 7);
const long long INF = (long long)(2e18);
long long pw[N];
long long ha[N];
map<long long, long long> ma;
long long n, m;
bool vis[N];
vector<long long> adj[N];
void dfs(long long s) {
vis[s] = true;
for (auto &it : adj[s]) {
if (!vis[it]) {
dfs(it);
}
}
}
void solve(long long tc) {
cin >> n >> m;
pw[0] = 1;
for (long long i = 1; i <= n; i++) {
pw[i] = 271 * pw[i - 1];
}
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
ha[x] += pw[y];
ha[y] += pw[x];
}
long long idx = 1;
for (long long i = 1; i <= n; i++) {
if (ha[i] == 0) {
cout << -1 << '\n';
return;
}
if (ma[ha[i]] == 0) {
ma[ha[i]] = idx++;
}
}
if ((long long)ma.size() == 3) {
for (long long i = 1; i <= n; i++) {
cout << ma[ha[i]] << " ";
}
} else {
cout << -1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long cnt = 1;
long long t = 1;
while (t--) {
for (auto blockTime = make_pair(chrono::high_resolution_clock::now(), true);
blockTime.second;
fprintf(stderr, "%s: %lld ms\n", "solve",
chrono::duration_cast<chrono::milliseconds>(
chrono::high_resolution_clock::now() - blockTime.first)
.count()),
fflush(stderr), blockTime.second = false) {
solve(cnt);
}
cnt++;
}
return 0;
}
```
|
### Prompt
Generate a CPP solution to the following problem:
Petya likes horse racing very much. Horses numbered from l to r take part in the races. Petya wants to evaluate the probability of victory; for some reason, to do that he needs to know the amount of nearly lucky horses' numbers. A nearly lucky number is an integer number that has at least two lucky digits the distance between which does not exceed k. Petya learned from some of his mates from Lviv that lucky digits are digits 4 and 7. The distance between the digits is the absolute difference between their positions in the number of a horse. For example, if k = 2, then numbers 412395497, 404, 4070400000070004007 are nearly lucky and numbers 4, 4123954997, 4007000040070004007 are not.
Petya prepared t intervals [li, ri] and invented number k, common for all of them. Your task is to find how many nearly happy numbers there are in each of these segments. Since the answers can be quite large, output them modulo 1000000007 (109 + 7).
Input
The first line contains two integers t and k (1 ≤ t, k ≤ 1000) — the number of segments and the distance between the numbers correspondingly. Next t lines contain pairs of integers li and ri (1 ≤ l ≤ r ≤ 101000). All numbers are given without the leading zeroes. Numbers in each line are separated by exactly one space character.
Output
Output t lines. In each line print one integer — the answer for the corresponding segment modulo 1000000007 (109 + 7).
Examples
Input
1 2
1 100
Output
4
Input
1 2
70 77
Output
2
Input
2 1
1 20
80 100
Output
0
0
Note
In the first sample, the four nearly lucky numbers are 44, 47, 74, 77.
In the second sample, only 74 and 77 are in the given segment.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
const long long inf = 2147383647;
const long long mod = 1000000007;
const double pi = 2 * acos(0.0);
const double eps = 1e-11;
int N, K;
string low, upp, target;
char tmp[1005];
long long DP[1005][1005][2][2];
int vis[1005][1005][2][2];
int tc = 0;
long long call(int pos, int prv, int sm, int f) {
if (pos == 0) {
return f;
}
if (vis[pos][prv][sm][f] == tc) return DP[pos][prv][sm][f];
if (sm == 1) {
if (vis[pos][prv][sm][f] != 0) return DP[pos][prv][sm][f];
}
vis[pos][prv][sm][f] = tc;
int st = 0, ed = 9;
if (sm == 0) {
ed = (target[N - pos] - '0');
}
long long res = 0;
for (long long d = (st); d <= (ed); ++d) {
int sm2 = sm;
if (d < ed) sm2 = 1;
int prv2 = prv;
int f2 = f;
if (d == 4 || d == 7) {
if (prv != 0) {
int dif = prv - pos;
if (dif <= K) f2 = 1;
}
prv2 = pos;
}
res += call(pos - 1, prv2, sm2, f2);
res %= mod;
}
return DP[pos][prv][sm][f] = res;
}
bool islucky(string s) {
int prv = -1;
for (long long i = (0); i <= (((long long)(s).size()) - 1); ++i) {
int d = (s[i] - '0');
if (d == 4 || d == 7) {
if (prv == -1) {
prv = i;
} else {
int dif = i - prv;
if (dif <= K) return true;
prv = i;
}
}
}
return false;
}
long long findres(string &s) {
target = s;
N = ((long long)(target).size());
tc++;
long long res = call(N, 0, 0, 0);
return res;
}
long long solve() {
long long res = findres(upp) - findres(low);
if (res < 0) res += mod;
res += islucky(low);
res %= mod;
return res;
}
int main() {
int t;
scanf("%d %d", &t, &K);
for (long long cs = (1); cs <= (t); ++cs) {
scanf("%s", tmp);
low = tmp;
scanf("%s", tmp);
upp = tmp;
long long res = solve();
printf("%lld\n", res);
}
return 0;
}
```
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Problem A Secret of Chocolate Poles
Wendy, the master of a chocolate shop, is thinking of displaying poles of chocolate disks in the showcase. She can use three kinds of chocolate disks: white thin disks, dark thin disks, and dark thick disks. The thin disks are $1$ cm thick, and the thick disks are $k$ cm thick. Disks will be piled in glass cylinders.
Each pole should satisfy the following conditions for her secret mission, which we cannot tell.
* A pole should consist of at least one disk.
* The total thickness of disks in a pole should be less than or equal to $l$ cm.
* The top disk and the bottom disk of a pole should be dark.
* A disk directly upon a white disk should be dark and vice versa.
As examples, six side views of poles are drawn in Figure A.1. These are the only possible side views she can make when $l = 5$ and $k = 3$.
<image>
Figure A.1. Six chocolate poles corresponding to Sample Input 1
Your task is to count the number of distinct side views she can make for given $l$ and $k$ to help her accomplish her secret mission.
Input
The input consists of a single test case in the following format.
$l$ $k$
Here, the maximum possible total thickness of disks in a pole is $l$ cm, and the thickness of the thick disks is $k$ cm. $l$ and $k$ are integers satisfying $1 \leq l \leq 100$ and $2 \leq k \leq 10$.
Output
Output the number of possible distinct patterns.
Sample Input 1
5 3
Sample Output 1
6
Sample Input 2
9 10
Sample Output 2
5
Sample Input 3
10 10
Sample Output 3
6
Sample Input 4
20 5
Sample Output 4
86
Sample Input 5
100 2
Sample Output 5
3626169232670
Example
Input
5 3
Output
6
### Response
```cpp
#include<cstdio>
long long D[110], Res;
int K, L;
int main() {
int i, j;
scanf("%d%d", &L, &K);
D[1] = D[K] = 1;
for (i = 1; i <= L; i++) {
Res += D[i];
D[i + 2] += D[i];
D[i + K + 1] += D[i];
}
printf("%lld\n", Res);
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
A top-secret military base under the command of Colonel Zuev is expecting an inspection from the Ministry of Defence. According to the charter, each top-secret military base must include a top-secret troop that should... well, we cannot tell you exactly what it should do, it is a top secret troop at the end. The problem is that Zuev's base is missing this top-secret troop for some reasons.
The colonel decided to deal with the problem immediately and ordered to line up in a single line all n soldiers of the base entrusted to him. Zuev knows that the loquacity of the i-th soldier from the left is equal to qi. Zuev wants to form the top-secret troop using k leftmost soldiers in the line, thus he wants their total loquacity to be as small as possible (as the troop should remain top-secret). To achieve this, he is going to choose a pair of consecutive soldiers and swap them. He intends to do so no more than s times. Note that any soldier can be a participant of such swaps for any number of times. The problem turned out to be unusual, and colonel Zuev asked you to help.
Determine, what is the minimum total loquacity of the first k soldiers in the line, that can be achieved by performing no more than s swaps of two consecutive soldiers.
Input
The first line of the input contains three positive integers n, k, s (1 ≤ k ≤ n ≤ 150, 1 ≤ s ≤ 109) — the number of soldiers in the line, the size of the top-secret troop to be formed and the maximum possible number of swap operations of the consecutive pair of soldiers, respectively.
The second line of the input contains n integer qi (1 ≤ qi ≤ 1 000 000) — the values of loquacity of soldiers in order they follow in line from left to right.
Output
Print a single integer — the minimum possible total loquacity of the top-secret troop.
Examples
Input
3 2 2
2 4 1
Output
3
Input
5 4 2
10 1 6 2 5
Output
18
Input
5 2 3
3 1 4 2 5
Output
3
Note
In the first sample Colonel has to swap second and third soldiers, he doesn't really need the remaining swap. The resulting soldiers order is: (2, 1, 4). Minimum possible summary loquacity of the secret troop is 3. In the second sample Colonel will perform swaps in the following order:
1. (10, 1, 6 — 2, 5)
2. (10, 1, 2, 6 — 5)
The resulting soldiers order is (10, 1, 2, 5, 6).
Minimum possible summary loquacity is equal to 18.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, s;
int a[200];
int f[200][200 * 200];
int main() {
scanf("%d %d %d", &n, &k, &s);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i - 1; j >= 0; j--) {
for (int k = 0; k <= i * j; k++) {
if (f[j][k] != 0x3f3f3f3f) {
f[j + 1][k + i - j - 1] =
min(f[j + 1][k + i - j - 1], f[j][k] + a[i]);
}
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i <= min(s, n * n); i++) {
ans = min(ans, f[k][i]);
}
printf("%d\n", ans);
}
```
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
There is a grid of squares with H+1 horizontal rows and W vertical columns.
You will start at one of the squares in the top row and repeat moving one square right or down. However, for each integer i from 1 through H, you cannot move down from the A_i-th, (A_i + 1)-th, \ldots, B_i-th squares from the left in the i-th row from the top.
For each integer k from 1 through H, find the minimum number of moves needed to reach one of the squares in the (k+1)-th row from the top. (The starting square can be chosen individually for each case.) If, starting from any square in the top row, none of the squares in the (k+1)-th row can be reached, print `-1` instead.
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 1 \leq A_i \leq B_i \leq W
Input
Input is given from Standard Input in the following format:
H W
A_1 B_1
A_2 B_2
:
A_H B_H
Output
Print H lines. The i-th line should contain the answer for the case k=i.
Example
Input
4 4
2 4
1 1
2 3
2 4
Output
1
3
6
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int h, w;
cin >> h >> w;
// map of (start index, current index)
map<int, int> s;
// times took right step
multiset<int> vals;
for (int i = 0; i < w; ++i) {
s[i] = i;
vals.insert(0);
}
for (int i = 0; i < h; ++i) {
int l, r;
cin >> l >> r;
l--;
auto itr = s.lower_bound(l);
int till = -1;
while(itr != s.end() && itr->first <= r) {
till = max(till, itr->second);
int x = itr->first - itr->second;
vals.erase(vals.find(x));
s.erase(itr++);
}
if(till != -1 && r < w) {
vals.insert(r - till);
s[r] = till;
}
int ans = -1;
if(vals.size()) {
ans = *vals.begin() + (i+1);
}
cout << ans << endl;
}
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
A rare article in the Internet is posted without a possibility to comment it. On a Polycarp's website each article has comments feed.
Each comment on Polycarp's website is a non-empty string consisting of uppercase and lowercase letters of English alphabet. Comments have tree-like structure, that means each comment except root comments (comments of the highest level) has exactly one parent comment.
When Polycarp wants to save comments to his hard drive he uses the following format. Each comment he writes in the following format:
* at first, the text of the comment is written;
* after that the number of comments is written, for which this comment is a parent comment (i. e. the number of the replies to this comments);
* after that the comments for which this comment is a parent comment are written (the writing of these comments uses the same algorithm).
All elements in this format are separated by single comma. Similarly, the comments of the first level are separated by comma.
For example, if the comments look like:
<image>
then the first comment is written as "hello,2,ok,0,bye,0", the second is written as "test,0", the third comment is written as "one,1,two,2,a,0,b,0". The whole comments feed is written as: "hello,2,ok,0,bye,0,test,0,one,1,two,2,a,0,b,0". For a given comments feed in the format specified above print the comments in a different format:
* at first, print a integer d — the maximum depth of nesting comments;
* after that print d lines, the i-th of them corresponds to nesting level i;
* for the i-th row print comments of nesting level i in the order of their appearance in the Policarp's comments feed, separated by space.
Input
The first line contains non-empty comments feed in the described format. It consists of uppercase and lowercase letters of English alphabet, digits and commas.
It is guaranteed that each comment is a non-empty string consisting of uppercase and lowercase English characters. Each of the number of comments is integer (consisting of at least one digit), and either equals 0 or does not contain leading zeros.
The length of the whole string does not exceed 106. It is guaranteed that given structure of comments is valid.
Output
Print comments in a format that is given in the statement. For each level of nesting, comments should be printed in the order they are given in the input.
Examples
Input
hello,2,ok,0,bye,0,test,0,one,1,two,2,a,0,b,0
Output
3
hello test one
ok bye two
a b
Input
a,5,A,0,a,0,A,0,a,0,A,0
Output
2
a
A a A a A
Input
A,3,B,2,C,0,D,1,E,0,F,1,G,0,H,1,I,1,J,0,K,1,L,0,M,2,N,0,O,1,P,0
Output
4
A K M
B F H L N O
C D G I P
E J
Note
The first example is explained in the statements.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxl = 1000006;
char str[Maxl];
int len, pnt;
vector<string> com[Maxl];
string getString() {
int a = pnt;
while (pnt < len && str[pnt] != ',') pnt++;
string s(pnt - a, '?');
for (int i = a; i < pnt; i++) s[i - a] = str[i];
pnt++;
return s;
}
int getNum() {
int res = 0;
while (pnt < len && str[pnt] != ',') {
res = 10 * res + (str[pnt] - '0');
pnt++;
}
pnt++;
return res;
}
void Solve(int lvl) {
if (pnt < len) {
com[lvl].push_back(getString());
int no = getNum();
while (no--) Solve(lvl + 1);
}
}
int main() {
scanf("%s", str);
len = strlen(str);
while (pnt < len) Solve(0);
int i = 0;
while (com[i].size() > 0) i++;
printf("%d\n", i);
for (int j = 0; j < i; j++)
for (int k = 0; k < com[j].size(); k++)
printf("%s%c", com[j][k].c_str(), k + 1 < com[j].size() ? ' ' : '\n');
return 0;
}
```
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
This is an easier version of the problem. In this version, n ≤ 2000.
There are n distinct points in three-dimensional space numbered from 1 to n. The i-th point has coordinates (x_i, y_i, z_i). The number of points n is even.
You'd like to remove all n points using a sequence of n/2 snaps. In one snap, you can remove any two points a and b that have not been removed yet and form a perfectly balanced pair. A pair of points a and b is perfectly balanced if no other point c (that has not been removed yet) lies within the axis-aligned minimum bounding box of points a and b.
Formally, point c lies within the axis-aligned minimum bounding box of points a and b if and only if min(x_a, x_b) ≤ x_c ≤ max(x_a, x_b), min(y_a, y_b) ≤ y_c ≤ max(y_a, y_b), and min(z_a, z_b) ≤ z_c ≤ max(z_a, z_b). Note that the bounding box might be degenerate.
Find a way to remove all points in n/2 snaps.
Input
The first line contains a single integer n (2 ≤ n ≤ 2000; n is even), denoting the number of points.
Each of the next n lines contains three integers x_i, y_i, z_i (-10^8 ≤ x_i, y_i, z_i ≤ 10^8), denoting the coordinates of the i-th point.
No two points coincide.
Output
Output n/2 pairs of integers a_i, b_i (1 ≤ a_i, b_i ≤ n), denoting the indices of points removed on snap i. Every integer between 1 and n, inclusive, must appear in your output exactly once.
We can show that it is always possible to remove all points. If there are many solutions, output any of them.
Examples
Input
6
3 1 0
0 3 0
2 2 0
1 0 0
1 3 0
0 1 0
Output
3 6
5 1
2 4
Input
8
0 1 1
1 0 1
1 1 0
1 1 1
2 2 2
3 2 2
2 3 2
2 2 3
Output
4 5
1 6
2 7
3 8
Note
In the first example, here is what points and their corresponding bounding boxes look like (drawn in two dimensions for simplicity, as all points lie on z = 0 plane). Note that order of removing matters: for example, points 5 and 1 don't form a perfectly balanced pair initially, but they do after point 3 is removed.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long qmul(long long a, long long b) {
long long r = 0;
while (b) {
if (b & 1) r = (r + a) % mod;
b >>= 1;
a = (a + a) % mod;
}
return r;
}
long long qpow(long long a, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % mod;
n >>= 1;
a = (a * a) % mod;
}
return r;
}
long long qpow(long long a, long long n, long long p) {
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % p;
n >>= 1;
a = (a * a) % p;
}
return r;
}
const int N = 2e5 + 10;
struct node {
long long x, y, z;
} a[N];
int st[N];
long long dist(node A, node B) {
return abs(A.x - B.x) + abs(A.y - B.y) + abs(A.z - B.z);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> a[i].x >> a[i].y >> a[i].z;
}
memset(st, 0, sizeof(st));
int id = -1;
for (int i = (1); i <= (n); i++) {
if (st[i]) continue;
long long maxx = 0x3f3f3f3f;
id = -1;
for (int j = (1); j <= (n); j++) {
if (j == i || st[j] == 1) continue;
if (dist(a[i], a[j]) < maxx) {
maxx = dist(a[i], a[j]);
id = j;
}
}
st[i] = 1;
st[id] = 1;
cout << i << " " << id << endl;
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
A calculator scholar has discovered a strange life form called an electronic fly that lives in electronic space. While observing the behavior of the electronic flies, the electronic flies at the (x, y, z) point in this space then move to (x', y', z') indicated by the following rules. I found out.
<image>
However, a1, m1, a2, m2, a3, m3 are positive integers determined for each individual electronic fly. A mod B is the remainder of the positive integer A divided by the positive integer B.
Further observation revealed that some electronic flies always return to (1,1,1) shortly after being placed at (1,1,1). Such flies were named return flies (1).
Create a program that takes the data of the return fly as input and outputs the minimum number of movements (> 0) that return to (1,1,1). Note that 1 <a1, m1, a2, m2, a3, m3 <215.
(1) Returns when a1 and m1, a2 and m2, a3 and m3 are relatively prime (common divisor 1), respectively.
Input
Given multiple datasets. Each dataset is given in the following format:
a1 m1 a2 m2 a3 m3
The input ends with a line containing 6 0s. The number of datasets does not exceed 50.
Output
For each dataset, output the minimum number of moves (integer) that return to (1,1,1) on one line.
Example
Input
2 5 3 7 6 13
517 1024 746 6561 4303 3125
0 0 0 0 0 0
Output
12
116640000
### Response
```cpp
//Electro-Fly
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a1, a2, a3, m1, m2, m3;
ll gcd(ll a, ll b){
if(a==0)return b;
return gcd(b%a, a);
}
int main(){
while(cin>>a1>>m1>>a2>>m2>>a3>>m3){
if(a1==0 && m1==0 && a2==0 && m2==0 && a3==0 && m3==0)break;
ll b1=1, b2=1, b3=1;
ll t1=a1, t2=a2, t3=a3;
while(t1!=1){t1=(t1*a1)%m1; b1++;}
while(t2!=1){t2=(t2*a2)%m2; b2++;}
while(t3!=1){t3=(t3*a3)%m3; b3++;}
ll g1=gcd(min(b1, b2), max(b1, b2));
b1=b1*(b2/g1);
ll g2=gcd(min(b1, b3), max(b1, b3));
cout<<b1*(b3/g2)<<endl;
}
return 0;
}
```
|
### Prompt
Develop a solution in cpp to the problem described below:
Vasya owns three strings s , a and b, each of them consists only of first k Latin letters.
Let a template be such a string of length k that each of the first k Latin letters appears in it exactly once (thus there are k! distinct templates). Application of template p to the string s is the replacement of each character in string s with p_i, i is the index of this letter in the alphabet. For example, applying template "bdca" to a string "aabccd" yields string "bbdcca".
Vasya wants to know if there exists such a template which yields a string lexicographically greater than or equal to string a and lexicographically less than or equal to string b after applying it to s.
If there exist multiple suitable templates, print any of them.
String a is lexicographically less than string b if there is some i (1 ≤ i ≤ n) that a_i < b_i and for any j (1 ≤ j < i) a_j = b_j.
You are required to answer t testcases independently.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) — the number of testcases.
In hacks you can only use t = 1.
Each of the next t lines contains the description of the testcase in the following form:
The first line of the testcase contains a single integer k (1 ≤ k ≤ 26) — the length of the template.
The second line of the testcase contains the string s (1 ≤ |s| ≤ 10^6).
The third line of the testcase contains the string a.
The fourth line of the testcase contains the string b.
Strings s, a and b have the same length (|s| = |a| = |b|) and consist only of the first k Latin letters, all letters are lowercase.
It is guaranteed that string a is lexicographically less than or equal to string b.
It is also guaranteed that the total length of strings over all testcase won't exceed 3 ⋅ 10^6.
Output
Print the answers to all testcases in the following form:
If there exists no suitable template then print "NO" in the first line.
Otherwise print "YES" in the first line and the template itself in the second line (k lowercase letters, each of the first k Latin letters should appear exactly once).
If there exist multiple suitable templates, print any of them.
Example
Input
2
4
bbcb
aada
aada
3
abc
bbb
bbb
Output
YES
badc
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000005;
const int Maxk = 26;
char tmp[Maxn];
int t;
int k;
bool tk[Maxk];
bool mytk[Maxk];
int seq[Maxk];
int myseq[Maxk];
string S, A, B, R;
void Read(string &s) {
scanf("%s", tmp);
s = tmp;
}
void getGreatest(int lvl) {
for (int i = 0; i < k; i++) {
myseq[i] = seq[i];
mytk[i] = tk[i];
}
int pnt = k - 1;
for (int i = lvl; i < S.length(); i++) {
int let = S[i] - 'a';
if (myseq[let] == -1) {
while (mytk[pnt]) pnt--;
myseq[let] = pnt;
mytk[pnt] = true;
}
}
for (int i = 0; i < k; i++)
if (myseq[i] == -1) {
while (mytk[pnt]) pnt--;
myseq[i] = pnt;
mytk[pnt] = true;
}
}
void getSmallest(int lvl) {
for (int i = 0; i < k; i++) {
myseq[i] = seq[i];
mytk[i] = tk[i];
}
int pnt = 0;
for (int i = lvl; i < S.length(); i++) {
int let = S[i] - 'a';
if (myseq[let] == -1) {
while (mytk[pnt]) pnt++;
myseq[let] = pnt;
mytk[pnt] = true;
}
}
for (int i = 0; i < k; i++)
if (myseq[i] == -1) {
while (mytk[pnt]) pnt++;
myseq[i] = pnt;
mytk[pnt] = true;
}
}
bool Check(int seq[]) {
R.resize(S.length());
for (int i = 0; i < S.length(); i++) R[i] = seq[S[i] - 'a'] + 'a';
return A <= R && R <= B;
}
void Print(int seq[]) {
printf("YES\n");
for (int i = 0; i < k; i++) printf("%c", seq[i] + 'a');
printf("\n");
}
void printNo() { printf("NO\n"); }
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &k);
fill(tk, tk + k, false);
fill(seq, seq + k, -1);
Read(S);
Read(A);
Read(B);
bool ok = true;
for (int lvl = 0; lvl < S.length(); lvl++) {
int let = S[lvl] - 'a';
ok = false;
int alet = A[lvl] - 'a';
int blet = B[lvl] - 'a';
bool tobreak = false;
for (int i = alet; i <= blet; i++)
if (seq[let] == i || !tk[i] && seq[let] == -1) {
bool upd = seq[let] == -1;
if (upd) {
seq[let] = i;
tk[i] = true;
}
if (i == alet && i == blet) {
ok = true;
break;
}
if (i == alet) {
getGreatest(lvl + 1);
if (Check(myseq)) {
Print(myseq);
tobreak = true;
break;
}
}
if (i == blet) {
getSmallest(lvl + 1);
if (Check(myseq)) {
Print(myseq);
tobreak = true;
break;
}
}
if (alet < i && i < blet) {
getSmallest(lvl + 1);
if (Check(myseq)) {
Print(myseq);
tobreak = true;
break;
}
}
if (upd) {
seq[let] = -1;
tk[i] = false;
}
}
if (tobreak) break;
if (!ok) {
printNo();
break;
}
}
if (ok) {
getSmallest(S.length());
if (Check(myseq))
Print(myseq);
else
printNo();
}
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
As meticulous Gerald sets the table, Alexander finished another post on Codeforces and begins to respond to New Year greetings from friends. Alexander has n friends, and each of them sends to Alexander exactly one e-card. Let us number his friends by numbers from 1 to n in the order in which they send the cards. Let's introduce the same numbering for the cards, that is, according to the numbering the i-th friend sent to Alexander a card number i.
Alexander also sends cards to friends, but he doesn't look for the new cards on the Net. He simply uses the cards previously sent to him (sometimes, however, he does need to add some crucial details). Initially Alexander doesn't have any cards. Alexander always follows the two rules:
1. He will never send to a firend a card that this friend has sent to him.
2. Among the other cards available to him at the moment, Alexander always chooses one that Alexander himself likes most.
Alexander plans to send to each friend exactly one card. Of course, Alexander can send the same card multiple times.
Alexander and each his friend has the list of preferences, which is a permutation of integers from 1 to n. The first number in the list is the number of the favorite card, the second number shows the second favorite, and so on, the last number shows the least favorite card.
Your task is to find a schedule of sending cards for Alexander. Determine at which moments of time Alexander must send cards to his friends, to please each of them as much as possible. In other words, so that as a result of applying two Alexander's rules, each friend receives the card that is preferred for him as much as possible.
Note that Alexander doesn't choose freely what card to send, but he always strictly follows the two rules.
Input
The first line contains an integer n (2 ≤ n ≤ 300) — the number of Alexander's friends, equal to the number of cards. Next n lines contain his friends' preference lists. Each list consists of n different integers from 1 to n. The last line contains Alexander's preference list in the same format.
Output
Print n space-separated numbers: the i-th number should be the number of the friend, whose card Alexander receives right before he should send a card to the i-th friend. If there are several solutions, print any of them.
Examples
Input
4
1 2 3 4
4 1 3 2
4 3 1 2
3 4 2 1
3 1 2 4
Output
2 1 1 4
Note
In the sample, the algorithm of actions Alexander and his friends perform is as follows:
1. Alexander receives card 1 from the first friend.
2. Alexander sends the card he has received (at the moment he only has one card, and therefore it is the most preferable for him) to friends with the numbers 2 and 3.
3. Alexander receives card 2 from the second friend, now he has two cards — 1 and 2.
4. Alexander sends a card to the first friend. Despite the fact that Alexander likes card 1 more, he sends card 2 as he cannot send a friend the card sent by that very friend.
5. Alexander receives card 3 from the third friend.
6. Alexander receives card 4 from the fourth friend.
7. Among the cards Alexander has number 3 is his favorite and he sends it to the fourth friend.
Note that Alexander can send cards to multiple friends at a time (in this case the second and the third one). Alexander can send card 3 to the fourth friend after he receives the third card or after he receives the fourth card (both variants are correct).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
int a[400][400];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
scanf("%d", &a[i][j]);
a[i][j]--;
}
}
int b[500];
int w[301] = {};
for (int i = 0; i < N; i++) {
scanf("%d", &b[i]);
b[i]--;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (a[i][j] == i) continue;
for (int k = 0; k < N; k++) {
if (b[k] == i) continue;
if (a[i][j] == b[k]) {
printf("%d ", a[i][j] + 1);
goto e1;
}
if (b[k] < a[i][j]) break;
}
}
e1:;
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
Levko loves sports pathfinding competitions in his city very much. In order to boost his performance, Levko spends his spare time practicing. The practice is a game.
The city consists of n intersections connected by m + k directed roads. Two or more roads can connect the same pair of intersections. Besides, there can be roads leading from an intersection to itself.
Levko and Zenyk are playing a game. First Levko stands on intersection s1, and Zenyk stands on intersection s2. They both want to get to intersection f. The person who does it quicker wins. If they get there at the same time, the game ends with a draw. By agreement both players start simultaneously and move with the same speed.
Levko wants to win very much. He knows the lengths of all the roads in the city. Also he knows that he can change the lengths of some roads (there are k such roads at all) if he pays the government. So, the government can change the length of the i-th road to any integer value in the segment [li, ri] (both borders inclusive). Levko wondered if he can reconstruct the roads so as to win the game and whether he can hope for the draw if he cannot win.
You should consider that both players play optimally well. It is guaranteed that we can get from intersections s1 and s2 to intersection f.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 104, 1 ≤ k ≤ 100). The second line contains three integers s1, s2 and f (1 ≤ s1, s2, f ≤ n).
The next m lines contains the descriptions of the roads that cannot be changed by Levko. Each line contains three integers ai, bi and ci (1 ≤ ai, bi ≤ n, 1 ≤ ci ≤ 109), representing a road from intersection ai to intersection bi of length ci.
The next k lines contains the descriptions of the roads that can be changed by Levko. Each line contains four integers ai, bi, li and ri (1 ≤ ai, bi ≤ n, 1 ≤ li ≤ ri ≤ 109), representing a road from intersection ai to intersection bi, Levko can set the road's length within limits [li, ri].
Consider all intersections numbered from 1 to n. It is guaranteed that you can get from intersections s1 and s2 to intersection f.
Output
In the first line print string "WIN" (without the quotes) if Levko can win this game, string "DRAW" (without the quotes) if Levko can end the game with a draw and "LOSE" (without the quotes) if he loses for sure.
If the answer is "WIN" or "DRAW", then print on the second line k space-separated integers — the length of the roads Levko sets in the order they occur in the input.
Examples
Input
4 1 3
1 3 4
3 2 2
1 2 1 3
2 4 1 3
3 4 1 3
Output
WIN
1 1 3
Input
4 1 3
1 3 4
3 2 2
1 2 1 3
2 4 1 3
3 4 1 2
Output
DRAW
1 1 2
Input
5 4 2
1 2 5
1 3 3
1 4 4
2 3 2
2 4 3
3 5 1 5
4 5 4 7
Output
LOSE
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct k_edge {
int u, i, l, r;
k_edge() : u(0), i(0), l(0), r(0){};
k_edge(int U, int I, int L, int R) : u(U), i(I), l(L), r(R){};
} k_edges[105];
int n, m, k;
int s1, s2, f;
vector<pair<int, int> > graph[10005];
vector<long long> Dijkstra(int s) {
vector<long long> dist(n + 1);
for (int i = 0; i < n + 1; i++) {
dist[i] = INT_MAX;
}
dist[s] = 0;
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, s));
while (!pq.empty()) {
int u = pq.top().second;
long long d = -pq.top().first;
pq.pop();
if (d > dist[u]) continue;
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i].first;
int w = graph[u][i].second;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push(make_pair(-dist[v], v));
}
}
}
return dist;
}
void print_k_edges() {
for (int i = 0; i < k; i++) {
printf("%d ", graph[k_edges[i].u][k_edges[i].i].second);
}
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%d%d%d", &s1, &s2, &f);
for (int i = 0; i < m; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
graph[u].push_back(pair<int, int>(v, c));
}
for (int i = 0; i < k; i++) {
int u, v, l, r;
scanf("%d%d%d%d", &u, &v, &l, &r);
int pos = graph[u].size();
graph[u].push_back(pair<int, int>(v, r));
k_edges[i] = k_edge(u, pos, l, r);
}
bool modify = 1;
int u, index, l, r;
vector<long long> dist1;
vector<long long> dist2;
while (modify) {
modify = 0;
dist1 = Dijkstra(s1);
dist2 = Dijkstra(s2);
for (int i = 0; i < k; i++) {
u = k_edges[i].u, index = k_edges[i].i, l = k_edges[i].l;
if (dist1[u] < dist2[u] && graph[u][index].second > l) {
modify = true;
graph[u][index].second = l;
break;
}
}
}
if (dist1[f] < dist2[f]) {
printf("WIN\n");
print_k_edges();
} else {
modify = true;
while (modify) {
modify = 0;
dist1 = Dijkstra(s1);
dist2 = Dijkstra(s2);
for (int i = 0; i < k; i++) {
u = k_edges[i].u, index = k_edges[i].i, l = k_edges[i].l,
r = k_edges[i].r;
if (dist1[u] <= dist2[u] && graph[u][index].second > l) {
modify = true;
graph[u][index].second = l;
break;
}
}
}
if (dist1[f] <= dist2[f]) {
printf("DRAW\n");
print_k_edges();
} else
printf("LOSE\n");
}
return 0;
}
```
|
### Prompt
Your task is to create a CPP solution to the following problem:
You took a peek on Thanos wearing Infinity Gauntlet. In the Gauntlet there is a place for six Infinity Gems:
* the Power Gem of purple color,
* the Time Gem of green color,
* the Space Gem of blue color,
* the Soul Gem of orange color,
* the Reality Gem of red color,
* the Mind Gem of yellow color.
Using colors of Gems you saw in the Gauntlet determine the names of absent Gems.
Input
In the first line of input there is one integer n (0 ≤ n ≤ 6) — the number of Gems in Infinity Gauntlet.
In next n lines there are colors of Gems you saw. Words used for colors are: purple, green, blue, orange, red, yellow. It is guaranteed that all the colors are distinct. All colors are given in lowercase English letters.
Output
In the first line output one integer m (0 ≤ m ≤ 6) — the number of absent Gems.
Then in m lines print the names of absent Gems, each on its own line. Words used for names are: Power, Time, Space, Soul, Reality, Mind. Names can be printed in any order. Keep the first letter uppercase, others lowercase.
Examples
Input
4
red
purple
yellow
orange
Output
2
Space
Time
Input
0
Output
6
Time
Mind
Soul
Power
Reality
Space
Note
In the first sample Thanos already has Reality, Power, Mind and Soul Gems, so he needs two more: Time and Space.
In the second sample Thanos doesn't have any Gems, so he needs all six.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s[10];
string c[10] = {"purple", "green", "blue", "orange", "red", "yellow"};
string c1[10] = {"Power", "Time", "Space", "Soul", "Reality", "Mind"};
map<string, string> mp;
map<string, int> m;
cin >> n;
cin.ignore();
for (int i = 0; i < 6; i++) {
mp[c[i]] = c1[i];
}
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]] = 1;
cnt++;
}
cout << 6 - cnt << endl;
for (int i = 5; i >= 0; i--) {
if (m[c[i]] == 0) cout << mp[c[i]] << endl;
}
return 0;
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
problem
Information I want to paint a rectangular veneer board to make a signboard for the promotion of the Olympic Games. Some rectangular masking tapes are pre-attached to the veneer board where I do not want to paint. We decided to paint each area with a different color. For example, in the case of Figure 5-1 we use 5 colors of paint.
<image>
Create a program to find the number of paint colors to use when given the position to apply masking tape as input. However, the entire veneer board is not covered with masking tape, and all sides of the masking tape are on any of the veneer boards. Parallel to that side.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, the width w (integer with 1 ≤ w ≤ 1000000) and height h (integer with 1 ≤ h ≤ 1000000) are written in this order, separated by blanks.
The number of masking tapes n (an integer such that 1 ≤ n ≤ 1000) is written on the second line. The second and subsequent lines 2 + i (1 ≤ i ≤ n) are the i-th. The lower left coordinates (x1, y1) and the upper right coordinates (x2, y2) of the masking tape to be applied are x1, y1, x2, y2 (0 ≤ x1 <x2 ≤ w, 0 ≤ y1 <y2 ≤ h) It is written in the order of, separated by blanks.
However, the coordinates of the lower left corner of the plywood are (0, 0) and the coordinates of the upper right corner are (w, h). Of the scoring data, 30% of the points are w ≤ 100, h ≤ 100, n ≤ 100.
<image>
When both h and w are 0, it indicates the end of input. The number of data sets does not exceed 20.
output
Outputs the number of paint colors used for each dataset on one line.
Examples
Input
15 6
10
1 4 5 6
2 1 4 5
1 0 5 1
6 1 7 5
7 5 9 6
7 0 9 2
9 1 10 5
11 0 14 1
12 1 13 5
11 5 14 6
0 0
Output
5
Input
None
Output
None
### Response
```cpp
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <climits>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <set>
using namespace std;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int h, w;
vector<vector<bool> > check;
void dfs(int y, int x){
check[y][x] = false;
for(int i=0; i<4; ++i){
int y1 = y + dy[i];
int x1 = x + dx[i];
if(0 <= y1 && y1 < h && 0 <= x1 && x1 < w && check[y1][x1]){
dfs(y1, x1);
}
}
}
int main()
{
for(;;){
int n;
cin >> w >> h >> n;
if(w == 0)
return 0;
map<int, int> my, mx;
my[0];
my[h];
mx[0];
mx[w];
vector<int> x1(n), y1(n), x2(n), y2(n);
for(int i=0; i<n; ++i){
cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
my[y1[i]];
my[y2[i]];
mx[x1[i]];
mx[x2[i]];
}
map<int, int>::iterator it;
h = -1;
for(it=my.begin(); it!=my.end(); ++it){
++ h;
it->second = h;
}
w = -1;
for(it=mx.begin(); it!=mx.end(); ++it){
++ w;
it->second = w;
}
for(int i=0; i<n; ++i){
y1[i] = my[y1[i]];
y2[i] = my[y2[i]];
x1[i] = mx[x1[i]];
x2[i] = mx[x2[i]];
}
check.assign(h, vector<bool>(w, true));
for(int i=0; i<n; ++i){
for(int j=y1[i]; j<y2[i]; ++j){
for(int k=x1[i]; k<x2[i]; ++k){
check[j][k] = false;
}
}
}
int ret = 0;
for(int i=0; i<h; ++i){
for(int j=0; j<w; ++j){
if(check[i][j]){
dfs(i, j);
++ ret;
}
}
}
cout << ret << endl;
}
}
```
|
### Prompt
Generate a CPP solution to the following problem:
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int ar[100010];
long long psum[100010];
long long total, halftotal;
bool binser(int po) {
long long target = halftotal - ar[po];
int l = 0, r = po - 1;
int m;
while (l <= r) {
m = r - (r - l) / 2;
if (psum[m] > target)
r = m - 1;
else if (psum[m] < target)
l = m + 1;
else
return 1;
}
target = halftotal + ar[po];
l = po + 1, r = n;
while (l <= r) {
m = r - (r - l) / 2;
if (psum[m] > target)
r = m - 1;
else if (psum[m] < target)
l = m + 1;
else
return 1;
}
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> ar[i];
psum[i] = psum[i - 1] + ar[i];
total += ar[i];
}
if (total & 1) {
cout << "NO\n";
return 0;
}
halftotal = total / 2;
for (int i = 1; i <= n; ++i) {
if (binser(i)) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Young Teodor enjoys drawing. His favourite hobby is drawing segments with integer borders inside his huge [1;m] segment. One day Teodor noticed that picture he just drawn has one interesting feature: there doesn't exist an integer point, that belongs each of segments in the picture. Having discovered this fact, Teodor decided to share it with Sasha.
Sasha knows that Teodor likes to show off so he never trusts him. Teodor wants to prove that he can be trusted sometimes, so he decided to convince Sasha that there is no such integer point in his picture, which belongs to each segment. However Teodor is lazy person and neither wills to tell Sasha all coordinates of segments' ends nor wills to tell him their amount, so he suggested Sasha to ask him series of questions 'Given the integer point xi, how many segments in Fedya's picture contain that point?', promising to tell correct answers for this questions.
Both boys are very busy studying and don't have much time, so they ask you to find out how many questions can Sasha ask Teodor, that having only answers on his questions, Sasha can't be sure that Teodor isn't lying to him. Note that Sasha doesn't know amount of segments in Teodor's picture. Sure, Sasha is smart person and never asks about same point twice.
Input
First line of input contains two integer numbers: n and m (1 ≤ n, m ≤ 100 000) — amount of segments of Teodor's picture and maximal coordinate of point that Sasha can ask about.
ith of next n lines contains two integer numbers li and ri (1 ≤ li ≤ ri ≤ m) — left and right ends of ith segment in the picture. Note that that left and right ends of segment can be the same point.
It is guaranteed that there is no integer point, that belongs to all segments.
Output
Single line of output should contain one integer number k – size of largest set (xi, cnt(xi)) where all xi are different, 1 ≤ xi ≤ m, and cnt(xi) is amount of segments, containing point with coordinate xi, such that one can't be sure that there doesn't exist point, belonging to all of segments in initial picture, if he knows only this set(and doesn't know n).
Examples
Input
2 4
1 2
3 4
Output
4
Input
4 6
1 3
2 3
4 6
5 6
Output
5
Note
First example shows situation where Sasha can never be sure that Teodor isn't lying to him, because even if one knows cnt(xi) for each point in segment [1;4], he can't distinguish this case from situation Teodor has drawn whole [1;4] segment.
In second example Sasha can ask about 5 points e.g. 1, 2, 3, 5, 6, still not being sure if Teodor haven't lied to him. But once he knows information about all points in [1;6] segment, Sasha can be sure that Teodor haven't lied to him.
### Response
```cpp
#include <bits/stdc++.h>
const double eps = 1e-10;
const float epsf = 1e-6;
using namespace std;
inline long long int __gcd(long long int a, long long int b) {
if (a == 0 || b == 0) {
return max(a, b);
}
long long int tempa, tempb;
while (1) {
if (a % b == 0)
return b;
else {
tempa = a;
tempb = b;
a = tempb;
b = tempa % tempb;
}
}
}
inline int compfloat(float& x, float& y) {
if (fabs(x - y) < epsf)
return 0;
else if (x - y > 0)
return 1;
return -1;
}
inline int compdouble(double x, double y) {
if (fabs(x - y) < eps)
return 0;
else if (x - y > 0)
return 1;
else
return -1;
}
bool prime(long long int k) {
for (long long int i = 2; i * i <= k; i++)
if (k % i == 0) {
return false;
}
return true;
}
void pdash(int n = 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
cout << "-";
}
cout << "\n";
}
}
long long int power(long long int x, long long int y) {
long long int result = 1;
while (y > 0) {
if (y & 1) {
result = (result * x);
}
y = y >> 1;
x = (x * x);
}
return result;
}
long long int power(long long int x, long long int y, long long int z) {
long long int result = 1;
x = x % z;
while (y > 0) {
if (y & 1) {
result = (result * x) % z;
}
y = y >> 1;
x = (x * x) % z;
}
return result;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrF(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int f[n + 1];
f[0] = 1;
for (long long int i = 1; i <= n; i++) f[i] = f[i - 1] * i % p;
return (f[n] * modInverse(f[r], p) % p * modInverse(f[n - r], p) % p) % p;
}
void cordinate_compression(vector<int>& v) {
vector<int> p = v;
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
for (int i = 0; i < (int)((v).size()); i++)
v[i] = (int)(lower_bound(p.begin(), p.end(), v[i]) - p.begin());
}
vector<int> lis(vector<int> const& a) {
int n = (int)((a).size());
const int INF = 1e9;
vector<int> d(n + 1, INF), parent(n + 1, -1), index(n + 1);
index[0] = -1;
d[0] = -INF;
for (int i = 0; i < n; i++) {
int j = (int)(upper_bound(d.begin(), d.end(), a[i]) - d.begin());
if (d[j - 1] <= a[i] && a[i] < d[j]) {
index[j] = i;
parent[i] = index[j - 1];
d[j] = a[i];
}
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (d[i] < INF) ans = i;
}
vector<int> aans;
vector<int> len(n + 1, 0);
len[0] = 0;
for (int i = 0; i < n; i++) {
len[i + 1] = len[parent[i] + 1] + 1;
}
len.erase(len.begin());
return len;
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> cnt(m + 2, 0);
while (n--) {
int a, b;
cin >> a >> b;
cnt[a]++;
cnt[b + 1]--;
}
for (int i = 1; i <= m; i++) {
cnt[i] += cnt[i - 1];
}
cnt.pop_back();
cnt.erase(cnt.begin());
auto p = lis(cnt);
reverse(cnt.begin(), cnt.end());
auto q = lis(cnt);
reverse(q.begin(), q.end());
for (int i = 0; i < (int)((p).size()); i++) {
p[i] = p[i] + q[i] - 1;
}
cout << *max_element(p.begin(), p.end()) << "\n";
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
```
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Polycarp plays a (yet another!) strategic computer game. In this game, he leads an army of mercenaries.
Polycarp wants to gather his army for a quest. There are n mercenaries for hire, and the army should consist of some subset of them.
The i-th mercenary can be chosen if the resulting number of chosen mercenaries is not less than l_i (otherwise he deems the quest to be doomed) and not greater than r_i (he doesn't want to share the trophies with too many other mercenaries). Furthermore, m pairs of mercenaries hate each other and cannot be chosen for the same quest.
How many non-empty subsets does Polycarp need to consider? In other words, calculate the number of non-empty subsets of mercenaries such that the size of this subset belongs to [l_i, r_i] for each chosen mercenary, and there are no two mercenaries in the subset that hate each other.
The answer may be large, so calculate it modulo 998244353.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ m ≤ min(20, (n(n-1))/(2))) — the number of mercenaries and the number of pairs of mercenaries that hate each other.
Then n lines follow, the i-th of them contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n).
Then m lines follow, the i-th of them contains two integers a_i and b_i (1 ≤ a_i < b_i ≤ n) denoting that the mercenaries a_i and b_i hate each other. There are no two equal pairs in this list.
Output
Print one integer — the number of non-empty subsets meeting the constraints, taken modulo 998244353.
Examples
Input
3 0
1 1
2 3
1 3
Output
3
Input
3 1
1 1
2 3
1 3
2 3
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll << 60;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T>
std::ostream& operator<<(std::ostream& out, const std::pair<S, T>& a) {
std::cout << '(' << a.first << ", " << a.second << ')';
return out;
}
template <class T>
std::ostream& operator<<(std::ostream& out, const std::vector<T>& a) {
std::cout << '[';
for (ll i = (0); i < (a.size()); ++i) {
std::cout << a[i];
if (i != a.size() - 1) std::cout << ", ";
}
std::cout << ']';
return out;
}
const ll mod = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
std::vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
ll n, m;
ll l[300010], r[300010];
ll a[30], b[30];
ll cnt[300010];
mint binom[50][300010];
combination comb(300010);
int main() {
std::cin >> n >> m;
for (ll i = (0); i < (n); ++i) {
std::cin >> l[i] >> r[i];
++cnt[l[i]];
--cnt[r[i] + 1];
}
for (ll i = (0); i < (n + 1); ++i) cnt[i + 1] += cnt[i];
for (ll i = (0); i < (m); ++i) std::cin >> a[i] >> b[i];
for (ll i = (1); i < (n + 1); ++i) {
for (ll j = (0); j < (2 * m + 1); ++j) {
binom[j][i] = binom[j][i - 1] + comb(cnt[i] - j, i - j);
}
}
mint ans = 0;
for (ll i = (0); i < (1ll << m); ++i) {
ll L = 1, R = n;
std::set<ll> S;
for (ll j = (0); j < (m); ++j)
if (i >> j & 1) {
S.emplace(a[j] - 1);
S.emplace(b[j] - 1);
}
ll k = __builtin_popcountll(i);
for (auto x : S) {
chmax(L, l[x]);
chmin(R, r[x]);
}
if (R >= L) {
ans += (binom[S.size()][R] - binom[S.size()][L - 1]) * (k & 1 ? -1 : 1);
}
}
std::cout << ans.x << '\n';
return 0;
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The Shuseki Islands are an archipelago of 30001 small islands in the Yutampo Sea. The islands are evenly spaced along a line, numbered from 0 to 30000 from the west to the east. These islands are known to contain many treasures. There are n gems in the Shuseki Islands in total, and the i-th gem is located on island pi.
Mr. Kitayuta has just arrived at island 0. With his great jumping ability, he will repeatedly perform jumps between islands to the east according to the following process:
* First, he will jump from island 0 to island d.
* After that, he will continue jumping according to the following rule. Let l be the length of the previous jump, that is, if his previous jump was from island prev to island cur, let l = cur - prev. He will perform a jump of length l - 1, l or l + 1 to the east. That is, he will jump to island (cur + l - 1), (cur + l) or (cur + l + 1) (if they exist). The length of a jump must be positive, that is, he cannot perform a jump of length 0 when l = 1. If there is no valid destination, he will stop jumping.
Mr. Kitayuta will collect the gems on the islands visited during the process. Find the maximum number of gems that he can collect.
Input
The first line of the input contains two space-separated integers n and d (1 ≤ n, d ≤ 30000), denoting the number of the gems in the Shuseki Islands and the length of the Mr. Kitayuta's first jump, respectively.
The next n lines describe the location of the gems. The i-th of them (1 ≤ i ≤ n) contains a integer pi (d ≤ p1 ≤ p2 ≤ ... ≤ pn ≤ 30000), denoting the number of the island that contains the i-th gem.
Output
Print the maximum number of gems that Mr. Kitayuta can collect.
Examples
Input
4 10
10
21
27
27
Output
3
Input
8 8
9
19
28
36
45
55
66
78
Output
6
Input
13 7
8
8
9
16
17
17
18
21
23
24
24
26
30
Output
4
Note
In the first sample, the optimal route is 0 → 10 (+1 gem) → 19 → 27 (+2 gems) → ...
In the second sample, the optimal route is 0 → 8 → 15 → 21 → 28 (+1 gem) → 36 (+1 gem) → 45 (+1 gem) → 55 (+1 gem) → 66 (+1 gem) → 78 (+1 gem) → ...
In the third sample, the optimal route is 0 → 7 → 13 → 18 (+1 gem) → 24 (+2 gems) → 30 (+1 gem) → ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dp[30011][510];
int occ[30010];
int mx;
int d;
int tt = 0;
int solve(int pos, int jumplength) {
tt++;
if (pos > mx) {
return 0;
}
int offset = jumplength - (d - 250);
if (dp[pos][offset] != -1) return dp[pos][offset];
int ret = 0;
ret = max(solve(pos + jumplength, jumplength),
solve(pos + jumplength + 1, jumplength + 1));
if (jumplength != 1) {
ret = max(ret, solve(pos + jumplength - 1, jumplength - 1));
}
ret += occ[pos];
dp[pos][offset] = ret;
return ret;
}
int main() {
int n;
cin >> n;
cin >> d;
mx = 0;
for (int i = 1; i <= n; i++) {
int aa;
cin >> aa;
occ[aa]++;
mx = max(aa, mx);
}
memset(dp, -1, sizeof(dp));
int res = solve(d, d);
cout << res << endl;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
Taro is an elementary school student and has graffiti on the back of the leaflet. At one point, Taro came up with the next game.
* Write n × n grid-like squares.
* The initial state of each square is either marked or unmarked.
* Erase or write these circles so that there is always exactly one circle no matter which column you look at, and only one circle no matter what line you look at. That is the goal, and if you make it in this state, you have cleared the game.
Taro came up with this game, but Taro takes a lot of time to clear this game. So I asked you, a college student, for help. Your job as Taro's older brother and college student is as follows.
To consider the exact situation, you have derived the cost of writing a circle in a square and the cost of removing the circle in a square. Consider a procedure that uses this cost to minimize the cost of the operation required to clear this game. At this time, write a program that outputs the minimum cost and the procedure to achieve that cost. As for the output, any operation and order may be used as long as the procedure for achieving the minimum cost is achieved.
Constraints
> 1 ≤ n ≤ 100
> 1 ≤ Wij ≤ 1000
> 1 ≤ Eij ≤ 1000
>
* Fi is a string and its length is n
* Fi consists only of'o'and'.'
Input
> n
> W11 W12 .. W1n
> W21 W22 .. W2n
> ..
> Wn1 Wn2 .. Wnn
> E11 E12 .. E1n
> E21 E22 .. E2n
> ..
> En1 En2 .. Enn
> F1 (n characters)
> F2 (n characters)
> ..
> Fn (n characters)
>
* n indicates how many squares Taro made on one side
* Wij represents the cost of writing a circle in the i-th cell from the top and the j-th cell from the left.
* Eij represents the cost of erasing the circles in the i-th and j-th squares from the top.
* Fi represents the initial state of the cell in the i-th row from the top
* About the jth character from the left of Fi
* When it is'o', it means that a circle is written in the i-th cell from the top and the j-th cell from the left.
* When it is'.', It means that the i-th cell from the top and the j-th cell from the left are blank.
Output
> mincost
> cnt
> R1 C1 operate1
> R2 C2 operate2
> ..
> Rcnt Ccnt operatecnt
>
* mincost represents the minimum cost required to clear Taro's game.
* mincost is calculated as the sum of the costs incurred in write and erase operations.
* cnt: Represents the number of operations performed to achieve the cost of mincost
* The operation to be executed at the kth time (1 ≤ k ≤ cnt) is described in the k + 2nd line.
* For the kth operation (1 ≤ k ≤ cnt)
* Suppose you went to the i-th square from the top and the j-th square from the left.
* Rkk.
* If this operation is to remove the circle, set operator = "erase"
* If this is an operation to write a circle, set operator = "write"
* Rk, Ck, operator must be output on one line separated by blanks
* Wrong Answer if you write a circle on a square with a circle and delete the circle on a square without a circle.
* WrongAnswer when the sum of the costs of cnt operations does not match the mincost.
Examples
Input
3
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
o.o
...
.o.
Output
2
2
1 3 erase
2 3 write
Input
4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
oooo
oooo
oooo
oooo
Output
30
12
1 1 erase
1 2 erase
1 3 erase
2 1 erase
2 2 erase
2 4 erase
3 1 erase
3 3 erase
3 4 erase
4 2 erase
4 3 erase
4 4 erase
Input
3
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
o..
.o.
..o
Output
0
0
### Response
```cpp
// Enjoy your stay.
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(auto it=(X).begin();it!=(X).end();it++)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
//
#define MN 10010
struct edge{int to;ll cap,cost;int rev;
edge(int to,ll cap,ll cost,int rev):to(to),cap(cap),cost(cost),rev(rev){}};
vector<edge> g[MN];
int V_mcf,prevv[MN],preve[MN];
ll h[MN],dist[MN];
void init(int V){
V_mcf=V;
rep(i,V)g[i].clear();
}
void add_edge(int from,int to,ll cap,ll cost){
g[from].pb(edge(to,cap,cost,sz(g[to])));
g[to].pb(edge(from,0,-cost,sz(g[from])-1));
};
ll min_cost_flow_neg(int s,int t,ll f){
ll res=0;
fill(h,h+V_mcf,0);
while(f>0){
fill(dist,dist+V_mcf,INF);
dist[s]=0;
while(1){
bool update=0;
rep(i,V_mcf)rep(j,sz(g[i])){
edge& e=g[i][j];
if(e.cap>0 && dist[e.to]>dist[i]+e.cost+h[i]-h[e.to]){
dist[e.to]=dist[i]+e.cost+h[i]-h[e.to];
prevv[e.to]=i;
preve[e.to]=j;
update=1;
}
}
if(!update)break;
}
if(dist[t]==INF)return INF*INF;
rep(v,V_mcf)h[v]+=dist[v];
ll d=f;
for(int v=t;v!=s;v=prevv[v]){
d=min(d,g[prevv[v]][preve[v]].cap);
}
f-=d;
res+=d*h[t];
for(int v=t;v!=s;v=prevv[v]){
edge& e=g[prevv[v]][preve[v]];
e.cap-=d;
g[v][e.rev].cap+=d;
}
}
return res;
}
//
int n,W[111][111],E[111][111];
char c[111][111];
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin>>n;
rep(i,n)rep(j,n)cin>>W[i][j];
rep(i,n)rep(j,n)cin>>E[i][j];
rep(i,n)cin>>c[i];
init(n*2+2);
int s = n*2, t = s+1;
rep(i,n){
add_edge(s, i, 1, 0);
add_edge(n+i, t, 1, 0);
}
int ans = 0;
rep(i,n)rep(j,n){
if(c[i][j] == '.'){
add_edge(i, n+j, 1, W[i][j]);
}else{
ans += E[i][j];
add_edge(i, n+j, 1, -E[i][j]);
}
}
ans += min_cost_flow_neg(s,t,n);
cout<<ans<<endl;
vector<pair<pi,string>> v;
rep(i,n)rep(j,sz(g[i])){
int to = g[i][j].to - n;
if(!(to >= 0 && to < n))continue;
if(c[i][to] == '.' && g[i][j].cap == 0){
v.pb(mp(mp(i+1,to+1),"write"));
}
if(c[i][to] == 'o' && g[i][j].cap == 1){
v.pb(mp(mp(i+1,to+1),"erase"));
}
}
cout<<sz(v)<<endl;
rep(i,sz(v)){
cout<<v[i].fir.fir<<" "<<v[i].fir.sec<<" "<<v[i].sec<<endl;
}
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
n hobbits are planning to spend the night at Frodo's house. Frodo has n beds standing in a row and m pillows (n ≤ m). Each hobbit needs a bed and at least one pillow to sleep, however, everyone wants as many pillows as possible. Of course, it's not always possible to share pillows equally, but any hobbit gets hurt if he has at least two pillows less than some of his neighbors have.
Frodo will sleep on the k-th bed in the row. What is the maximum number of pillows he can have so that every hobbit has at least one pillow, every pillow is given to some hobbit and no one is hurt?
Input
The only line contain three integers n, m and k (1 ≤ n ≤ m ≤ 109, 1 ≤ k ≤ n) — the number of hobbits, the number of pillows and the number of Frodo's bed.
Output
Print single integer — the maximum number of pillows Frodo can have so that no one is hurt.
Examples
Input
4 6 2
Output
2
Input
3 10 3
Output
4
Input
3 6 1
Output
3
Note
In the first example Frodo can have at most two pillows. In this case, he can give two pillows to the hobbit on the first bed, and one pillow to each of the hobbits on the third and the fourth beds.
In the second example Frodo can take at most four pillows, giving three pillows to each of the others.
In the third example Frodo can take three pillows, giving two pillows to the hobbit in the middle and one pillow to the hobbit on the third bed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k, var, Min, ans, Term, Max;
cin >> n >> m >> k;
if (n == m)
cout << "1";
else {
ans = 2;
Min = min(k - 1, n - k);
Max = max(k - 1, n - k);
m = m - n - 1;
if (m > 0 && m <= ((Min * (6 + (Min - 1) * 2)) / 2)) {
var = ((-2) + sqrt(4 + (4 * m))) / 2;
if (m >= ((var * (6 + (var - 1) * 2)) / 2)) {
if (var > Min) var = Min;
ans = ans + var;
} else {
var--;
if (var > Min) var = Min;
ans = ans + var;
}
} else {
ans = ans + Min;
if (Min != 0) {
m = m - (Min * (6 + (Min - 1) * 2)) / 2;
Term = 3 + (Min - 1) * 2 + 1;
} else {
Term = 2;
}
Min = Max - Min;
if (m > 0 && m <= (Min * (2 * Term + (Min - 1) * 1)) / 2) {
var = ((-(2 * Term - 1)) +
sqrt((2 * Term - 1) * (2 * Term - 1) + 8 * m)) /
2;
if (m >= (var * (2 * Term + (var - 1) * 1)) / 2) {
if (var > Min) var = Min;
ans = ans + var;
} else {
var--;
if (var > Min) var = Min;
ans = ans + var;
}
} else {
ans = ans + Min;
m = m - (Min * (2 * Term + (Min - 1) * 1)) / 2;
Term = Term + (Min - 1) * 1;
ans = ans + (m / Term);
}
}
cout << ans;
}
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
A state with $n$ flags of ON or OFF can be represented by a sequence of bits where $0, 1, ..., n-1$ th flag corresponds to 1 (ON) or 0 (OFF). The state can be managed by the corresponding decimal integer, because the sequence of bits is a binary representation where each bit is 0 or 1.
On the other hand, a mask is a special bit sequence which can be used to set specified bits of a given bit sequence to ON/OFF. It can also be used to extract/exclude a bit sequence based on a specified pattern.
Given a sequence of bits with 64 flags which represent a state, perform the following operations using a set of pre-defined masks. Note that each flag of the bits is initialized by OFF.
* test(i): Print 1 if $i$-th flag is ON, otherwise 0
* set(m): Set flags specified by mask $m$ to ON
* clear(m): Set flags specified by mask $m$ to OFF
* flip(m): Inverse flags specified by mask $m$
* all(m): Print 1 if all flags specified by mask $m$ are ON, otherwise 0
* any(m): Print 1 if at least one flag specified by mask $m$ is ON, otherwise 0
* none(m): Print 1 if all flags specified by mask $m$ are OFF, otherwise 0
* count(m): Print the number of flags specifed by mask $m$ with ON
* val(m): Print the decimal value of the state specified by mask $m$
Constraints
* $1 \leq n \leq 10$
* $1 \leq k \leq 64$
* $1 \leq q \leq 200,000$
* $0 \leq i < 64$
* $0 \leq m < n$
Input
The input is given in the following format.
$n$
$mask_0$
$mask_1$
:
$mask_{n-1}$
$q$
$query_1$
$query_2$
:
$query_q$
$n$ represents the number of masks. $mask_i$ represents state of $i$-th mask and is given in the following format:
$k$ $b_0$ $b_1$ ... $b_k$
$k$ is the number of ON in the bits. The following $k$ integers $b_j$ show that $b_j$-th bit is ON.
$query_i$ represents $i$-th query and is given in the following format:
0 $i$
or
1 $m$
or
2 $m$
or
3 $m$
or
4 $m$
or
5 $m$
or
6 $m$
or
7 $m$
or
8 $m$
The first digit 0, 1,...,8 represents the operation test(i), set(m), clear(m), flip(m), all(m), any(m), none(m), count(m) or val(m) respectively.
Output
Print the result in a line for each test, all, any, none, count and val operation.
Example
Input
3
3 0 1 3
1 3
3 0 1 2
8
1 0
2 1
3 1
4 2
5 2
6 2
7 2
8 2
Output
0
1
0
2
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(n) (n).begin(), (n).end()
int main()
{
int n, q;
cin >> n;
vector<bitset<64>> mask(n);
bitset<64> bit;
rep(i, n)
{
int k;
int flag;
cin >> k;
rep(j, k)
{
cin >> flag;
mask[i] |= (1LL << flag);
}
}
cin >> q;
rep(n, q)
{
ll que, i, m;
cin >> que;
if (que == 0)
cin >> i;
else
cin >> m;
switch (que) {
case 0://test
//(bit & (1LL << i))
cout << bit.test(i) << endl;
break;
case 1://set
bit |= mask[m];
break;
case 2://clear
bit &= ~(mask[m]);
break;
case 3:
//XOR_ 0 0 = 0, 0 1 = 1, 1 1=0,
bit ^= mask[m];
break;
case 4:
cout << ((bit & mask[m]) == mask[m]) << endl;
break;
case 5:
cout << (bit & mask[m]).any() << endl;
break;
case 6:
cout << (bit & mask[m]).none() << endl;
break;
case 7:
cout << (bit & mask[m]).count() << endl;
break;
case 8:
cout << (bit & mask[m]).to_ulong() << endl;
break;
}
}
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Igor likes hexadecimal notation and considers positive integer in the hexadecimal notation interesting if each digit and each letter in it appears no more than t times. For example, if t = 3, then integers 13a13322, aaa, abcdef0123456789 are interesting, but numbers aaaa, abababab and 1000000 are not interesting.
Your task is to find the k-th smallest interesting for Igor integer in the hexadecimal notation. The integer should not contain leading zeros.
Input
The first line contains the two integers k and t (1 ≤ k ≤ 2·109, 1 ≤ t ≤ 10) — the number of the required integer and the maximum number of times some integer or letter can appear in interesting integer.
It can be shown that the answer always exists for such constraints.
Output
Print in the hexadecimal notation the only integer that is the k-th smallest interesting integer for Igor.
Examples
Input
17 1
Output
12
Input
1000000 2
Output
fca2c
Note
The first 20 interesting integers if t = 1: 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 10, 12, 13, 14, 15. So the answer for the first example equals 12.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int inf = 1e9 + 7;
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0') ch = getchar();
while (ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
}
long long ans[8][10000] = {
{},
{},
{10000000ll, 684262ll, 1818416ll, 2917177ll, 4262765ll,
5595204ll, 6693165ll, 8038807ll, 9139198ll, 10469239ll,
11816120ll, 12914223ll, 14269578ll, 15603427ll, 16702159ll,
18047800ll, 19380159ll, 20478181ll, 21823788ll, 22922519ll,
24267412ll, 25599831ll, 26698541ll, 28044152ll, 29780437ll,
31416441ll, 36280998ll, 39579622ll, 41325881ll, 43047046ll,
45027197ll, 46773364ll, 48520257ll, 50499710ll, 52233770ll,
54098466ll, 55959757ll, 57706651ll, 59699964ll, 61420486ll,
63171190ll, 65160646ll, 66906872ll, 68626738ll, 70620047ll,
72613361ll, 74099948ll, 76333503ll, 78332881ll, 79819609ll,
85648774ll, 87983741ll, 89963160ll, 91464362ll, 93431318ll,
95437098ll, 97100413ll, 98903165ll, 100883315ll, 102630874ll,
104363821ll, 106353279ll, 108090918ll, 109837175ll, 111810100ll,
113563491ll, 115542916ll, 117175732ll, 119024572ll, 121262581ll,
122764405ll, 124730006ll, 126735643ll, 130021788ll, 134395030ll,
136386589ll, 138366708ll, 140085237ll, 141834159ll, 143826755ll,
145573646ll, 147308010ll, 149286829ll, 151033663ll, 152780554ll,
154753661ll, 156494405ll, 158477722ll, 160230483ll, 161963925ll,
163947095ll, 165941048ll, 167683968ll, 169666729ll, 171400425ll,
173134150ll, 175127321ll, 179386105ll, 183070787ll, 184791402ll,
186770221ll, 188504555ll, 190251212ll, 192230873ll, 193977796ll,
195712823ll, 197690946ll, 199425303ll, 201417960ll, 203166531ll,
204897885ll, 206877975ll, 208625324ll, 210365139ll, 212596941ll,
214378737ll, 216100658ll, 218070218ll, 220037167ll, 221546806ll,
223530778ll, 228753836ll, 231693779ll, 233196248ll, 235161146ll,
237141297ll, 238697638ll, 240640740ll, 242614507ll, 244348094ll,
246108292ll, 248087042ll, 249821538ll, 251566217ll, 253534595ll,
255280920ll, 257429429ll, 259213766ll, 261000456ll, 262990524ll,
264644268ll, 266460561ll, 268441288ll, 269992569ll, 272143804ll,
278118380ll, 280095962ll, 281765127ll, 283578803ll, 285545444ll,
287292318ll, 289040470ll, 291018040ll, 292752352ll, 294512412ll,
296491865ll, 298225593ll, 300217548ll, 302202761ll, 303945227ll,
305937240ll, 307671604ll, 309414230ll, 311386514ll, 313144784ll,
314878491ll, 316844135ll, 318849952ll, 321511563ll, 326510075ll,
328491580ll, 330469176ll, 331982610ll, 333962761ll, 335830294ll,
337443295ll, 339433413ll, 341249439ll, 343148467ll, 344890856ll,
346675283ll, 348868089ll, 350602514ll, 352362601ll, 354328495ll,
356075084ll, 357809156ll, 359788211ll, 361780828ll, 363281995ll,
365262149ll, 367254069ll, 371924674ll, 374913551ll, 376906199ll,
378885144ll, 380385516ll, 382366215ll, 384345672ll, 386092591ll,
387826724ll},
{10000000ll, 30150ll, 103656ll, 157030ll, 244418ll, 297965ll,
385397ll, 439739ll, 526333ll, 614472ll, 668684ll, 755406ll,
809620ll, 896121ll, 950599ll, 1038030ll, 1116876ll, 1178966ll,
1265157ll, 1319683ll, 1407250ll, 1460440ll, 1547962ll, 1602494ll,
1688675ll, 1776153ll, 1829432ll, 1989918ll, 2063980ll, 2616461ll,
2977822ll, 3117791ll, 3260113ll, 3334566ll, 3475818ll, 3567409ll,
3691300ll, 3801023ll, 3908068ll, 4043942ll, 4144704ll, 4264322ll,
4373242ll, 4480336ll, 4588680ll, 4721902ll, 4810971ll, 4945495ll,
5052554ll, 5162278ll, 5299376ll, 5377716ll, 5519012ll, 5593155ll,
5767448ll, 5878902ll, 5984222ll, 6499622ll, 6890963ll, 7037907ll,
7145131ll, 7253388ll, 7393572ll, 7468872ll, 7611330ll, 7719847ll,
7826941ll, 7935677ll, 8044872ll, 8180067ll, 8292150ll, 8399203ll,
8508876ll, 8617307ll, 8724322ll, 8864369ll, 8947731ll, 9081055ll,
9189533ll, 9297918ll, 9469221ll, 9546310ll, 9687563ll, 9763042ll,
9903045ll, 10382858ll, 10773491ll, 10955568ll, 11033580ll, 11173590ll,
11280644ll, 11389030ll, 11529034ll, 11605805ll, 11745765ll, 11854240ll,
11962545ll, 12070961ll, 12180335ll, 12316827ll, 12427749ll, 12534801ll,
12643231ll, 12752902ll, 12860006ll, 12999967ll, 13083997ll, 13249728ll,
13358126ll, 13466468ll, 13605206ll, 13681908ll, 13823097ll, 13993474ll,
14643087ll, 14875683ll, 14953745ll, 15091122ll, 15169228ll, 15308922ll,
15416328ll, 15526002ll, 15664719ll, 15742464ll, 15881405ll, 15989875ll,
16098180ll, 16205320ll, 16326511ll, 16453590ll, 16563346ll, 16671823ll,
16778785ll, 16921504ll, 17028556ll, 17168551ll, 17246621ll, 17384044ll,
17493678ll, 17602065ll, 17740779ll, 17876682ll, 18525577ll, 18756589ll,
18870029ll, 19011242ll, 19089343ll, 19226775ll, 19333863ll, 19443493ll,
19551925ll, 19661611ll, 19800314ll, 19908703ll, 20015757ll, 20125435ll,
20233910ll, 20340914ll, 20481895ll, 20581777ll, 20731932ll, 20840372ll,
20947378ll, 21080615ll, 21165091ll, 21304158ll, 21382264ll, 21519685ll,
21657188ll, 21759211ll, 22407491ll, 22650232ll, 22790142ll, 22899821ll,
23006957ll, 23146966ll, 23223735ll, 23362404ll, 23472083ll, 23580471ll,
23687566ll, 23796307ll, 23935913ll, 24044346ll, 24152688ll, 24261038ll,
24402460ll, 24509476ll, 24649558ll, 24727222ll, 24866335ll, 24975574ll,
25083019ll, 25224317ll, 25299797ll, 25439798ll, 25517950ll, 25655283ll,
26276380ll, 26569050ll, 26710300ll},
{10000000ll, 760ll, 4106ll, 5636ll, 9442ll, 10968ll,
14778ll, 16361ll, 20114ll, 23745ll, 25446ll, 29200ll,
30832ll, 34534ll, 36168ll, 39866ll, 41504ll, 45254ll,
48957ll, 50532ll, 54284ll, 55864ll, 59638ll, 61197ll,
65010ll, 66953ll, 70343ll, 78258ll, 80967ll, 127491ll,
151151ll, 160647ll, 164604ll, 169581ll, 175777ll, 178516ll,
185246ll, 187504ll, 194121ll, 198618ll, 203055ll, 207553ll,
212049ll, 218662ll, 223159ll, 227596ll, 232092ll, 236590ll,
241026ll, 247699ll, 250071ll, 256632ll, 261189ll, 265567ll,
274531ll, 276685ll, 283408ll, 285610ll, 342938ll, 360914ll,
365405ll, 372019ll, 374339ll, 381009ll, 385264ll, 389945ll,
394442ll, 398880ll, 405436ll, 409514ll, 414484ll, 418982ll,
423419ll, 427915ll, 432558ll, 436791ll, 443523ll, 447900ll,
452456ll, 456894ll, 461390ll, 470237ll, 472559ll, 479173ll,
481553ll, 488107ll, 534741ll, 558168ll, 567900ll, 570222ll,
576834ll, 581337ll, 585768ll, 591802ll, 594704ll, 601374ll,
605813ll, 610308ll, 614746ll, 619252ll, 623740ll, 630234ll,
634848ll, 639345ll, 643842ll, 648279ll, 654528ll, 657213ll,
666121ll, 668444ll, 675054ll, 679546ll, 683934ll, 690660ll,
692863ll, 750142ll, 765985ll, 772658ll, 777158ll, 781591ll,
788205ll, 790585ll, 797139ll, 801694ll, 806131ll, 810628ll,
815126ll, 821681ll, 826235ll, 830672ll, 835168ll, 839606ll,
844043ll, 850715ll, 852977ll, 861885ll, 866251ll, 870875ll,
875316ll, 879812ll, 886424ll, 888806ll, 895359ll, 908260ll,
964298ll, 975152ll, 977416ll, 984086ll, 986408ll, 993020ll,
997464ll, 1001956ll, 1006920ll, 1010891ll, 1017502ll, 1021999ll,
1026496ll, 1030933ll, 1035429ll, 1039909ll, 1046539ll, 1052791ll,
1057707ll, 1062263ll, 1066642ll, 1072965ll, 1075636ll, 1082308ll,
1084560ll, 1091182ll, 1095911ll, 1100115ll, 1157240ll, 1173239ll,
1179909ll, 1182231ll, 1188845ll, 1193404ll, 1197837ll, 1204391ll,
1206771ll, 1213325ll, 1217881ll, 1222323ll, 1226815ll, 1231313ll,
1237925ll, 1242419ll, 1249095ll, 1253531ll, 1258028ll, 1262465ll,
1269137ll, 1271459ll, 1278072ll, 1282453ll, 1287005ll, 1293671ll,
1296058ll, 1302612ll, 1315509ll},
{10000000ll, 8ll, 96ll, 114ll, 208ll, 226ll, 320ll, 339ll,
432ll, 522ll, 544ll, 637ll, 656ll, 749ll, 768ll, 861ll,
880ll, 973ll, 1065ll, 1085ll, 1178ll, 1197ll, 1290ll, 1309ll,
1402ll, 1427ll, 1514ll, 1751ll, 1787ll, 4429ll, 5186ll, 5454ll,
5544ll, 5659ll, 5766ll, 5863ll, 6040ll, 6069ll, 6246ll, 6348ll,
6451ll, 6553ll, 6656ll, 6833ll, 6935ll, 7038ll, 7140ll, 7244ll,
7345ll, 7523ll, 7550ll, 7727ll, 7828ll, 7932ll, 8183ll, 8212ll,
8388ll, 8417ll, 11412ll, 11977ll, 12085ll, 12261ll, 12290ll, 12466ll,
12559ll, 12671ll, 12774ll, 12876ll, 12989ll, 13082ll, 13257ll, 13360ll,
13462ll, 13566ll, 13668ll, 13771ll, 13947ll, 14050ll, 14152ll, 14256ll,
14357ll, 14610ll, 14638ll, 14815ll, 14843ll, 15019ll, 17595ll, 18357ll,
18686ll, 18715ll, 18891ll, 18992ll, 19096ll, 19199ll, 19302ll, 19478ll,
19574ll, 19683ll, 19786ll, 19889ll, 19991ll, 20152ll, 20211ll, 20373ll,
20474ll, 20578ll, 20680ll, 20783ll, 21034ll, 21063ll, 21239ll, 21337ll,
21445ll, 21622ll, 21650ll, 24590ll, 25141ll, 25317ll, 25420ll, 25521ll,
25698ll, 25727ll, 25903ll, 26006ll, 26108ll, 26211ll, 26314ll, 26419ll,
26589ll, 26695ll, 26798ll, 26902ll, 27003ll, 27172ll, 27208ll, 27461ll,
27489ll, 27665ll, 27767ll, 27870ll, 28046ll, 28076ll, 28251ll, 28574ll,
31526ll, 31917ll, 31948ll, 32124ll, 32153ll, 32329ll, 32432ll, 32535ll,
32637ll, 32739ll, 32915ll, 33018ll, 33120ll, 33223ll, 33326ll, 33429ll,
33604ll, 33641ll, 33885ll, 33989ll, 34090ll, 34194ll, 34295ll, 34473ll,
34501ll, 34678ll, 34710ll, 34882ll, 37757ll, 38373ll, 38549ll, 38578ll,
38754ll, 38857ll, 38960ll, 39136ll, 39165ll, 39341ll, 39444ll, 39547ll,
39649ll, 39752ll, 39854ll, 40031ll, 40208ll, 40311ll, 40413ll, 40516ll,
40620ll, 40722ll, 40897ll, 40927ll, 41102ll, 41206ll, 41308ll, 41485ll,
41741ll},
{10000000ll, 0ll, 1ll, 1ll, 2ll, 2ll, 3ll, 3ll, 4ll, 5ll,
5ll, 6ll, 6ll, 7ll, 7ll, 8ll, 8ll, 9ll, 10ll, 10ll,
11ll, 11ll, 12ll, 12ll, 13ll, 13ll, 14ll, 17ll, 17ll, 97ll,
107ll, 110ll, 111ll, 112ll, 113ll, 114ll, 116ll, 116ll, 118ll, 119ll,
120ll, 121ll, 122ll, 124ll, 125ll, 126ll, 127ll, 128ll, 129ll, 131ll,
131ll, 133ll, 134ll, 135ll, 138ll, 138ll, 140ll, 140ll, 224ll, 232ll,
233ll, 235ll, 235ll, 237ll, 238ll, 239ll, 240ll, 241ll, 242ll, 243ll,
245ll, 246ll, 247ll, 248ll, 249ll, 250ll, 252ll, 253ll, 254ll, 255ll,
256ll, 259ll, 259ll, 261ll, 261ll, 263ll, 342ll, 352ll, 356ll, 356ll,
358ll, 359ll, 360ll, 361ll, 362ll, 364ll, 365ll, 366ll, 367ll, 368ll,
369ll, 371ll, 371ll, 373ll, 374ll, 375ll, 376ll, 377ll, 380ll, 380ll,
382ll, 383ll, 384ll, 386ll, 386ll, 470ll, 477ll, 479ll, 480ll, 481ll,
483ll, 483ll, 485ll, 486ll, 487ll, 488ll, 489ll, 490ll, 492ll, 493ll,
494ll, 495ll, 496ll, 498ll, 498ll, 501ll, 501ll, 503ll, 504ll, 505ll,
507ll, 507ll, 509ll, 513ll, 597ll, 602ll, 602ll, 604ll, 604ll, 606ll,
607ll, 608ll, 609ll, 610ll, 612ll, 613ll, 614ll, 615ll, 616ll, 617ll,
619ll, 619ll, 622ll, 623ll, 624ll, 625ll, 626ll, 628ll, 628ll, 630ll,
630ll, 632ll, 715ll, 723ll, 725ll, 725ll, 727ll, 728ll, 729ll, 731ll,
731ll, 733ll, 734ll, 735ll, 736ll, 737ll, 738ll, 740ll, 742ll, 743ll,
744ll, 745ll, 746ll, 747ll, 749ll, 749ll, 751ll, 752ll, 753ll, 755ll,
758ll},
{10000000ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll,
0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll, 0ll,
0ll, 0ll, 0ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll,
1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 1ll,
1ll, 1ll, 1ll, 1ll, 1ll, 1ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll,
2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll,
2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 2ll, 3ll, 3ll, 3ll, 3ll, 3ll,
3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll,
3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 3ll, 4ll, 4ll,
4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll,
4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll, 4ll,
4ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll,
5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll, 5ll,
5ll, 5ll, 5ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll,
6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll, 6ll,
6ll, 6ll, 6ll, 6ll, 6ll, 6ll}};
int cnt[20];
long long n, k;
long long ans1[] = {
5889660ll, 16563930ll, 9566218ll, 33777501ll, 13344800ll,
51215614ll, 17266740ll, 69336796ll, 21220602ll, 87717409ll,
24981876ll, 105098648ll, 28756217ll, 122655178ll, 32710740ll,
140902108ll, 36636420ll, 159170541ll, 40483190ll, 177009278ll,
44329310ll, 194842446ll, 48171900ll, 212598489ll, 52012958ll,
230346360ll, 55840249ll, 248108075ll, 59613300ll, 265660814ll,
61932152ll, 283716200ll, 62311740ll, 303033803ll, 64713480ll,
323629037ll, 67123089ll, 342032005ll, 69514396ll, 360401056ll,
71898900ll, 378601180ll, 74254650ll, 396708350ll, 76600140ll,
414698238ll, 78915030ll, 432508909ll, 81184063ll, 450072427ll,
83542569ll, 468133135ll, 85901840ll, 486184242ll, 88164951ll,
503793375ll, 90419820ll, 521067706ll, 92593860ll, 540147420ll,
95081110ll, 559188272ll, 96751860ll, 570350778ll, 98090340ll,
598450157ll, 100412131ll, 616306093ll, 102698295ll, 633902959ll,
104996580ll, 651558603ll, 107276664ll, 669119322ll, 109553550ll,
686653387ll, 111828620ll, 704254087ll, 114093096ll, 721799023ll,
116365507ll, 739240545ll, 118635810ll, 756748268ll, 120844500ll,
773840058ll, 123006660ll, 790551738ll, 125182583ll, 809656054ll,
127559418ll, 827936047ll, 130015860ll, 846659292ll, 131346420ll,
855563450ll, 132843300ll, 884670172ll, 135182488ll, 902687480ll,
137574274ll, 920988795ll, 139871985ll, 938650478ll, 142210680ll,
956731373ll, 144480750ll, 974168045ll, 146742900ll, 991624924ll,
149075160ll, 1009605630ll, 151269180ll, 1026550970ll, 153457080ll,
1044520924ll, 155696297ll, 1061854492ll, 157826940ll, 1079574236ll,
160303380ll, 1098483454ll, 162676097ll, 1116615077ll, 165049980ll,
1134755548ll, 165940980ll, 1140776122ll, 167789903ll, 1172281468ll,
170087694ll, 1189939599ll, 172350780ll, 1207473901ll, 174718320ll,
1225641963ll, 177084442ll, 1243808121ll, 179412900ll, 1261633244ll,
181693860ll, 1279258042ll, 183912180ll, 1297529598ll, 186235629ll,
1315388175ll, 188477340ll, 1332604090ll, 190638784ll, 1350497304ll,
193015500ll, 1368719068ll, 195371700ll, 1386827757ll, 197704140ll,
1404739565ll, 200119740ll, 1423179467ll, 200574150ll, 1443119085ll,
202916499ll, 1461227567ll, 205209582ll, 1478792159ll, 207547980ll,
1496793854ll, 209861340ll, 1514602204ll, 212118540ll, 1531964874ll,
214280700ll, 1548742074ll, 216515229ll, 1567101455ll, 218756085ll,
1584375885ll, 220981020ll, 1601498571ll, 223143180ll, 1619394268ll,
225483540ll, 1637416668ll, 227831820ll, 1655480301ll, 230142768ll,
1673274655ll, 232473930ll, 1691181035ll, 234808350ll, 1709100986ll,
235168710ll, 1728331757ll, 237459570ll, 1746014189ll, 239728105ll,
1763510261ll, 241984860ll, 1780874972ll, 244220640ll, 1798190589ll,
246465780ll, 1815552510ll, 248697060ll, 1832713914ll, 250914821ll,
1849864653ll, 253182403ll, 1867352597ll, 255295473ll, 1884979663ll,
257666460ll, 1903099339ll, 259840500ll, 1919937995ll, 262108705ll,
1938551116ll, 264490800ll, 1956742142ll, 266826004ll, 1974665682ll,
269123211ll, 1992382772ll, 269724660ll, 1996414138ll, 271794292ll,
2029332960ll, 274120260ll, 2047278812ll, 276369567ll, 2064671327ll,
278617380ll, 2082047742ll, 280854240ll, 2099302379ll, 283149060ll,
2116943034ll, 285358740ll, 2134044107ll, 287485260ll, 2151673291ll,
289840560ll, 2169790718ll, 292219440ll, 2188083181ll, 294506340ll,
2205613788ll, 296751660ll, 2222976459ll, 298939560ll, 2240946157ll,
301247079ll, 2258722319ll, 303523001ll, 2276326162ll, 304319220ll,
2281626810ll, 306056670ll, 2312318956ll, 308287140ll, 2329542347ll,
310475938ll, 2346593527ll, 312716400ll, 2363801562ll, 314923740ll,
2380887804ll, 317137740ll, 2397031337ll, 319454340ll, 2414726057ll,
321662803ll, 2433084539ll, 324004112ll, 2451045380ll, 326311080ll,
2468814829ll, 328601940ll, 2486370012ll, 330912600ll, 2504167405ll,
333282660ll, 2522414812ll, 335653125ll, 2540602463ll, 337923663ll,
2558180975ll, 338913780ll, 2566839482ll, 340303740ll, 2593123787ll,
342620340ll, 2611998152ll, 344936940ll, 2629823912ll, 347229780ll,
2647391912ll, 349448280ll, 2664606971ll, 351640500ll, 2681549548ll,
353798873ll, 2699425490ll, 356197101ll, 2717760670ll, 358458710ll,
2735294189ll, 360740310ll, 2752921581ll, 363076085ll, 2770855433ll,
365430570ll, 2788952574ll, 367734660ll, 2806644444ll, 369576060ll,
2821193436ll, 371904540ll, 2839084764ll, 373508340ll, 2852052152ll,
374268660ll, 2874080713ll, 376468859ll, 2891069368ll, 378664260ll,
2908028619ll, 380836230ll, 2924924411ll, 382996500ll, 2941689564ll,
385160943ll, 2959598682ll, 387570300ll, 2978000877ll, 389898589ll,
2995891688ll, 392231220ll, 3013803740ll, 394512180ll, 3031428553ll,
396793140ll, 3049979609ll, 399062220ll, 3067477706ll, 401342190ll,
3085098954ll, 403598400ll, 3102519257ll, 405856410ll, 3119897324ll,
408037024ll, 3136771588ll, 408206850ll, 3154751469ll, 410364762ll,
3171506895ll, 412611279ll, 3188948749ll, 414875769ll, 3206358286ll,
417023280ll, 3224102740ll, 419362566ll, 3242112607ll, 421637267ll,
3259650280ll, 423974580ll, 3277586138ll, 426231780ll, 3295018715ll,
428487355ll, 3312440292ll, 430769940ll, 3330014938ll, 433017117ll,
3347324579ll, 435284340ll, 3363827130ll, 437588520ll, 3381589211ll,
439869892ll, 3399023959ll, 442131901ll, 3416546561ll, 442697460ll,
3422476952ll, 444490178ll, 3451382281ll, 446712900ll, 3468679832ll,
448875060ll, 3485391512ll, 451037220ll, 3503287209ll, 453199380ll,
3520064425ll, 455459811ll, 3538502607ll, 457678140ll, 3555707817ll,
459919797ll, 3572998958ll, 462228180ll, 3590848203ll, 464449740ll,
3607953082ll, 466766340ll, 3625778874ll, 469082940ll, 3643604666ll,
471375780ll, 3661233867ll, 473667016ll, 3678922010ll, 475414980ll,
3692822185ll, 477125700ll, 3706452632ll, 477292020ll, 3707681432ll,
478836420ll, 3735014312ll, 480616284ll, 3749100584ll, 482116200ll,
3762626044ll, 483932940ll, 3775913146ll, 485786220ll, 3789540265ll,
487591800ll, 3803839196ll, 489380074ll, 3818160576ll, 491248950ll,
3832925691ll, 493021140ll, 3845979578ll, 494778390ll, 3860062155ll,
496597020ll, 3873426345ll, 498540952ll, 3888682532ll, 500398620ll,
3903323595ll, 502453860ll, 3918396602ll, 504249405ll, 3932691295ll,
506109472ll, 3947407088ll, 507902328ll, 3961755524ll, 509759223ll,
3976458908ll, 511732140ll, 3989813912ll, 511886580ll, 3992763032ll,
512874600ll, 4016381387ll, 514333860ll, 4029476282ll, 516210900ll,
4042116009ll, 518146260ll, 4057451498ll, 519858060ll, 4071157195ll,
521640897ll, 4085386590ll, 523535910ll, 4100431580ll, 525409098ll,
4114170158ll, 527176140ll, 4128169146ll, 529089172ll, 4142204113ll,
530847060ll, 4156222921ll, 532581540ll, 4169063610ll, 534384118ll,
4183473267ll, 536086140ll, 4197051851ll, 537832500ll, 4209888152ll,
539628657ll, 4224197694ll, 541382550ll, 4237208537ll, 543178500ll,
4251511994ll, 544943130ll, 4265641692ll, 546481140ll, 4275878552ll,
546481140ll, 4275878552ll, 546481140ll, 4275878552ll, 546481140ll,
4275878552ll, 547449972ll, 4342512382ll, 548437380ll, 4356439772ll,
549461940ll, 4370952173ll, 550472820ll, 4384091595ll, 551571084ll,
4399482815ll, 552658740ll, 4412333242ll, 553777548ll, 4427894267ll,
554819006ll, 4442543523ll, 555890100ll, 4457491915ll, 557039693ll,
4472392882ll, 558153188ll, 4487758767ll, 559200660ll, 4502453946ll,
560311172ll, 4517877711ll, 561370740ll, 4532665803ll, 562542900ll,
4546481065ll, 563778420ll, 4562209705ll, 563778420ll, 4562209705ll,
563778420ll, 4562209705ll, 563778420ll, 4562209705ll, 563778420ll,
4562209705ll, 563778420ll, 4562209705ll, 563778420ll, 4562209705ll,
563778420ll, 4562209705ll, 563778420ll, 4562209705ll, 563778420ll,
4562209705ll, 563778420ll, 4562209705ll, 563778420ll, 4562209705ll,
563778420ll, 4562209705ll, 563778420ll, 4562209705ll, 563778420ll,
4562209705ll, 563778420ll, 4562209705ll, 563778420ll, 4562209705ll,
564538740ll, 4843367883ll, 565013940ll, 4848540858ll, 565013940ll,
4848540858ll, 565562004ll, 4891432190ll, 566573109ll, 4905822768ll,
567761978ll, 4920900410ll, 568815540ll, 4933545419ll, 569987700ll,
4949737180ll, 571049668ll, 4964552589ll, 572063597ll, 4978914800ll,
573092340ll, 4992265675ll, 574177380ll, 5007408860ll, 575286180ll,
5022744284ll, 576304836ll, 5037202430ll, 577432356ll, 5050661868ll,
578414580ll, 5063568297ll, 579567060ll, 5079534239ll, 580624260ll,
5094305227ll, 581590500ll, 5109186268ll, 582311220ll, 5116976314ll,
582699300ll, 5141233372ll, 583546740ll, 5150530746ll, 583736820ll,
5170523595ll, 584893140ll, 5186584284ll, 586073220ll, 5201657564ll,
587211228ll, 5217302702ll, 588242739ll, 5231801388ll, 589354764ll,
5247233022ll, 590389620ll, 5260701131ll, 591555092ll, 5276773647ll,
592585540ll, 5291269855ll, 593571300ll, 5304270829ll, 594757140ll,
5319392971ll, 595790340ll, 5333831593ll, 596828580ll, 5347409353ll,
597838740ll, 5361798876ll, 598701300ll, 5375627245ll, 599608500ll,
5385411770ll, 599849268ll, 5408196606ll, 601034100ll, 5422181835ll,
602079540ll, 5435743418ll, 602165940ll, 5453569995ll, 603148740ll,
5467536843ll, 604149540ll, 5481783276ll, 605090004ll, 5495333886ll,
606178572ll, 5509394686ll, 607306740ll, 5523893707ll, 608416260ll,
5539368941ll, 609587700ll, 5554302410ll, 610586340ll, 5568466908ll,
611641156ll, 5582180415ll, 612646660ll, 5596469903ll, 613524660ll,
5609361372ll, 614641380ll, 5623844572ll, 615670260ll, 5635951529ll,
616809980ll, 5652860267ll, 616905780ll, 5653847226ll, 617861373ll,
5684377155ll, 618895140ll, 5698957020ll, 619923867ll, 5713497323ll,
620612340ll, 5720956090ll, 620992500ll, 5743046091ll, 622012089ll,
5757522169ll, 623042976ll, 5770960052ll, 624035140ll, 5785009871ll,
625030475ll, 5799142396ll, 626118798ll, 5813255570ll, 627170100ll,
5826932170ll, 628286820ll, 5842403034ll, 629356020ll, 5856292026ll,
630436020ll, 5871390411ll, 631528980ll, 5885480890ll, 632595300ll,
5900398026ll, 633569460ll, 5915410140ll, 634203060ll, 5922282682ll,
634678260ll, 5947518411ll, 635818740ll, 5962198475ll, 636914076ll,
5976520190ll, 638004660ll, 5990510027ll, 639078180ll, 6005497564ll,
639145140ll, 6006168762ll, 639926484ll, 6034801406ll, 640950900ll,
6048181707ll, 642091380ll, 6062861771ll, 643056508ll, 6076688543ll,
644150580ll, 6090850012ll, 645112500ll, 6104571882ll, 646234764ll,
6119041790ll, 647136420ll, 6132137675ll, 648166020ll, 6145572026ll,
649166316ll, 6159881453ll, 650264820ll, 6172822441ll, 651254820ll,
6188105419ll, 651500340ll, 6190718138ll, 652226172ll, 6218825982ll,
653250660ll, 6233194204ll, 654358300ll, 6247475423ll, 655420740ll,
6261374684ll, 656524500ll, 6275620828ll, 657507139ll, 6289591485ll,
657677940ll, 6291381434ll, 658496556ll, 6320443294ll, 659824260ll,
6338182875ll, 661095780ll, 6355381979ll, 662367300ll, 6372528108ll,
663604222ll, 6389317506ll, 664900980ll, 6405745577ll, 666231540ll,
6423563177ll, 667530706ll, 6441010649ll, 668797620ll, 6459153594ll,
668995620ll, 6480264924ll, 670372908ll, 6498741756ll, 671735220ll,
6516826059ll, 673036932ll, 6534414158ll, 674309940ll, 6551498187ll,
675545460ll, 6567226827ll, 676210740ll, 6576594106ll, 676911188ll,
6604287567ll, 678206580ll, 6620704203ll, 679537140ll, 6638529993ll,
680867700ll, 6656355753ll, 682191060ll, 6674124474ll, 683441700ll,
6691028154ll, 684677427ll, 6707873227ll, 685948740ll, 6726062044ll,
686189940ll, 6745484747ll, 687499890ll, 6764197579ll, 688801020ll,
6781716478ll, 690110340ll, 6799228636ll, 691385460ll, 6816530140ll,
692675124ll, 6833824509ll, 693938580ll, 6851022829ll, 694743540ll,
6861806778ll, 695327460ll, 6886182893ll, 696604740ll, 6903365340ll,
697845012ll, 6920242942ll, 699143460ll, 6937673708ll, 700428588ll,
6954991098ll, 701681460ll, 6971907258ll, 702877380ll, 6989348572ll,
703392180ll, 6996024505ll, 704448027ll, 7027779741ll, 705768900ll,
7045394140ll, 707055888ll, 7062722261ll, 708334260ll, 7079910585ll,
709613700ll, 7097327597ll, 710889540ll, 7114498012ll, 712135860ll,
7131360715ll, 713276340ll, 7147019448ll, 713427500ll, 7166562158ll,
714700500ll, 7183777497ll, 715951284ll, 7200752894ll, 717210500ll,
7217791503ll, 718439532ll, 7234511068ll, 719596500ll, 7251492572ll,
720689460ll, 7264459945ll, 721227380ll, 7289369358ll, 722520874ll,
7306824813ll, 723809796ll, 7324170988ll, 725124660ll, 7341801180ll,
726416102ll, 7359171795ll, 727679220ll, 7376236525ll, 728932940ll,
7393305503ll, 730193460ll, 7410281928ll, 731428980ll, 7426010568ll,
731809140ll, 7432232088ll, 732759540ll, 7460613528ll, 734074260ll,
7479164568ll, 735318204ll, 7496206554ll, 736607076ll, 7513483756ll,
737818218ll, 7531179881ll, 738081780ll, 7550791098ll, 739325830ll,
7568887446ll, 740677002ll, 7586887898ll, 742004340ll, 7604682733ll,
743291700ll, 7621951466ll, 744567396ll, 7639133181ll, 745829196ll,
7656256766ll, 747086820ll, 7673216730ll, 748328820ll, 7690108905ll,
749581620ll, 7707028905ll, 750341940ll, 7717444248ll, 750847668ll,
7740909051ll, 752074100ll, 7757605791ll, 753299420ll, 7774304782ll,
754454580ll, 7791267820ll, 755284020ll, 7801326505ll, 756123540ll,
7829520057ll, 757436100ll, 7847129068ll, 758722740ll, 7864528875ll,
760011388ll, 7881812415ll, 761271540ll, 7898917801ll, 762507060ll,
7915695017ll, 763742580ll, 7932472233ll, 764994660ll, 7950503883ll,
766227266ll, 7967252328ll, 767449140ll, 7982803608ll, 768684660ll,
7998532248ll, 768874740ll, 8002648728ll, 770015220ll, 8033122968ll,
771250740ll, 8049834648ll, 772486260ll, 8067730345ll, 772676340ll,
8087657658ll, 773919780ll, 8105557451ll, 775234500ll, 8123186362ll,
776512261ll, 8140581824ll, 777800580ll, 8157789370ll, 779057777ll,
8174879498ll, 780314100ll, 8191893468ll, 781571220ll, 8208912348ll,
782865004ll, 8226307885ll, 784125348ll, 8243352829ll, 785411412ll,
8260671418ll, 786639300ll, 8277261225ll, 787407540ll, 8287730328ll,
787844297ll, 8310565384ll, 788999460ll, 8327523786ll, 789878580ll,
8337083305ll, 790622412ll, 8365334747ll, 791890260ll, 8382508491ll,
793204980ll, 8400067769ll, 794516844ll, 8417742926ll, 795740100ll,
8434355932ll, 796959060ll, 8450928074ll, 798202500ll, 8467770826ll,
799420641ll, 8484408694ll, 800631780ll, 8500977372ll, 801948660ll,
8517508248ll, 803174820ll, 8534204088ll, 804395940ll, 8550739128ll,
805583940ll, 8567119033ll, 805940340ll, 8570845848ll, 805940340ll,
8570845848ll, 806969940ll, 8621194938ll, 807175860ll, 8623414458ll,
808457044ll, 8658737247ll, 809741940ll, 8675913163ll, 811052574ll,
8694634324ll, 812346053ll, 8712150609ll, 813656796ll, 8729687806ll,
815024580ll, 8747941596ll, 816260100ll, 8764653276ll, 817514148ll,
8781651023ll, 818853540ll, 8799547355ll, 820152276ll, 8817044734ll,
821455620ll, 8834579915ll, 822784388ll, 8852391966ll, 824092980ll,
8870948298ll, 824473140ll, 8875072698ll, 824568180ll, 8909745611ll,
825898740ll, 8929668555ll, 827229300ll, 8947494347ll, 828559860ll,
8965320139ll, 829890420ll, 8983145931ll, 831265620ll, 9002532845ll,
832639380ll, 9020837596ll, 833952363ll, 9038522329ll, 835314828ll,
9056611578ll, 836604666ll, 9073964394ll, 837917789ll, 9091650384ll,
839212404ll, 9109177820ll, 840534900ll, 9125612457ll, 840534900ll,
9125612457ll, 840534900ll, 9125612457ll, 840534900ll, 9125612457ll,
840534900ll, 9125612457ll, 840534900ll, 9125612457ll, 840534900ll,
9125612457ll, 840534900ll, 9125612457ll, 840534900ll, 9125612457ll,
840534900ll, 9125612457ll, 840534900ll, 9125612457ll, 840534900ll,
9125612457ll, 840534900ll, 9125612457ll, 840534900ll, 9125612457ll,
840875460ll, 9402253020ll, 842182932ll, 9419886446ll, 843005940ll,
9428720826ll, 843005940ll, 9428720826ll, 843947700ll, 9475907514ll,
845252468ll, 9493459407ll, 846553469ll, 9510973808ll, 847806900ll,
9527959516ll, 849136020ll, 9545706955ll, 850410500ll, 9562874124ll,
851679860ll, 9580205087ll, 852935460ll, 9597140973ll, 854228580ll,
9614458571ll, 855551220ll, 9632210106ll, 856786740ll, 9648921786ll,
857983452ll, 9667564030ll, 859265700ll, 9685761756ll, 860303220ll,
9697156282ll, 860873460ll, 9723440587ll, 861538740ll, 9730710714ll,
862409940ll, 9760276187ll, 863703060ll, 9777790955ll, 864999780ll,
9795206859ll, 866264580ll, 9812289919ll, 867542100ll, 9829481931ll,
868785540ll, 9846390219ll, 870046980ll, 9863446492ll, 871319940ll,
9880599465ll, 872594340ll, 9897889466ll, 873888381ll, 9915159472ll,
875129460ll, 9930918825ll, 876458012ll, 9949922878ll, 877600500ll,
9965591738ll, 877808902ll, 9987066545ll, 879121140ll, 10003410379ll,
880071540ll, 10015923386ll, 880562580ll, 10041294556ll, 881843444ll,
10058715054ll, 883128660ll, 10075897564ll, 884443380ll, 10092539339ll,
885586622ll, 10108300915ll, 886863540ll, 10125550655ll, 888126180ll,
10142613210ll, 889386180ll, 10159661036ll, 890611068ll, 10176279375ll,
891823380ll, 10192867035ll, 893014260ll, 10210263021ll, 894360156ll,
10228282878ll, 894897780ll, 10234027194ll, 895796340ll, 10264018925ll,
897109620ll, 10281631724ll, 898406967ll, 10299051172ll, 898604340ll,
10301136058ll, 899816237ll, 10334503905ll, 901095180ll, 10351847678ll,
902366340ll, 10368974556ll, 903649380ll, 10386210524ll, 904905276ll,
10403292414ll, 906178740ll, 10420445164ll, 907436580ll, 10437475787ll,
908678580ll, 10454228154ll, 909819060ll, 10471075275ll, 911170045ll,
10490329296ll, 912195060ll, 10502462650ll, 912670260ll, 10526649803ll,
914006652ll, 10545582590ll, 915292140ll, 10563029246ll, 916606868ll,
10580658975ll, 917137140ll, 10586348730ll, 918030228ll, 10616165630ll,
919299300ll, 10633346778ll, 920611572ll, 10650957566ll, 921871258ll,
10667991433ll, 923152588ll, 10685287391ll, 924399204ll, 10702156235ll,
925690740ll, 10718530473ll, 927021300ll, 10736225193ll, 928209300ll,
10753666507ll, 929492340ll, 10770898106ll, 929682420ll, 10789842379ll,
931012980ll, 10808716747ll, 932301996ll, 10826208254ll, 933646260ll,
10844148799ll, 934972764ll, 10861935341ll, 935669940ll, 10871561402ll,
936335220ll, 10896797131ll, 937652180ll, 10915561743ll, 938933052ll,
10932781566ll, 940183199ll, 10949682452ll, 941428524ll, 10966601823ll,
942669564ll, 10983426045ll, 943906740ll, 11000212939ll, 945094740ll,
11017649884ll, 946464900ll, 11035803355ll, 946789620ll, 11039333562ll,
948124684ll, 11074057903ll, 949403220ll, 11091377884ll, 950686260ll,
11108609483ll, 951921780ll, 11125386699ll, 953176405ll, 11143510880ll,
954202740ll, 11156774074ll, 954557828ll, 11178664383ll, 955861260ll,
11196131582ll, 957106863ll, 11212994308ll, 958321668ll, 11229596751ll,
959553610ll, 11246283915ll, 960790884ll, 11263070700ll, 961944983ll,
11280102215ll, 963317743ll, 11298331461ll, 964086900ll, 11307769017ll,
964891860ll, 11336654829ll, 966234372ll, 11354577150ll, 967546797ll,
11372259088ll, 968823060ll, 11389435577ll, 970134900ll, 11407036380ll,
971397060ll, 11424103609ll, 972617964ll, 11440756989ll, 972735540ll,
11441986744ll, 973852260ll, 11474173384ll, 975095700ll, 11491081624ll,
976373988ll, 11508409836ll, 977653860ll, 11525545144ll, 978913140ll,
11541531544ll, 980243700ll, 11560545738ll, 981384180ll, 11576204457ll,
981769380ll, 11599392749ll, 983045492ll, 11616703951ll, 984345060ll,
11634075215ll, 985605540ll, 11651120860ll, 986896500ll, 11667500490ll,
988205244ll, 11685149438ll, 989511540ll, 11702575085ll, 990753540ll,
11719409372ll, 991268340ll, 11727199384ll, 992099940ll, 11754208984ll,
993384280ll, 11771584007ll, 994605396ll, 11788180733ll, 995883540ll,
11805368028ll, 997045188ll, 11822523902ll, 998370492ll, 11840180478ll,
998681460ll, 11844639657ll, 999807243ll, 11877030074ll, 1001079780ll,
11894243034ll, 1002357924ll, 11911442925ll, 1003661484ll, 11929049854ll,
1004930340ll, 11946163930ll, 1006208004ll, 11963492959ll, 1007496420ll,
11980766937ll, 1008755700ll, 11997801897ll, 1009801140ll, 12012411544ll,
1009991220ll, 12031355817ll, 1011242580ll, 12049317306ll, 1012463772ll,
12065985005ll, 1013602740ll, 12081687738ll, 1014902907ll, 12100259050ll,
1015978740ll, 12113071017ll, 1016507364ll, 12137906686ll, 1017827700ll,
12155580396ll, 1019149620ll, 12173332460ll, 1020450516ll, 12190784766ll,
1021701522ll, 12207756556ll, 1022992980ll, 12225118187ll, 1024267812ll,
12242356222ll, 1025496140ll, 12259006479ll, 1026813300ll, 12275674264ll,
1028032980ll, 12292193944ll, 1028333940ll, 12297616024ll, 1029181380ll,
12324764584ll, 1030414884ll, 12341518827ll, 1031538660ll, 12358225884ll,
1032879729ll, 12376143830ll, 1033276020ll, 12381440937ll, 1034416500ll,
12413029289ll, 1035653460ll, 12430884299ll, 1036956244ll, 12448339485ll,
1038230929ll, 12465712457ll, 1039516332ll, 12482965980ll, 1040757540ll,
12499783644ll, 1041947700ll, 12516122571ll, 1043215188ll, 12533167580ll,
1044395700ll, 12549212824ll, 1045639140ll, 12566265018ll, 1046866740ll,
12582697624ll, 1046940384ll, 12600431815ll, 1048102260ll, 12614154904ll,
1049432820ll, 12634217658ll, 1050573300ll, 12648827817ll, 1050828700ll,
12671736862ll, 1052109780ll, 12688944587ll, 1053424500ll, 12705520826ll,
1054695980ll, 12722871885ll, 1055933556ll, 12739595245ll, 1057172100ll,
12756393692ll, 1058415540ll, 12773236444ll, 1059496980ll, 12788276939ll,
1060629485ll, 12802891328ll, 1061677140ll, 12816407704ll, 1062747060ll,
12831493818ll, 1064002740ll, 12847451834ll, 1065179341ll, 12863484320ll,
1065399540ll, 12865813144ll, 1065399540ll, 12865813144ll, 1066560612ll,
12917778925ll, 1067870580ll, 12935158970ll, 1068018612ll, 12954814974ll,
1069312020ll, 12973178588ll, 1070555565ll, 12990223794ll, 1071886020ll,
13007912668ll, 1073206070ll, 13025593621ll, 1074464436ll, 13042692703ll,
1075784100ll, 13060354029ll, 1076994676ll, 13076867247ll, 1078301220ll,
13094354650ll, 1079607700ll, 13111916910ll, 1080869676ll, 13128979709ll,
1082203484ll, 13146828062ll, 1083448148ll, 13164795951ll, 1083932340ll,
13170039994ll, 1085127612ll, 13203267804ll, 1085325540ll, 13223325660ll,
1086602100ll, 13241552877ll, 1087939860ll, 13259439836ll, 1089272724ll,
13277364990ll, 1090660485ll, 13295786848ll, 1091963220ll, 13313244892ll,
1093288340ll, 13331028079ll, 1094603700ll, 13348730447ll, 1095918936ll,
13366362263ll, 1097229300ll, 13383946153ll, 1098524652ll, 13401354493ll,
1099819596ll, 13418817884ll, 1101055916ll, 13436787855ll, 1102425540ll,
13454929355ll, 1102465140ll, 13455252666ll, 1102665187ll, 13494222493ll,
1103990100ll, 13511995373ll, 1105326420ll, 13529866221ll, 1106662740ll,
13547732700ll, 1107978180ll, 13565435885ll, 1109308020ll, 13582200267ll,
1110638580ll, 13600026059ll, 1111969140ll, 13617851849ll, 1113299700ll,
13635677609ll, 1114593645ll, 13653074304ll, 1115881620ll, 13670415546ll,
1117166964ll, 13687738860ll, 1117291380ll, 13689015209ll, 1117291380ll,
13689015209ll, 1117291380ll, 13689015209ll, 1117291380ll, 13689015209ll,
1117291380ll, 13689015209ll, 1117291380ll, 13689015209ll, 1117291380ll,
13689015209ll, 1117291380ll, 13689015209ll, 1117291380ll, 13689015209ll,
1117291380ll, 13689015209ll, 1117291380ll, 13689015209ll, 1117291380ll,
13689015209ll, 1117291380ll, 13689015209ll, 1117291380ll, 13689015209ll,
1118693940ll, 13978374124ll, 1119952500ll, 13994290635ll, 1120997940ll,
14008900794ll, 1120997940ll, 14008900794ll, 1121591940ll, 14052163292ll,
1122922500ll, 14069989084ll, 1124234844ll, 14087670526ll, 1125546180ll,
14105325532ll, 1126907700ll, 14123409388ll, 1128199380ll, 14140846059ll,
1129473780ll, 14158012380ll, 1130779140ll, 14175566761ll, 1132069396ll,
14192992300ll, 1133337300ll, 14210030761ll, 1134588660ll, 14225886121ll,
1135919220ll, 14244900299ll, 1137249780ll, 14262726091ll, 1138295220ll,
14277336250ll, 1138580340ll, 14297329099ll, 1139530740ll, 14310890682ll,
1140016740ll, 14336229357ll, 1141306980ll, 14353706989ll, 1142607300ll,
14371160045ll, 1143902580ll, 14387506635ll, 1145233140ll, 14405332427ll,
1146500484ll, 14422508286ll, 1147777620ll, 14439755755ll, 1149100476ll,
14457389822ll, 1150355076ll, 14474386172ll, 1151600820ll, 14491245737ll,
1152868020ll, 14509539019ll, 1154200156ll, 14527447775ll, 1155529140ll,
14545186251ll, 1155798420ll, 14564851420ll, 1157113140ll, 14582541771ll,
1158063540ll, 14596103354ll, 1158430340ll, 14618089871ll, 1159718820ll,
14635499228ll, 1161004236ll, 14652752621ll, 1162245300ll, 14669573579ll,
1163480820ll, 14686350794ll, 1164727752ll, 14704283285ll, 1165977229ll,
14721230224ll, 1167226980ll, 14738128331ll, 1168476340ll, 14755152414ll,
1169677140ll, 14772629485ll, 1171004820ll, 14790360796ll, 1172330050ll,
14808083452ll, 1172889780ll, 14814207162ll, 1173847668ll, 14844753644ll,
1175105940ll, 14861783019ll, 1176415620ll, 14879371228ll, 1176596340ll,
14881316026ll, 1177789004ll, 14914528718ll, 1179067380ll, 14931647674ll,
1180328061ll, 14948839313ll, 1181581620ll, 14965829613ll, 1182843060ll,
14982819820ll, 1184096580ll, 14999747770ll, 1185239940ll, 15015431354ll,
1186480500ll, 15031192489ll, 1187775060ll, 15049916397ll, 1189104612ll,
15067736830ll, 1190187060ll, 15082642618ll, 1190404908ll, 15102028751ll,
1191639972ll, 15118802766ll, 1192943220ll, 15136189899ll, 1194178740ll,
15152967115ll, 1195129140ll, 15166528698ll, 1195510092ll, 15188632062ll,
1196776500ll, 15205727964ll, 1198012020ll, 15222505180ll, 1199268201ll,
15239588854ll, 1200507064ll, 15256389241ll, 1201736700ll, 15273116095ll,
1202969940ll, 15289806283ll, 1204134086ll, 15306915234ll, 1205449620ll,
15324614637ll, 1206763620ll, 15342173916ll, 1207484340ll, 15351078074ll,
1208175540ll, 15378755565ll, 1209460416ll, 15396075620ll, 1210733844ll,
15413170686ll, 1211853540ll, 15427679278ll, 1212972732ll, 15442180990ll,
1213661940ll, 15451741370ll, 1213981515ll, 15473204877ll, 1215182580ll,
15488511434ll, 1216423689ll, 15506390407ll, 1217656500ll, 15523147756ll,
1218889140ll, 15538838714ll, 1220124660ll, 15555550394ll, 1221085191ll,
15570596568ll, 1222405620ll, 15587077579ll, 1223736180ll, 15604903371ll,
1224781620ll, 15619513529ll, 1225116518ll, 15642222978ll, 1226411772ll,
15659557117ll, 1227727860ll, 15676206539ll, 1229020692ll, 15693720062ll,
1230327380ll, 15711152495ll, 1231576980ll, 15728049884ll, 1232194740ll,
15736954040ll, 1232821364ll, 15761741071ll, 1234085460ll, 15778881499ll,
1235315220ll, 15795551929ll, 1236585952ll, 15812685575ll, 1237802100ll,
15829228729ll, 1238967492ll, 15846419198ll, 1240270361ll, 15863882345ll,
1241560644ll, 15881249278ll, 1242078900ll, 15887948969ll, 1242938724ll,
15917421310ll, 1244259060ll, 15935155930ll, 1245571620ll, 15952707273ll,
1246856636ll, 15970085999ll, 1248143220ll, 15987414895ll, 1249373220ll,
16004087240ll, 1250624580ll, 16021060760ll, 1250727540ll, 16022166680ll,
1251931308ll, 16055331545ll, 1253142636ll, 16071910090ll, 1254362820ll,
16088489129ll, 1255669620ll, 16104934040ll, 1256878100ll, 16122545758ll,
1258218420ll, 16140582890ll, 1259376180ll, 16156384169ll, 1259661300ll,
16176377274ll, 1260927732ll, 16194662189ll, 1262250636ll, 16212227309ll,
1263492420ll, 16229122029ll, 1264770060ll, 16246441982ll, 1266005220ll,
16263151322ll, 1267304100ll, 16280583899ll, 1268532924ll, 16297302782ll,
1269260340ll, 16307378840ll, 1269844980ll, 16331685866ll, 1271050260ll,
16348085673ll, 1272301620ll, 16365050793ll, 1273433460ll, 16381824954ll,
1274685540ll, 16398745291ll, 1275972180ll, 16416141292ll, 1276673460ll,
16424815529ll, 1277467620ll, 16452562924ll, 1278737268ll, 16469689598ll,
1279995232ll, 16486717620ll, 1281242147ll, 16503596538ll, 1282491276ll,
16520484094ll, 1283715780ll, 16537169900ll, 1284948420ll, 16553922537ll,
1286272500ll, 16570641560ll, 1287525876ll, 16587574014ll, 1287793140ll,
16592583320ll, 1288824664ll, 16621774997ll, 1290021302ll, 16638167457ll,
1291190820ll, 16655252937ll, 1292479620ll, 16672731099ll, 1293817141ll,
16690617008ll, 1293970740ll, 16693185449ll, 1295204820ll, 16726731961ll,
1296488580ll, 16744243147ll, 1297780260ll, 16761552331ll, 1299023700ll,
16778460619ll, 1300235460ll, 16794909882ll, 1301459897ll, 16811591959ll,
1302690660ll, 16828267977ll, 1303902556ll, 16844854495ll, 1305122100ll,
16861494458ll, 1306325940ll, 16877664920ll, 1306325940ll, 16877664920ll,
1307561460ll, 16909122200ll, 1308796980ll, 16927017897ll, 1310135460ll,
16946097611ll, 1311268020ll, 16960572329ll, 1311553140ll, 16981613754ll,
1312825428ll, 17000018094ll, 1314079620ll, 17016942027ll, 1315301460ll,
17033604828ll, 1316574029ll, 17050691216ll, 1317812100ll, 17067486923ll,
1319029620ll, 17084050891ll, 1320300164ll, 17101257326ll, 1321516500ll,
17117736361ll, 1322707380ll, 17134149323ll, 1323932100ll, 17150696634ll,
1324858740ll, 17160780440ll, 1324858740ll, 17160780440ll, 1325349780ll,
17205296860ll, 1326707700ll, 17223417837ll, 1328097372ll, 17241862893ll,
1328565300ll, 17246903482ll, 1329646564ll, 17278934159ll, 1331004660ll,
17296977355ll, 1332271860ll, 17314012346ll, 1333588013ll, 17332846546ll,
1334932980ll, 17350782411ll, 1336230180ll, 17368275343ll, 1337499060ll,
17385385402ll, 1338809316ll, 17404034046ll, 1340082564ll, 17421259517ll,
1341364020ll, 17438535115ll, 1342625100ll, 17456650733ll, 1343391540ll,
17465007290ll, 1344324012ll, 17495339262ll, 1345674660ll, 17513344988ll,
1345863300ll, 17532338157ll, 1347193140ll, 17550011851ll, 1348444500ll,
17568104156ll, 1349664180ll, 17583566283ll, 1350968820ll, 17602232301ll,
1352287290ll, 17619965453ll, 1353560820ll, 17637043658ll, 1354820100ll,
17655135963ll, 1356014580ll, 17670389738ll, 1357267380ll, 17687370938ll,
1358502900ll, 17704082618ll, 1359709116ll, 17722799870ll, 1361066829ll,
17740841043ll, 1361924340ll, 17750219962ll, 1362670260ll, 17778483164ll,
1363159860ll, 17783774394ll, 1364191620ll, 17815191499ll, 1365527940ll,
17833000122ll, 1366840174ll, 17850673249ll, 1368204900ll, 17868848860ll,
1369512420ll, 17886482396ll, 1370778900ll, 17904565980ll, 1372093620ll,
17922256314ll, 1373329140ll, 17939033274ll, 1374580500ll, 17956994507ll,
1375857060ll, 17974304476ll, 1377091212ll, 17992192766ll, 1378448340ll,
18010238940ll, 1379795460ll, 18028204013ll, 1380457140ll, 18035432634ll,
1380457140ll, 18035432634ll, 1381526340ll, 18083937739ll, 1382827380ll,
18101513675ll, 1384124100ll, 18118995403ll, 1385415060ll, 18136366812ll,
1386708052ll, 18153823791ll, 1387999860ll, 18171260909ll, 1389287596ll,
18188531757ll, 1390547220ll, 18205507275ll, 1391836020ll, 18222919644ll,
1393087956ll, 18239830764ll, 1394047860ll, 18252417961ll, 1394047860ll,
18252417961ll, 1394047860ll, 18252417961ll, 1394047860ll, 18252417961ll,
1394047860ll, 18252417961ll, 1394047860ll, 18252417961ll, 1394047860ll,
18252417961ll, 1394047860ll, 18252417961ll, 1394047860ll, 18252417961ll,
1394047860ll, 18252417961ll, 1394047860ll, 18252417961ll, 1394047860ll,
18252417961ll, 1394047860ll, 18252417961ll, 1394047860ll, 18252417961ll,
1394047860ll, 18252417961ll, 1395166956ll, 18537538557ll, 1396525877ll,
18555726835ll, 1397881212ll, 18573951742ll, 1398989940ll, 18589080762ll,
1398989940ll, 18589080762ll, 1399370100ll, 18626899403ll, 1400643596ll,
18646359103ll, 1401940914ll, 18663652060ll, 1403211300ll, 18680839900ll,
1404536820ll, 18698616813ll, 1405808052ll, 18715830269ll, 1407094476ll,
18733032190ll, 1408338420ll, 18749997036ll, 1409594820ll, 18766953931ll,
1410835884ll, 18783844589ll, 1412034972ll, 18801304062ll, 1413364740ll,
18819055324ll, 1414691124ll, 18836853246ll, 1416025860ll, 18854641355ll,
1416287220ll, 18857516218ll, 1417522740ll, 18891070650ll, 1417736580ll,
18910281436ll, 1418987940ll, 18927320796ll, 1420273860ll, 18944581340ll,
1421566260ll, 18962026477ll, 1422844980ll, 18979220938ll, 1424090820ll,
18997147711ll, 1425347700ll, 19014090443ll, 1426601940ll, 19031211996ll,
1427846167ll, 19048071395ll, 1429024020ll, 19065290733ll, 1430341692ll,
19082944765ll, 1431588660ll, 19099807179ll, 1432930020ll, 19118780397ll,
1433584500ll, 19125951674ll, 1434488916ll, 19155984751ll, 1435784820ll,
19173330923ll, 1436055540ll, 19176283322ll, 1437243540ll, 19209317835ll,
1438550340ll, 19226951388ll, 1439801700ll, 19243925212ll, 1441060980ll,
19260964571ll, 1442302572ll, 19277792831ll, 1443544398ll, 19294622451ll,
1444790580ll, 19311480506ll, 1445939700ll, 19326159785ll, 1447270260ll,
19345173963ll, 1448616660ll, 19364183772ll, 1449931380ll, 19380825547ll,
1450881780ll, 19394387130ll, 1451396580ll, 19419037404ll, 1452668460ll,
19436250622ll, 1453923060ll, 19452128715ll, 1454588340ll, 19461495994ll,
1455309060ll, 19489357532ll, 1456584180ll, 19505606091ll, 1457896740ll,
19523280876ll, 1459141620ll, 19540139961ll, 1460372524ll, 19556874191ll,
1461609587ll, 19573599020ll, 1462886612ll, 19590792622ll, 1464098394ll,
19608491819ll, 1465446660ll, 19626458827ll, 1466789460ll, 19644452828ll,
1468143921ll, 19662537191ll, 1468300332ll, 19681147455ll, 1469570940ll,
19698274991ll, 1470887700ll, 19715915484ll, 1472158655ll, 19733050134ll,
1473121140ll, 19746708666ll, 1473461700ll, 19767295708ll, 1474693344ll,
19784039446ll, 1475911140ll, 19800666093ll, 1477136580ll, 19817234123ll,
1478344956ll, 19833783260ll, 1479557380ll, 19850306334ll, 1480745220ll,
19867746285ll, 1482054900ll, 19885190603ll, 1483307700ll, 19903225837ll,
1484644740ll, 19921043164ll, 1485476340ll, 19931258041ll, 1486184820ll,
19958034413ll, 1487472180ll, 19975368139ll, 1488707700ll, 19992145355ll,
1489943220ll, 20008922571ll, 1491178740ll, 20024651211ll, 1491653940ll,
20031921336ll, 1492509300ll, 20059254216ll, 1493744820ll, 20076031416ll,
1494980340ll, 20092808376ll, 1496215860ll, 20109581496ll, 1497451380ll,
20126293176ll, 1498686900ll, 20144188873ll, 1499965124ll, 20162503951ll,
1501324260ll, 20180565705ll, 1502641140ll, 20198272988ll, 1502836980ll,
20217265884ll, 1504096260ll, 20234304970ll, 1505350500ll, 20251308013ll,
1506591780ll, 20268126189ll, 1507819452ll, 20284846334ll, 1509004580ll,
20301009439ll, 1510186740ll, 20317133976ll, 1510236924ll, 20334533374ll,
1511446020ll, 20351024842ll, 1512649860ll, 20367338136ll, 1513870972ll,
20383931804ll, 1515128820ll, 20399901336ll, 1516347060ll, 20417588953ll,
1517393188ll, 20432285546ll, 1518471060ll, 20446314202ll, 1519381860ll,
20459552474ll, 1520070900ll, 20468128681ll, 1520584749ll, 20492774096ll,
1521546846ll, 20504469297ll, 1522585244ll, 20519096943ll, 1523686380ll,
20534298349ll, 1524783480ll, 20549534582ll, 1525963380ll, 20564667816ll,
1527103860ll, 20579347896ll, 1528237140ll, 20595019482ll, 1528719540ll,
20602346136ll, 1529131380ll, 20624703162ll, 1530335220ll, 20640160681ll,
1531481033ll, 20655941401ll, 1532528754ll, 20671756730ll, 1533756660ll,
20687350970ll, 1535000100ll, 20704198347ll, 1536121596ll, 20719634750ll,
1537278900ll, 20735635147ll, 1537368180ll, 20736560041ll, 1538484900ll,
20768816313ll, 1539649140ll, 20783819689ll, 1540863276ll, 20800287486ll,
1541972972ll, 20815698239ll, 1543130780ll, 20831566607ll, 1544369460ll,
20847328971ll, 1545501161ll, 20862987270ll, 1546634580ll, 20878655162ll,
1547252340ll, 20887550616ll, 1547663460ll, 20909903802ll, 1548834852ll,
20924972588ll, 1549809780ll, 20939919290ll, 1551053940ll, 20955782330ll,
1552226180ll, 20971984191ll, 1553429940ll, 20988152745ll, 1554639252ll,
21004720092ll, 1554689220ll, 21022113227ll, 1555869300ll, 21038226618ll,
1557041460ll, 21053295529ll, 1558269060ll, 21069888425ll, 1559404788ll,
21085639675ll, 1560467299ll, 21100528157ll, 1561537831ll, 21114371954ll,
1562458740ll, 21126700201ll, 1563337860ll, 21139553722ll, 1564454580ll,
21153954456ll, 1565681460ll, 21169418136ll, 1565785140ll, 21172632216ll,
1566640500ll, 21199965096ll, 1567664340ll, 21215592155ll, 1568839092ll,
21231741421ll, 1570020844ll, 21247938077ll, 1571186076ll, 21263868635ll,
1571962740ll, 21272316841ll, 1572399996ll, 21297243117ll, 1573626660ll,
21312900828ll, 1574813940ll, 21327961274ll, 1575945780ll, 21343620794ll,
1577060340ll, 21359136476ll, 1578164100ll, 21374430667ll, 1579374420ll,
21389745336ll, 1580448796ll, 21404807630ll, 1581640980ll, 21419978136ll,
1582723860ll, 21435162315ll, 1583803140ll, 21450185914ll, 1584317940ll,
21455747736ll, 1584317940ll, 21455747736ll, 1584843436ll, 21500685983ll,
1586088132ll, 21517540094ll, 1587328980ll, 21534355437ll, 1588568820ll,
21551169517ll, 1589260020ll, 21558647994ll, 1589841780ll, 21585104877ll,
1591029780ll, 21601415149ll, 1592301300ll, 21617438155ll, 1592966580ll,
21625756858ll, 1594162500ll, 21642145227ll, 1594962420ll, 21653089739ll,
1595817780ll, 21664624074ll, 1596750900ll, 21678112746ll, 1597908660ll,
21692865449ll, 1598954100ll, 21706566569ll, 1600163907ll, 21723001817ll,
1601344185ll, 21739255959ll, 1602508020ll, 21756362733ll, 1602850740ll,
21759974586ll, 1603999140ll, 21792615883ll, 1605241880ll, 21809520761ll,
1606478100ll, 21826301387ll, 1606557300ll, 21827083450ll, 1607628355ll,
21858892493ll, 1608822420ll, 21875195578ll, 1610054132ll, 21891939087ll,
1611279150ll, 21908632164ll, 1612498092ll, 21925208318ll, 1613690688ll,
21941495782ll, 1614920820ll, 21957176745ll, 1616132580ll, 21973630665ll,
1617346500ll, 21990227932ll, 1618492636ll, 22006000749ll, 1619482740ll,
22021139915ll, 1620591684ll, 22036612350ll, 1621383540ll, 22045187258ll,
1621668660ll, 22067277259ll, 1622883803ll, 22082849788ll, 1623854580ll,
22095518906ll, 1624075836ll, 22116037869ll, 1625280180ll, 22131240395ll,
1626515700ll, 22148017611ll, 1627602900ll, 22163247085ll, 1628764908ll,
22179146971ll, 1629968820ll, 22195531211ll, 1631110740ll, 22211338204ll,
1632273573ll, 22227255683ll, 1633540020ll, 22243360681ll, 1634637338ll,
22258614428ll, 1635734580ll, 22273776826ll, 1636818900ll, 22290100188ll,
1637941668ll, 22305622014ll, 1639060260ll, 22321028811ll, 1639916340ll,
22330399930ll, 1640379868ll, 22355549407ll, 1641151860ll, 22363954362ll,
1641623572ll, 22389170590ll, 1642784244ll, 22404011262ll, 1644003060ll,
22419598795ll, 1645144548ll, 22435342590ll, 1646362168ll, 22450923623ll,
1647467700ll, 22466297837ll, 1648549140ll, 22481268137ll, 1649708591ll,
22497228436ll, 1650845940ll, 22511872937ll, 1652118582ll, 22529091729ll,
1653322684ll, 22545477164ll, 1654472961ll, 22562404714ll, 1655724596ll,
22579445260ll, 1656976244ll, 22596355871ll, 1658221620ll, 22613209068ll,
1658449140ll, 22615612602ll, 1658449140ll, 22615612602ll, 1659576791ll,
22664802755ll, 1660786476ll, 22681359357ll, 1661997300ll, 22697737675ll,
1663185300ll, 22714056378ll, 1664386625ll, 22730487817ll, 1665585492ll,
22746827262ll, 1666812660ll, 22762483113ll, 1668046740ll, 22779244233ll,
1669239348ll, 22795543549ll, 1670424180ll, 22811696313ll, 1670804340ll,
22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll,
1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll,
22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll,
1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll,
22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll,
1670804340ll, 22815820713ll, 1670804340ll, 22815820713ll, 1670804340ll,
22815820713ll, 1670804340ll, 22815820713ll, 1671628020ll, 23097704156ll,
1672658340ll, 23112323053ll, 1673655540ll, 23124241867ll, 1674796020ll,
23138921931ll, 1675701780ll, 23152119516ll, 1676577588ll, 23164941293ll,
1676981940ll, 23169260730ll, 1676981940ll, 23169260730ll, 1677394455ll,
23207612307ll, 1678362900ll, 23221391341ll, 1679350020ll, 23235263674ll,
1680379620ll, 23249813210ll, 1681409220ll, 23263248092ll, 1682399220ll,
23275236810ll, 1683389604ll, 23289399887ll, 1684366980ll, 23303179995ll,
1685440500ll, 23317179305ll, 1686382764ll, 23330683083ll, 1687341300ll,
23342275770ll, 1688328004ll, 23357602095ll, 1689432180ll, 23371705803ll,
1690422180ll, 23385800139ll, 1691517726ll, 23401023969ll, 1692528900ll,
23415357148ll, 1693518900ll, 23428328907ll, 1694279220ll, 23437696186ll,
1694685300ll, 23458951149ll, 1695514740ll, 23471250618ll, 1695538884ll,
23488371567ll, 1696507788ll, 23502144063ll, 1697450100ll, 23515643885ll,
1698556020ll, 23528992203ll, 1699654020ll, 23543263213ll, 1700660713ll,
23557428201ll, 1701646116ll, 23571471341ll, 1702688616ll, 23585012244ll,
1703716359ll, 23599485284ll, 1704733620ll, 23612808378ll, 1705727580ll,
23627147262ll, 1706755380ll, 23641608173ll, 1707862740ll, 23655747019ll,
1708926900ll, 23670652892ll, 1709974500ll, 23685349357ll, 1710951828ll,
23699330814ll, 1711576500ll, 23706131642ll, 1712051700ll, 23728221643ll,
1713041700ll, 23742316252ll, 1714047540ll, 23756463290ll, 1714047540ll,
23756463290ll, 1714911540ll, 23785967597ll, 1716011484ll, 23800313837ll,
1717057140ll, 23813881564ll, 1718076596ll, 23827234574ll, 1719046196ll,
23841089999ll, 1720073940ll, 23855419322ll, 1721133780ll, 23869239260ll,
1722125940ll, 23882292410ll, 1723108020ll, 23897374428ll, 1724214227ll,
23911708396ll, 1725357300ll, 23926402507ll, 1726467806ll, 23941892050ll,
1727479860ll, 23956094411ll, 1728436980ll, 23969850159ll, 1728873780ll,
23974567098ll, 1729348980ll, 23996657099ll, 1730346900ll, 24010882780ll,
1731376500ll, 24025300700ll, 1732385052ll, 24039603070ll, 1732580340ll,
24041675962ll, 1733340660ll, 24067960267ll, 1734330660ll, 24081923804ll,
1735376248ll, 24095687706ll, 1736366100ll, 24109711034ll, 1737332340ll,
24122485672ll, 1738427100ll, 24137639677ll, 1739383620ll, 24150339019ll,
1740327705ll, 24163989116ll, 1741361417ll, 24178577257ll, 1742488260ll,
24193072860ll, 1743569628ll, 24208047612ll, 1744620500ll, 24222836591ll,
1745655389ll, 24236322032ll, 1746171060ll, 24243002553ll, 1746646260ll,
24265092555ll, 1747731300ll, 24280235740ll, 1748695324ll, 24294051630ll,
1749666516ll, 24307842046ll, 1750637940ll, 24319618507ll, 1751113140ll,
24326888632ll, 1751557330ll, 24348725049ll, 1752601252ll, 24363265311ll,
1753553248ll, 24376840295ll, 1754613780ll, 24390663832ll, 1755654468ll,
24404313085ll, 1756636844ll, 24418282766ll, 1757569082ll, 24431765978ll,
1758621300ll, 24445447626ll, 1759668900ll, 24460152540ll, 1760720100ll,
24474877642ll, 1761852660ll, 24489487817ll, 1762929780ll, 24504434396ll,
1763468340ll, 24511437993ll, 1763852316ll, 24532521982ll, 1764815460ll,
24546316269ll, 1765796820ll, 24560205258ll, 1766794740ll, 24573373897ll,
1767935220ll, 24588053962ll, 1768933124ll, 24602214045ll, 1769645940ll,
24612101272ll, 1769771436ll, 24630322173ll, 1770826020ll, 24645004713ll,
1771926900ll, 24659356312ll, 1772964420ll, 24672861352ll, 1773913740ll,
24686478570ll, 1774882500ll, 24700403693ll, 1775918580ll, 24713883066ll,
1777034409ll, 24729278838ll, 1778033148ll, 24743508970ll, 1779159300ll,
24758005741ll, 1780173276ll, 24772420606ll, 1780765620ll, 24779873193ll,
1781230156ll, 24801878495ll, 1782191414ll, 24815605460ll, 1783204180ll,
24829877166ll, 1784241087ll, 24844427331ll, 1785245508ll, 24857653391ll,
1786254180ll, 24870911705ll, 1787299620ll, 24884477657ll, 1788123300ll,
24896662953ll, 1788178740ll, 24897313432ll, 1788899460ll, 24923078330ll,
1789857780ll, 24935792058ll, 1790855700ll, 24949943738ll, 1791885300ll,
24963299992ll, 1792920581ll, 24978037745ll, 1793944500ll, 24992415435ll,
1794894468ll, 25006109932ll, 1795920101ll, 25019580144ll, 1797010260ll,
25033641675ll, 1797983561ll, 25047460616ll, 1798062900ll, 25048304553ll,
1798886580ll, 25076301515ll, 1799868660ll, 25089273018ll, 1801009140ll,
25103953082ll, 1802021964ll, 25118304508ll, 1802960988ll, 25131699435ll,
1804001460ll, 25145294825ll, 1805040420ll, 25158811338ll, 1806030420ll,
25172901545ll, 1806711540ll, 25182517912ll, 1806798660ll, 25200229289ll,
1807852020ll, 25212992152ll, 1808877844ll, 25227389262ll, 1809796020ll,
25241808860ll, 1810885380ll, 25256918202ll, 1811990724ll, 25271312893ll,
1813041780ll, 25284988892ll, 1814061300ll, 25299311802ll, 1815201780ll,
25313934522ll, 1815360180ll, 25316674473ll, 1816008180ll, 25342820314ll,
1817094084ll, 25356857820ll, 1818147388ll, 25370620205ll, 1819066740ll,
25383783337ll, 1820096340ll, 25397296552ll, 1821157620ll, 25411181752ll,
1822106580ll, 25424801225ll, 1823092980ll, 25437818843ll, 1824060300ll,
25451591420ll, 1825090396ll, 25463914943ll, 1825244340ll, 25467599512ll,
1825719540ll, 25489689513ll, 1826628771ll, 25504107835ll, 1827686580ll,
25516723659ll, 1828711300ll, 25531233070ll, 1829709924ll, 25545327067ll,
1830685380ll, 25559231947ll, 1831802100ll, 25572596922ll, 1832657460ll,
25584061353ll, 1832662975ll, 25602144916ll, 1833768820ll, 25616332926ll,
1834692900ll, 25629617611ll, 1835712564ll, 25643041517ll, 1836775860ll,
25656815051ll, 1837668420ll, 25669900414ll, 1838752612ll, 25683920589ll,
1839785460ll, 25697377432ll, 1840743780ll, 25711144378ll, 1841781300ll,
25724636073ll, 1842777134ll, 25738850564ll, 1843777140ll, 25750715032ll,
1843777140ll, 25750715032ll, 1843777140ll, 25750715032ll, 1844421540ll,
25796894700ll, 1845425436ll, 25811236350ll, 1846628340ll, 25826422219ll,
1847768820ll, 25841102283ll, 1848846595ll, 25856319293ll, 1849954740ll,
25870392506ll, 1849954740ll, 25870392506ll, 1850825940ll, 25900023515ll,
1851865018ll, 25914655693ll, 1852900980ll, 25927085515ll, 1853932206ll,
25941657010ll, 1854965940ll, 25956233197ll, 1856128020ll, 25971023306ll,
1857082740ll, 25983708585ll, 1858203042ll, 25999204248ll, 1859039772ll,
26010591741ll, 1860060660ll, 26024996299ll, 1861074420ll, 26037046185ll,
1862200509ll, 26053788243ll, 1862309940ll, 26054941882ll, 1863200639ll,
26084872421ll, 1864036500ll, 26097155804ll, 1865154804ll, 26111587053ll,
1866306084ll, 26126365694ll, 1867252020ll, 26138827962ll, 1867331843ll,
26156608940ll, 1868403180ll, 26171563342ll, 1869462420ll, 26186354668ll,
1870519812ll, 26201139454ll, 1871636060ll, 26215616350ll, 1872677532ll,
26230262111ll, 1873789188ll, 26244642302ll, 1874823684ll, 26259162366ll,
1875900660ll, 26273041321ll, 1876978910ll, 26287090099ll, 1878023220ll,
26301754826ll, 1878973620ll, 26316504796ll, 1880090340ll, 26331905756ll,
1880842740ll, 26340154554ll, 1881222900ll, 26363293131ll, 1882307652ll,
26377517805ll, 1883417532ll, 26391822590ll, 1884354180ll, 26405195467ll,
1884549300ll, 26407263418ll, 1885295508ll, 26435532285ll, 1886355060ll,
26449276363ll, 1887496076ll, 26465017231ll, 1888547940ll, 26478701471ll,
1889671864ll, 26493241765ll, 1890661380ll, 26507259612ll, 1891677300ll,
26520579497ll, 1892761404ll, 26535651836ll, 1893819300ll, 26550558684ll,
1894908660ll, 26564549818ll, 1895859060ll, 26578251211ll, 1896966500ll,
26592666671ll, 1897981620ll, 26606960075ll, 1899104693ll, 26622414416ll,
1899375540ll, 26625367226ll, 1900064580ll, 26652901084ll, 1901110164ll,
26667647742ll, 1901846580ll, 26675698874ll, 1902155460ll, 26696941276ll,
1903194420ll, 26710650861ll, 1904136716ll, 26724084863ll, 1905210150ll,
26739063329ll, 1906153316ll, 26751588815ll, 1907183364ll, 26765026045ll,
1908212820ll, 26778517210ll, 1909120668ll, 26791665147ll, 1910192494ll,
26805577553ll, 1911192260ll, 26819756575ll, 1912231699ll, 26834382013ll,
1913251380ll, 26847735243ll, 1914296820ll, 26861366731ll, 1915366020ll,
26876308939ll, 1916425525ll, 26891241808ll, 1917435300ll, 26905436141ll,
1917908340ll, 26910579898ll, 1918288500ll, 26931621323ll, 1919143860ll,
26944134330ll, 1919225940ll, 26961928156ll, 1920223860ll, 26976010204ll,
1921136783ll, 26989272658ll, 1922167860ll, 27002785771ll, 1923262260ll,
27016822492ll, 1924319884ll, 27030757150ll, 1925266020ll, 27044212170ll,
1926273940ll, 27058519743ll, 1927292100ll, 27071860714ll, 1928299208ll,
27086027669ll, 1929408180ll, 27099323578ll, 1930309060ll, 27113673791ll,
1931435700ll, 27128032715ll, 1932455796ll, 27142441982ll, 1933431540ll,
27156348636ll, 1934456540ll, 27170806799ll, 1935585780ll, 27183279563ll,
1936441140ll, 27195792570ll, 1936441140ll, 27195792570ll, 1936441140ll,
27195792570ll, 1937408820ll, 27243192300ll, 1938393780ll, 27257307117ll,
1939467940ll, 27271241167ll, 1940559540ll, 27284209372ll, 1941604980ll,
27298954972ll, 1942553004ll, 27312499181ll, 1943569140ll, 27325885865ll,
1944654180ll, 27340897995ll, 1945564980ll, 27352095930ll, 1946733519ll,
27368070834ll, 1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll,
1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll,
27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll,
1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll,
27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll,
1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll,
27379223465ll, 1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll,
1947560820ll, 27379223465ll, 1947560820ll, 27379223465ll, 1948396020ll,
27661262828ll, 1949374500ll, 27675131612ll, 1950507060ll, 27688693195ll,
1951552500ll, 27702324683ll, 1952665260ll, 27717835006ll, 1953726476ll,
27732575502ll, 1954763206ll, 27747173138ll, 1954973940ll, 27749440698ll,
1954973940ll, 27749440698ll, 1955544180ll, 27789356491ll, 1956657850ll,
27804872075ll, 1957583220ll, 27818221549ll, 1958533876ll, 27831665567ll,
1959543636ll, 27846048493ll, 1960685268ll, 27860739582ll, 1961721780ll,
27873242298ll, 1962777300ll, 27888009180ll, 1963721220ll, 27901595356ll,
1964736132ll, 27914831340ll, 1965623460ll, 27928932333ll, 1966677940ll,
27943688831ll, 1967804340ll, 27957128651ll, 1968849780ll, 27970760139ll,
1969816469ll, 27984600178ll, 1970877300ll, 27999337931ll, 1971930660ll,
28014083803ll, 1972271220ll, 28017876154ll, 1972841460ll, 28041014731ll,
1973506740ll, 28051430586ll, 1973639508ll, 28069713150ll, 1974601500ll,
28083430909ll, 1975591067ll, 28097584617ll, 1976643060ll, 28110220746ll,
1977708616ll, 28124028743ll, 1978690420ll, 28138109535ll, 1979639196ll,
28151591660ll, 1980710820ll, 28165503327ll, 1981620532ll, 28178674094ll,
1982630580ll, 28192009675ll, 1983689589ll, 28206878336ll, 1984727057ll,
28220378552ll, 1985782740ll, 28235132363ll, 1986799668ll, 28249576701ll,
1987762740ll, 28262264267ll, 1988808180ll, 28274847179ll, 1989568500ll,
28286311610ll, 1989746340ll, 28305154012ll, 1990742215ll, 28319162805ll,
1991569092ll, 28331517950ll, 1992039540ll, 28336643258ll, 1992609780ll,
28359781835ll, 1993557341ll, 28373393537ll, 1994562420ll, 28387606509ll,
1995591300ll, 28402016219ll, 1996630764ll, 28415600894ll, 1997551860ll,
28426886330ll, 1998632220ll, 28441934061ll, 1999452660ll, 28452965288ll};
inline bool check(long long x) {
memset(cnt, 0, sizeof(cnt));
while (x) {
cnt[x & 15]++;
x >>= 4;
}
for (int i = (0); i <= (15); i++)
if (cnt[i] > k) return 0;
return 1;
}
inline void print(long long x) {
string ans = "";
while (x) {
int t = x & 15;
if (t < 10)
ans = (char)('0' + t) + ans;
else
ans = (char)('a' + t - 10) + ans;
x >>= 4;
}
cout << ans << endl;
}
void solve1() {
long long st = 0;
long long idx = 0;
for (int i = 0; ans1[i]; i += 2) {
if (ans1[i] == 0) break;
if (ans1[i] > n) break;
idx = ans1[i];
st = ans1[i + 1];
}
long long left = n - idx;
while (left) {
st++;
if (check(st)) left--;
}
print(st);
}
int main() {
cin >> n >> k;
if (k >= 8) {
print(n);
return 0;
}
if (k == 1) {
solve1();
return 0;
}
long long rd = n / ans[k][0];
long long st = 0;
if (rd != 0) st = ans[k][rd] + rd * ans[k][0];
long long left = n - 1ll * rd * ans[k][0];
while (left) {
st++;
if (check(st)) left--;
}
print(st);
return 0;
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
A new airplane SuperPuperJet has an infinite number of rows, numbered with positive integers starting with 1 from cockpit to tail. There are six seats in each row, denoted with letters from 'a' to 'f'. Seats 'a', 'b' and 'c' are located to the left of an aisle (if one looks in the direction of the cockpit), while seats 'd', 'e' and 'f' are located to the right. Seats 'a' and 'f' are located near the windows, while seats 'c' and 'd' are located near the aisle.
<image>
It's lunch time and two flight attendants have just started to serve food. They move from the first rows to the tail, always maintaining a distance of two rows from each other because of the food trolley. Thus, at the beginning the first attendant serves row 1 while the second attendant serves row 3. When both rows are done they move one row forward: the first attendant serves row 2 while the second attendant serves row 4. Then they move three rows forward and the first attendant serves row 5 while the second attendant serves row 7. Then they move one row forward again and so on.
Flight attendants work with the same speed: it takes exactly 1 second to serve one passenger and 1 second to move one row forward. Each attendant first serves the passengers on the seats to the right of the aisle and then serves passengers on the seats to the left of the aisle (if one looks in the direction of the cockpit). Moreover, they always serve passengers in order from the window to the aisle. Thus, the first passenger to receive food in each row is located in seat 'f', and the last one — in seat 'c'. Assume that all seats are occupied.
Vasya has seat s in row n and wants to know how many seconds will pass before he gets his lunch.
Input
The only line of input contains a description of Vasya's seat in the format ns, where n (1 ≤ n ≤ 1018) is the index of the row and s is the seat in this row, denoted as letter from 'a' to 'f'. The index of the row and the seat are not separated by a space.
Output
Print one integer — the number of seconds Vasya has to wait until he gets his lunch.
Examples
Input
1f
Output
1
Input
2d
Output
10
Input
4a
Output
11
Input
5e
Output
18
Note
In the first sample, the first flight attendant serves Vasya first, so Vasya gets his lunch after 1 second.
In the second sample, the flight attendants will spend 6 seconds to serve everyone in the rows 1 and 3, then they will move one row forward in 1 second. As they first serve seats located to the right of the aisle in order from window to aisle, Vasya has to wait 3 more seconds. The total is 6 + 1 + 3 = 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long n = s.length();
long long st_row[] = {4, 5, 6, 3, 2, 1};
long long i, m = 0, ans = 0;
for (--n, i = 0; i < n; i++) {
m = m * 10 + (s[i] - '0');
}
ans = (m / 4 - (m % 4 == 0)) * 16 + (m % 4 % 2 == 0 ? 7 : 0) +
st_row[s[n] - 'a'];
cout << ans;
return 0;
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long t, n;
cin >> t;
while (t--) {
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = a[1] - a[0];
for (int i = 2; i < n; i++)
if (a[i] - a[i - 1] < ans) ans = a[i] - a[i - 1];
cout << ans << '\n';
}
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m — the number of elements in the array and number of comparisons made by Vasya (1 ≤ n ≤ 100 000, 0 ≤ m ≤ 100 000).
Each of the following m lines contains two integers a_i, b_i — the positions of the i-th comparison (1 ≤ a_i, b_i ≤ n; a_i ≠ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m;
pair<int, int> p[maxn];
pair<int, int> findpos() {
int a, b, c = 0;
pair<int, int> res;
for (a = 1; a <= n; a++)
for (b = a + 1; b <= n; b++)
if ((res = make_pair(a, b)) != p[++c]) return res;
}
int main() {
cin >> n >> m;
for (int i = 1, a, b; i <= m; i++) {
scanf("%d%d", &a, &b);
p[i] = make_pair(min(a, b), max(a, b));
}
if ((long long)n * (n - 1) / 2 <= (long long)m) {
printf("NO\n");
return 0;
}
printf("YES\n");
sort(p + 1, p + 1 + m);
pair<int, int> pos = findpos();
for (int i = 1, cnt = 0; i <= n; i++) {
if (i == pos.first)
printf("%d ", n - 1);
else if (i == pos.second)
printf("%d ", n);
else
printf("%d ", ++cnt);
}
printf("\n");
for (int i = 1, cnt = 0; i <= n; i++) {
if (i == pos.first)
printf("%d ", n);
else if (i == pos.second)
printf("%d ", n);
else
printf("%d ", ++cnt);
}
printf("\n");
}
```
|
### Prompt
Please create a solution in cpp to the following problem:
One day a highly important task was commissioned to Vasya — writing a program in a night. The program consists of n lines of code. Vasya is already exhausted, so he works like that: first he writes v lines of code, drinks a cup of tea, then he writes as much as <image> lines, drinks another cup of tea, then he writes <image> lines and so on: <image>, <image>, <image>, ...
The expression <image> is regarded as the integral part from dividing number a by number b.
The moment the current value <image> equals 0, Vasya immediately falls asleep and he wakes up only in the morning, when the program should already be finished.
Vasya is wondering, what minimum allowable value v can take to let him write not less than n lines of code before he falls asleep.
Input
The input consists of two integers n and k, separated by spaces — the size of the program in lines and the productivity reduction coefficient, 1 ≤ n ≤ 109, 2 ≤ k ≤ 10.
Output
Print the only integer — the minimum value of v that lets Vasya write the program in one night.
Examples
Input
7 2
Output
4
Input
59 9
Output
54
Note
In the first sample the answer is v = 4. Vasya writes the code in the following portions: first 4 lines, then 2, then 1, and then Vasya falls asleep. Thus, he manages to write 4 + 2 + 1 = 7 lines in a night and complete the task.
In the second sample the answer is v = 54. Vasya writes the code in the following portions: 54, 6. The total sum is 54 + 6 = 60, that's even more than n = 59.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long double n, k;
long long c, i, j, k1, min;
cin >> n >> k;
min = (long long)(n * ((long double)1 - 1.0 / k));
long long k2 = (long long)k;
for (i = min;; i++) {
k1 = i;
c = k1;
while (1) {
if (k1 / k2 == 0)
break;
else
c += k1 / k2;
k1 /= k2;
}
if (c >= n) break;
}
cout << i;
return 0;
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
Example
Input
2
10 10
Output
40.00000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define FOR(i,a,b) for(int i = (a); i < (b); i++)
using vi = vector<int>;
using ll = long long;
const double EPS = 1e-8;
using P = complex<double>;
namespace std{
bool operator <(const P &a, const P &b){
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
double cross(const P &a, const P &b){
return imag(conj(a)*b);
}
double dot(const P &a, const P &b){
return real(conj(a)*b);
}
struct L : public vector<P>{
L(const P &a, const P &b){
push_back(a);
push_back(b);
}
};
struct C{
P p; double r;
C(const P &p_, double r_) : p(p_), r(r_) {}
};
P projection(const L &l, const P &p){
double t = dot(p-l[0],l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
vector<P> crosspointCL(const C &c, const L &l){
P h = projection(l, c.p);
double d = abs(h - c.p);
vector<P> res;
if(d < c.r - EPS){
P dir = l[1]-l[0];
P x = dir / abs(dir) * sqrt(c.r*c.r - d*d);
res.push_back(h + x);
res.push_back(h - x);
}else if(d < c.r + EPS){
res.push_back(h);
}
return res;
}
int main(){
int n; cin >> n;
vector<double> rs(n); rep(i,n) cin >> rs[i];
vector<C> res;
res.push_back(C(P(rs[0],rs[0]),rs[0]));
FOR(i,1,n){ // n番目の円の場所を確定させる
P tmp(rs[i],rs[i]);
rep(j,i){
C tmpc(res[j].p,res[j].r+rs[i]);
// cerr << tmpc.p.real() << " " << tmpc.p.imag() << " " << tmpc.r << endl;
L tmpl(P(0,rs[i]),P(100,rs[i]));
vector<P> cross = crosspointCL(tmpc, tmpl);
sort(cross.begin(), cross.end());
// cerr << cross.back().real() << " " << cross.back().imag() << endl;
tmp = max(tmp, cross.back());
}
res.push_back(C(tmp,rs[i]));
}
double ans = 0;
rep(i,n){
ans = max(ans, res[i].p.real()+res[i].r);
// cerr << i << " " << res[i].p.real() << endl;
}
//cout << ans << endl;
printf("%.10lf\n",ans);
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
Tree is a connected graph without cycles. A leaf of a tree is any vertex connected with exactly one other vertex.
You are given a tree with n vertices and a root in the vertex 1. There is an ant in each leaf of the tree. In one second some ants can simultaneously go to the parent vertex from the vertex they were in. No two ants can be in the same vertex simultaneously except for the root of the tree.
Find the minimal time required for all ants to be in the root of the tree. Note that at start the ants are only in the leaves of the tree.
Input
The first line contains integer n (2 ≤ n ≤ 5·105) — the number of vertices in the tree.
Each of the next n - 1 lines contains two integers xi, yi (1 ≤ xi, yi ≤ n) — the ends of the i-th edge. It is guaranteed that you are given the correct undirected tree.
Output
Print the only integer t — the minimal time required for all ants to be in the root of the tree.
Examples
Input
12
1 2
1 3
1 4
2 5
2 6
3 7
3 8
3 9
8 10
8 11
8 12
Output
6
Input
2
2 1
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, ans;
vector<int> adj[N], vec;
void dfs(int u = 1, int par = -1, int d = 0) {
for (int v : adj[u])
if (v ^ par) {
dfs(v, u, d + 1);
if (u == 1) {
sort(vec.rbegin(), vec.rend());
for (int i = 0; i < vec.size(); i++) ans = max(ans, vec[i] + i);
vec.clear();
}
}
if (adj[u].size() == 1 && u ^ 1) vec.push_back(d);
}
int main() {
cin >> n;
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs();
cout << ans << endl;
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:536870912")
const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 100010;
const long double EPS = 1e-6;
const int HASH_POW = 29;
const long double PI = acos(-1.0);
using namespace std;
void my_return(int code) { exit(code); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
mt19937 mt_rand(time(0));
string s;
map<int, string> foo;
int cnt = 1, n;
cin >> s;
foo[cnt++] = "+";
while (true) {
cin >> s;
if (s != "=") {
foo[cnt++] = s;
cin >> s;
} else {
cin >> n;
break;
}
}
--cnt;
int cntplus = 0, cntminus = 0;
for (map<int, string>::iterator it = foo.begin(); it != foo.end(); ++it)
if (it->second == "+")
++cntplus;
else
++cntminus;
int ll1 = n - n * cntplus, rr1 = n - cntplus, ll2 = -n * cntminus,
rr2 = -cntminus;
if (min(rr1, rr2) < max(ll1, ll2)) {
cout << "Impossible\n";
my_return(0);
}
cout << "Possible\n";
int valminus = -max(ll1, ll2), valplus = n + valminus;
int baseminus = cntminus ? valminus / cntminus : 0,
baseplus = cntplus ? valplus / cntplus : 0;
int remminus = cntminus ? valminus % cntminus : 1,
remplus = cntplus ? valplus % cntplus : 1;
int deltaminus = 1, deltaplus = 1;
if (remminus < 0) {
remminus = -remminus;
deltaminus = -deltaminus;
}
if (remplus < 0) {
remplus = -remplus;
deltaplus = -deltaplus;
}
for (int i = 1; i <= cnt; ++i) {
if (i > 1) cout << " " << foo[i] << " ";
if (foo[i] == "+") {
if (remplus == 0) deltaplus = 0;
cout << baseplus + deltaplus;
--remplus;
} else {
if (remminus == 0) deltaminus = 0;
cout << baseminus + deltaminus;
--remminus;
}
}
cout << " = " << n << endl;
my_return(0);
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
The protection of a popular program developed by one of IT City companies is organized the following way. After installation it outputs a random five digit number which should be sent in SMS to a particular phone number. In response an SMS activation code arrives.
A young hacker Vasya disassembled the program and found the algorithm that transforms the shown number into the activation code. Note: it is clear that Vasya is a law-abiding hacker, and made it for a noble purpose — to show the developer the imperfection of their protection.
The found algorithm looks the following way. At first the digits of the number are shuffled in the following order <first digit><third digit><fifth digit><fourth digit><second digit>. For example the shuffle of 12345 should lead to 13542. On the second stage the number is raised to the fifth power. The result of the shuffle and exponentiation of the number 12345 is 455 422 043 125 550 171 232. The answer is the 5 last digits of this result. For the number 12345 the answer should be 71232.
Vasya is going to write a keygen program implementing this algorithm. Can you do the same?
Input
The only line of the input contains a positive integer five digit number for which the activation code should be found.
Output
Output exactly 5 digits without spaces between them — the found activation code of the program.
Examples
Input
12345
Output
71232
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[6];
int main() {
scanf("%s", s);
char d5, d3, d2, d1;
d2 = s[1];
s[1] = s[2];
s[2] = s[4];
s[4] = d2;
long long int n;
n = (s[4] - '0') + (s[3] - '0') * 10 + (s[2] - '0') * 100 +
(s[1] - '0') * 1000 + (s[0] - '0') * 10000;
n = (((((n * n) % 100000) * ((n * n) % 100000)) % 100000) * n) % 100000;
printf("%05lld\n", n);
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
A rabbit who came to the fair found that the prize for a game at a store was a carrot cake. The rules for this game are as follows.
There is a grid-like field of vertical h squares x horizontal w squares, and each block has at most one block. Each block is a color represented by one of the uppercase letters ('A'-'Z'). When n or more blocks of the same color are lined up in a straight line vertically or horizontally, those blocks disappear.
Participants can select two adjacent cells next to each other and switch their states to each other. When blocks are exchanged, disappeared, or dropped and there are no blocks in the cell below the cell with the block, this block At this time, it disappears when n or more blocks of the same color are lined up again. However, the disappearance of the blocks does not occur while the falling blocks exist, and occurs at the same time when all the blocks have finished falling.
If you eliminate all the blocks on the field with one operation, this game will be successful and you will get a free gift cake. Rabbit wants to get the cake with one entry fee, can not do it If you don't want to participate. From the state of the field at the beginning of the game, answer if the rabbit should participate in this game.
Input
The first line of input is given h, w, n separated by spaces.
2 ≤ h, w, n ≤ 30
In the following h lines, the state of the field is given in order from the top. Uppercase letters represent blocks, and'.' Represents an empty space. The state of the given field is n or more consecutive blocks of the same color in the vertical or horizontal direction. No, no blocks are in a falling state. There is one or more blocks.
Output
Output "YES" if the rabbit should participate in this game, otherwise output "NO" on one line.
Examples
Input
4 6 3
......
...Y..
...Y..
RRYRYY
Output
YES
Input
4 6 3
......
...Y..
...Y..
RRYRY.
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
int h, w, n;
char f[31][31];
bool check(int y, int x, int flag) {
char tmp[31][31];
memcpy(tmp, f, sizeof(f));
swap(tmp[y][x], tmp[y + !flag][x + flag]);
while (true) {
for (int j = 0; j < w; j++) {
for (int i = h - 1; i >= 0; i--) {
if (tmp[i][j] == '.') continue;
int l = i, r = i;
while (r + 1 < h && tmp[r + 1][j] == '.') r++;
tmp[r][j] = tmp[l][j];
if (l != r) tmp[l][j] = '.';
}
}
bool update = false, erase[31][31] = {};
for (int i = 0; i < h; i++) {
for (int j = 0; j + n - 1 < w; j++) {
if (tmp[i][j] == '.') continue;
int l = j, r = j;
while (r < w && tmp[i][r] == tmp[i][l]) r++;
if (r - l >= n) {
for (int k = l; k < r; k++) erase[i][k] = true;
update = true;
}
}
}
for (int j = 0; j < w; j++) {
for (int i = 0; i + n - 1 < h; i++) {
if (tmp[i][j] == '.') continue;
int l = i, r = i;
while (r < h && tmp[r][j] == tmp[l][j]) r++;
if (r - l >= n) {
for (int k = l; k < r; k++) erase[k][j] = true;
update = true;
}
}
}
if (!update) break;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (erase[i][j]) tmp[i][j] = '.';
}
}
}
bool res = true;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) res &= tmp[i][j] == '.';
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> h >> w >> n;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) cin >> f[i][j];
}
bool ans = false;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (j + 1 < w) ans |= check(i, j, 1);
}
}
cout << (ans ? "YES" : "NO") << endl;
return 0;
}
```
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n students living in the campus. Every morning all students wake up at the same time and go to wash. There are m rooms with wash basins. The i-th of these rooms contains ai wash basins. Every student independently select one the rooms with equal probability and goes to it. After all students selected their rooms, students in each room divide into queues by the number of wash basins so that the size of the largest queue is the least possible. Calculate the expected value of the size of the largest queue among all rooms.
Input
The first line contains two positive integers n and m (1 ≤ n, m ≤ 50) — the amount of students and the amount of rooms. The second line contains m integers a1, a2, ... , am (1 ≤ ai ≤ 50). ai means the amount of wash basins in the i-th room.
Output
Output single number: the expected value of the size of the largest queue. Your answer must have an absolute or relative error less than 10 - 9.
Examples
Input
1 1
2
Output
1.00000000000000000000
Input
2 2
1 1
Output
1.50000000000000000000
Input
2 3
1 1 1
Output
1.33333333333333350000
Input
7 5
1 1 2 3 1
Output
2.50216960000000070000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m;
b /= 2;
a = ((a % m) * (a % m)) % m;
}
return ans % m;
}
double fac[55];
double c[55][55];
void factorial() {
fac[0] = 1.00;
for (int i = 1; i <= 50; i++) {
fac[i] = fac[i - 1] * (double)i;
}
}
int n, m;
int a[55];
double pw(double base, int exp) {
double ans = 1.00;
for (int i = 0; i < exp; i++) ans *= base;
return ans;
}
double dp[55][55][55];
bool vis[55][55][55];
double solve(int id, int cnt, int maxSoFar) {
if (id == (m)) {
if (cnt == 0)
return maxSoFar;
else
return 0.00;
}
if (vis[id][cnt][maxSoFar]) return dp[id][cnt][maxSoFar];
vis[id][cnt][maxSoFar] = 1;
double ans = 0.00;
for (int i = 0; i <= cnt; i++) {
ans += c[cnt][i] *
solve(id + 1, cnt - i, max((a[id] + i - 1) / a[id], maxSoFar));
}
return dp[id][cnt][maxSoFar] = ans;
}
int main() {
cin >> n >> m;
factorial();
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 0; i <= 50; i++) {
c[i][0] = 1.00;
c[i][i] = 1.00;
}
for (int i = 2; i <= 50; i++) {
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
double ans = solve(0, n, 0);
ans /= pw(m, n);
cout << fixed << setprecision(12) << ans;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
Given are strings s and t of length N each, both consisting of lowercase English letters.
Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.
Constraints
* 1 \leq N \leq 100
* |S| = |T| = N
* S and T are strings consisting of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S T
Output
Print the string formed.
Examples
Input
2
ip cc
Output
icpc
Input
8
hmhmnknk uuuuuuuu
Output
humuhumunukunuku
Input
5
aaaaa aaaaa
Output
aaaaaaaaaa
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n;
string a,b;
int main(){
cin>>n;
cin>>a;
cin>>b;
for(int i=0;i<n;i++) cout<<a[i]<<b[i];
cout<<endl;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.
Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.
Find the inversion number of B, modulo 10^9 + 7.
Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 2000
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 ... A_{N - 1}
Output
Print the inversion number of B, modulo 10^9 + 7.
Examples
Input
2 2
2 1
Output
3
Input
3 5
1 1 1
Output
0
Input
10 998244353
10 9 8 7 5 6 3 4 2 1
Output
185297239
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
int n;
long long k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
long long ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (a[i] > a[j]) {
ans += k * (k + 1) / 2;
ans %= MOD;
} else if (a[i] < a[j]) {
ans += k * (k - 1) / 2;
ans %= MOD;
}
}
}
cout << ans << endl;
return 0;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int D, N, a;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cin >> D >> N;
for (int(i) = 1; (i) <= (N - 1); (i)++) {
cin >> a;
ans += (D - a);
}
cin >> a;
cout << ans << '\n';
}
```
|
### Prompt
Generate a CPP solution to the following problem:
One day Vasya the Hipster decided to count how many socks he had. It turned out that he had a red socks and b blue socks.
According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot.
Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them.
Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Can you help him?
Input
The single line of the input contains two positive integers a and b (1 ≤ a, b ≤ 100) — the number of red and blue socks that Vasya's got.
Output
Print two space-separated integers — the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day.
Examples
Input
3 1
Output
1 1
Input
2 3
Output
2 0
Input
7 3
Output
3 2
Note
In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a, b, x, z;
scanf("%d %d", &a, &b);
z = abs(a - b) / 2;
if (a < b) {
x = a;
} else
x = b;
printf("%d %d", x, z);
return 0;
}
```
|
### Prompt
Your task is to create a CPP solution to the following problem:
We'll call string s[a, b] = sasa + 1... sb (1 ≤ a ≤ b ≤ |s|) a substring of string s = s1s2... s|s|, where |s| is the length of string s.
The trace of a non-empty string t is a set of characters that the string consists of. For example, the trace of string "aab" equals {'a', 'b'}.
Let's consider an arbitrary string s and the set of its substrings with trace equal to C. We will denote the number of substrings from this set that are maximal by inclusion by r(C, s). Substring s[a, b] of length n = b - a + 1 belonging to some set is called maximal by inclusion, if there is no substring s[x, y] in this set with length greater than n, such that 1 ≤ x ≤ a ≤ b ≤ y ≤ |s|. Two substrings of string s are considered different even if they are equal but they are located at different positions of s.
Polycarpus got a challenging practical task on a stringology exam. He must do the following: given string s and non-empty sets of characters C1, C2, ..., Cm, find r(Ci, s) for each set Ci. Help Polycarpus to solve the problem as he really doesn't want to be expelled from the university and go to the army!
Input
The first line contains a non-empty string s (1 ≤ |s| ≤ 106).
The second line contains a single integer m (1 ≤ m ≤ 104). Next m lines contain descriptions of sets Ci. The i-th line contains string ci such that its trace equals Ci. It is guaranteed that all characters of each string ci are different.
Note that Ci are not necessarily different. All given strings consist of lowercase English letters.
Output
Print m integers — the i-th integer must equal r(Ci, s).
Examples
Input
aaaaa
2
a
a
Output
1
1
Input
abacaba
3
ac
ba
a
Output
1
2
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char input[1000010];
unsigned char ans[3 * (1 << 26) + 10];
int dp[2][28];
void add_count(int i) {
if (ans[3 * i] == 255) {
ans[3 * i] = 0;
if (ans[3 * i + 1] == 255) {
ans[3 * i + 1] = 0;
ans[3 * i + 2]++;
} else {
ans[3 * i + 1]++;
}
} else {
ans[3 * i]++;
}
}
int get_count(int i) {
int n = ans[3 * i + 2];
n *= 256;
n += ans[3 * i + 1];
n *= 256;
n += ans[3 * i];
return n;
}
int main() {
int L;
scanf("%s", input);
for (L = 0; input[L]; ++L) input[L] -= 'a';
bool write = 0, read = 1;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 28; ++j) dp[i][j] = -1;
dp[0][0] = 0;
for (int i = 0; i < L; ++i) {
if (i && input[i] == input[i - 1]) continue;
write ^= 1;
read ^= 1;
for (int j = 0; j < 27; ++j) dp[write][j] = -1;
dp[write][0] = 0;
for (int j = 0; j < 27; ++j) {
if (dp[read][j] == -1) continue;
if (dp[read][j] & (1 << input[i])) {
dp[write][j] = dp[read][j];
} else {
add_count(dp[read][j]);
dp[write][j + 1] = dp[read][j] | (1 << input[i]);
}
}
}
write ^= 1;
read ^= 1;
for (int j = 0; j < 27; ++j) {
add_count(dp[read][j]);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
char query[100];
scanf("%s", query);
int q = 0;
for (int i = 0; query[i]; ++i) q |= (1 << (query[i] - 'a'));
printf("%d\n", get_count(q));
}
}
```
|
### Prompt
Generate a cpp solution to the following problem:
The only difference between easy and hard versions is constraints.
The BerTV channel every day broadcasts one episode of one of the k TV shows. You know the schedule for the next n days: a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the show, the episode of which will be shown in i-th day.
The subscription to the show is bought for the entire show (i.e. for all its episodes), for each show the subscription is bought separately.
How many minimum subscriptions do you need to buy in order to have the opportunity to watch episodes of purchased shows d (1 ≤ d ≤ n) days in a row? In other words, you want to buy the minimum number of TV shows so that there is some segment of d consecutive days in which all episodes belong to the purchased shows.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then t test case descriptions follow.
The first line of each test case contains three integers n, k and d (1 ≤ n ≤ 100, 1 ≤ k ≤ 100, 1 ≤ d ≤ n). The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the show that is broadcasted on the i-th day.
It is guaranteed that the sum of the values of n for all test cases in the input does not exceed 100.
Output
Print t integers — the answers to the test cases in the input in the order they follow. The answer to a test case is the minimum number of TV shows for which you need to purchase a subscription so that you can watch episodes of the purchased TV shows on BerTV for d consecutive days. Please note that it is permissible that you will be able to watch more than d days in a row.
Example
Input
4
5 2 2
1 2 1 2 1
9 3 3
3 3 3 2 2 2 1 1 1
4 10 4
10 8 6 4
16 9 8
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3
Output
2
1
4
5
Note
In the first test case to have an opportunity to watch shows for two consecutive days, you need to buy a subscription on show 1 and on show 2. So the answer is two.
In the second test case, you can buy a subscription to any show because for each show you can find a segment of three consecutive days, consisting only of episodes of this show.
In the third test case in the unique segment of four days, you have four different shows, so you need to buy a subscription to all these four shows.
In the fourth test case, you can buy subscriptions to shows 3,5,7,8,9, and you will be able to watch shows for the last eight days.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
long long int n, k, c;
cin >> n >> k >> c;
long long int a[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
long long int mn, d = 0;
map<long long int, long long int> mp;
for (long long int i = 1; i <= c; i++) {
if (!mp[a[i]]) d++;
mp[a[i]]++;
}
mn = d;
for (long long int i = 2; i <= n - c + 1; i++) {
mp[a[i - 1]]--;
if (!mp[a[i - 1]]) d--;
if (!mp[a[i + c - 1]]) d++;
mp[a[i + c - 1]]++;
mn = min(mn, d);
}
cout << mn << "\n";
}
return 0;
}
```
|
### Prompt
Please formulate a Cpp solution to the following problem:
N programmers are going to participate in the preliminary stage of DDCC 20XX. Due to the size of the venue, however, at most 9 contestants can participate in the finals.
The preliminary stage consists of several rounds, which will take place as follows:
* All the N contestants will participate in the first round.
* When X contestants participate in some round, the number of contestants advancing to the next round will be decided as follows:
* The organizer will choose two consecutive digits in the decimal notation of X, and replace them with the sum of these digits. The number resulted will be the number of contestants advancing to the next round.
For example, when X = 2378, the number of contestants advancing to the next round will be 578 (if 2 and 3 are chosen), 2108 (if 3 and 7 are chosen), or 2315 (if 7 and 8 are chosen).
When X = 100, the number of contestants advancing to the next round will be 10, no matter which two digits are chosen.
* The preliminary stage ends when 9 or fewer contestants remain.
Ringo, the chief organizer, wants to hold as many rounds as possible. Find the maximum possible number of rounds in the preliminary stage.
Since the number of contestants, N, can be enormous, it is given to you as two integer sequences d_1, \ldots, d_M and c_1, \ldots, c_M, which means the following: the decimal notation of N consists of c_1 + c_2 + \ldots + c_M digits, whose first c_1 digits are all d_1, the following c_2 digits are all d_2, \ldots, and the last c_M digits are all d_M.
Constraints
* 1 \leq M \leq 200000
* 0 \leq d_i \leq 9
* d_1 \neq 0
* d_i \neq d_{i+1}
* c_i \geq 1
* 2 \leq c_1 + \ldots + c_M \leq 10^{15}
Input
Input is given from Standard Input in the following format:
M
d_1 c_1
d_2 c_2
:
d_M c_M
Output
Print the maximum possible number of rounds in the preliminary stage.
Examples
Input
2
2 2
9 1
Output
3
Input
3
1 1
0 8
7 1
Output
9
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void){
long long s = 0;
long long a = 0;
int M;
cin >> M;
for(int i = 0; i < M; i++){
long long d, c;
cin >> d >> c;
s += d * c;
a += c;
}
if(s % 9 == 0) s--;
cout << a + s / 9 - 1 << endl;
return 0;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
Arkady's morning seemed to be straight of his nightmare. He overslept through the whole morning and, still half-asleep, got into the tram that arrived the first. Some time after, leaving the tram, he realized that he was not sure about the line number of the tram he was in.
During his ride, Arkady woke up several times and each time he saw the tram stopping at some stop. For each stop he knows which lines of tram stop there. Given this information, can you help Arkady determine what are the possible lines of the tram he was in?
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of stops Arkady saw.
The next n lines describe the stops. Each of them starts with a single integer r (1 ≤ r ≤ 100) — the number of tram lines that stop there. r distinct integers follow, each one between 1 and 100, inclusive, — the line numbers. They can be in arbitrary order.
It is guaranteed that Arkady's information is consistent, i.e. there is at least one tram line that Arkady could take.
Output
Print all tram lines that Arkady could be in, in arbitrary order.
Examples
Input
3
3 1 4 6
2 1 4
5 10 5 6 4 1
Output
1 4
Input
5
1 1
10 10 9 8 7 100 5 4 3 99 1
5 1 2 3 4 5
5 4 1 3 2 5
4 10 1 5 3
Output
1
Note
Consider the first example. Arkady woke up three times. The first time he saw a stop with lines 1, 4, 6. The second time he saw a stop with lines 1, 4. The third time he saw a stop with lines 10, 5, 6, 4 and 1. He can be in a tram of one of two lines: 1 or 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> res;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int r;
vector<int> postaje;
scanf("%d", &r);
for (int j = 0; j < r; j++) {
int a;
scanf("%d", &a);
postaje.push_back(a);
}
sort(postaje.begin(), postaje.end());
if (i == 0)
res = postaje;
else {
vector<int> temp(110);
set_intersection(res.begin(), res.end(), postaje.begin(), postaje.end(),
temp.begin());
res = temp;
}
}
for (int i : res)
if (i != 0) printf("%d ", i);
putchar('\n');
return 0;
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
Om Nom is the main character of a game "Cut the Rope". He is a bright little monster who likes visiting friends living at the other side of the park. However the dark old parks can scare even somebody as fearless as Om Nom, so he asks you to help him.
<image>
The park consists of 2n + 1 - 1 squares connected by roads so that the scheme of the park is a full binary tree of depth n. More formally, the entrance to the park is located at the square 1. The exits out of the park are located at squares 2n, 2n + 1, ..., 2n + 1 - 1 and these exits lead straight to the Om Nom friends' houses. From each square i (2 ≤ i < 2n + 1) there is a road to the square <image>. Thus, it is possible to go from the park entrance to each of the exits by walking along exactly n roads.
<image> To light the path roads in the evening, the park keeper installed street lights along each road. The road that leads from square i to square <image> has ai lights.
Om Nom loves counting lights on the way to his friend. Om Nom is afraid of spiders who live in the park, so he doesn't like to walk along roads that are not enough lit. What he wants is that the way to any of his friends should have in total the same number of lights. That will make him feel safe.
He asked you to help him install additional lights. Determine what minimum number of lights it is needed to additionally place on the park roads so that a path from the entrance to any exit of the park contains the same number of street lights. You may add an arbitrary number of street lights to each of the roads.
Input
The first line contains integer n (1 ≤ n ≤ 10) — the number of roads on the path from the entrance to any exit.
The next line contains 2n + 1 - 2 numbers a2, a3, ... a2n + 1 - 1 — the initial numbers of street lights on each road of the park. Here ai is the number of street lights on the road between squares i and <image>. All numbers ai are positive integers, not exceeding 100.
Output
Print the minimum number of street lights that we should add to the roads of the park to make Om Nom feel safe.
Examples
Input
2
1 2 3 4 5 6
Output
5
Note
Picture for the sample test. Green color denotes the additional street lights.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ans, i, a[3000], b[3000], t[3000];
void get(int v, int h) {
if (v * 2 >= m) {
k++;
t[k] = h;
return;
}
get(v * 2, h + a[v * 2]);
get(v * 2 + 1, h + a[v * 2 + 1]);
}
int main() {
cin >> n;
m = 1 << (n + 1);
for (i = 2; i < m; ++i) cin >> a[i];
get(1, 0);
while (k > 1) {
n = k;
k = 0;
for (i = 1; i <= n; i += 2)
ans += abs(t[i] - t[i + 1]), k++, b[k] = max(t[i], t[i + 1]);
for (i = 1; i <= k; ++i) t[i] = b[i];
}
cout << ans;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
We all know the problem about the number of ways one can tile a 2 × n field by 1 × 2 dominoes. You probably remember that it goes down to Fibonacci numbers. We will talk about some other problem below, there you also are going to deal with tiling a rectangular field with dominoes.
You are given a 4 × n rectangular field, that is the field that contains four lines and n columns. You have to find for it any tiling by 1 × 2 dominoes such that each of the n - 1 potential vertical cuts along the grid lines intersects at least one domino, splitting it in two. No two dominoes in the sought tiling should overlap, each square of the field should be covered by exactly one domino. It is allowed to rotate the dominoes, that is, you can use 2 × 1 as well as 1 × 2 dominoes.
Write a program that finds an arbitrary sought tiling.
Input
The input contains one positive integer n (1 ≤ n ≤ 100) — the number of the field's columns.
Output
If there's no solution, print "-1" (without the quotes). Otherwise, print four lines containing n characters each — that's the description of tiling, where each vertical cut intersects at least one domino. You should print the tiling, having painted the field in no more than 26 colors. Each domino should be painted a color. Different dominoes can be painted the same color, but dominoes of the same color should not be side-neighbouring. To indicate colors you should use lowercase Latin letters. Print any of the acceptable ways of tiling.
Examples
Input
4
Output
yyzz
bccd
bxxd
yyaa
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char mp[105][105];
void paint(long long int x, long long int y, long long int xx,
long long int yy) {
mp[x][y] = mp[xx][yy] = (x % 5) * 5 + y % 5 + 'a';
}
int main() {
long long int n;
cin >> n;
if (n % 2) {
for (long long int i = 0; i < ((long long int)(n / 2)); i++)
for (long long int j = 0; j < ((long long int)(2)); j++)
paint(j, i * 2, j, i * 2 + 1);
for (long long int i = 0; i < ((long long int)(n / 2)); i++)
for (long long int j = 0; j < ((long long int)(2)); j++)
paint(j + 2, i * 2 + 1, j + 2, i * 2 + 2);
paint(0, n - 1, 1, n - 1);
paint(2, 0, 3, 0);
} else {
for (long long int i = 0; i < ((long long int)(n / 2)); i++)
for (long long int j = 0; j < ((long long int)(4)); j++)
if (j == 0 || j == 3) paint(j, i * 2, j, i * 2 + 1);
for (long long int i = 0; i < ((long long int)(n / 2 - 1)); i++)
for (long long int j = 0; j < ((long long int)(2)); j++)
paint(j + 1, i * 2 + 1, j + 1, i * 2 + 2);
paint(1, 0, 2, 0);
paint(1, n - 1, 2, n - 1);
}
for (long long int i = 0; i < ((long long int)(4)); i++) {
for (long long int j = 0; j < ((long long int)(n)); j++) cout << mp[i][j];
cout << endl;
}
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
Given is a positive integer N. How many tuples (A,B,C) of positive integers satisfy A \times B + C = N?
Constraints
* 2 \leq N \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
3
Output
3
Input
100
Output
473
Input
1000000
Output
13969985
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int N,ans=0;
cin >> N;
for(int i=1;i<=N;i++){
ans+=N/i;
if(N%i==0)ans--;
}cout<<ans;
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
Simon has a rectangular table consisting of n rows and m columns. Simon numbered the rows of the table from top to bottom starting from one and the columns — from left to right starting from one. We'll represent the cell on the x-th row and the y-th column as a pair of numbers (x, y). The table corners are cells: (1, 1), (n, 1), (1, m), (n, m).
Simon thinks that some cells in this table are good. Besides, it's known that no good cell is the corner of the table.
Initially, all cells of the table are colorless. Simon wants to color all cells of his table. In one move, he can choose any good cell of table (x1, y1), an arbitrary corner of the table (x2, y2) and color all cells of the table (p, q), which meet both inequations: min(x1, x2) ≤ p ≤ max(x1, x2), min(y1, y2) ≤ q ≤ max(y1, y2).
Help Simon! Find the minimum number of operations needed to color all cells of the table. Note that you can color one cell multiple times.
Input
The first line contains exactly two integers n, m (3 ≤ n, m ≤ 50).
Next n lines contain the description of the table cells. Specifically, the i-th line contains m space-separated integers ai1, ai2, ..., aim. If aij equals zero, then cell (i, j) isn't good. Otherwise aij equals one. It is guaranteed that at least one cell is good. It is guaranteed that no good cell is a corner.
Output
Print a single number — the minimum number of operations Simon needs to carry out his idea.
Examples
Input
3 3
0 0 0
0 1 0
0 0 0
Output
4
Input
4 3
0 0 0
0 0 1
1 0 0
0 0 0
Output
2
Note
In the first sample, the sequence of operations can be like this:
<image>
* For the first time you need to choose cell (2, 2) and corner (1, 1).
* For the second time you need to choose cell (2, 2) and corner (3, 3).
* For the third time you need to choose cell (2, 2) and corner (3, 1).
* For the fourth time you need to choose cell (2, 2) and corner (1, 3).
In the second sample the sequence of operations can be like this:
<image>
* For the first time you need to choose cell (3, 1) and corner (4, 3).
* For the second time you need to choose cell (2, 3) and corner (1, 1).
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n, m, x;
int zhong = 0, bian = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
if (x == 1) {
if (i == 1 || j == 1 || i == n || j == m) {
bian = 1;
} else {
zhong = 1;
}
}
}
}
if (bian == 1) {
printf("2\n");
return 0;
}
if (zhong == 1) {
printf("4\n");
return 0;
}
printf("0\n");
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
It is well known that Berland has n cities, which form the Silver ring — cities i and i + 1 (1 ≤ i < n) are connected by a road, as well as the cities n and 1. The goverment have decided to build m new roads. The list of the roads to build was prepared. Each road will connect two cities. Each road should be a curve which lies inside or outside the ring. New roads will have no common points with the ring (except the endpoints of the road).
Now the designers of the constructing plan wonder if it is possible to build the roads in such a way that no two roads intersect (note that the roads may intersect at their endpoints). If it is possible to do, which roads should be inside the ring, and which should be outside?
Input
The first line contains two integers n and m (4 ≤ n ≤ 100, 1 ≤ m ≤ 100). Each of the following m lines contains two integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi). No two cities will be connected by more than one road in the list. The list will not contain the roads which exist in the Silver ring.
Output
If it is impossible to build the roads in such a way that no two roads intersect, output Impossible. Otherwise print m characters. i-th character should be i, if the road should be inside the ring, and o if the road should be outside the ring. If there are several solutions, output any of them.
Examples
Input
4 2
1 3
2 4
Output
io
Input
6 3
1 3
3 5
5 1
Output
ooo
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int n, m;
pair<int, int> arr[N];
vector<int> g[N];
int col[N];
bool vis[N];
bool flag = true;
bool intersects(pair<int, int> a, pair<int, int> b) {
if (a.first > a.second) swap(a.first, a.second);
if (b.first > b.second) swap(b.first, b.second);
if (a.first >= b.second or a.second <= b.first) return false;
if (a.first == b.first || a.first == b.second || a.second == b.first ||
a.second == b.second)
return false;
if (a.first < b.first && b.second < a.second) return false;
if (b.first < a.first && a.second < b.second) return false;
return true;
}
void dfs(int u, int c) {
vis[u] = true;
col[u] = c;
for (auto to : g[u]) {
if (vis[to]) {
if (col[to] == c) flag = false;
continue;
}
dfs(to, 1 - c);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int i, j;
for (i = 0; 0 < m ? i < m : i > m; 0 < m ? i += 1 : i -= 1) {
cin >> arr[i].first >> arr[i].second;
}
for (i = 0; 0 < m ? i < m : i > m; 0 < m ? i += 1 : i -= 1) {
for (j = i + 1; i + 1 < m ? j < m : j > m; i + 1 < m ? j += 1 : j -= 1) {
if (intersects(arr[i], arr[j])) {
g[i].push_back(j);
g[j].push_back(i);
}
}
}
for (i = 0; 0 < m ? i < m : i > m; 0 < m ? i += 1 : i -= 1) {
if (!vis[i]) {
dfs(i, 1);
}
}
if (!flag) {
cout << "Impossible" << endl;
return 0;
}
for (i = 0; 0 < m ? i < m : i > m; 0 < m ? i += 1 : i -= 1) {
if (col[i] == 1)
cout << "i";
else
cout << "o";
}
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Some company is going to hold a fair in Byteland. There are n towns in Byteland and m two-way roads between towns. Of course, you can reach any town from any other town using roads.
There are k types of goods produced in Byteland and every town produces only one type. To hold a fair you have to bring at least s different types of goods. It costs d(u,v) coins to bring goods from town u to town v where d(u,v) is the length of the shortest path from u to v. Length of a path is the number of roads in this path.
The organizers will cover all travel expenses but they can choose the towns to bring goods from. Now they want to calculate minimum expenses to hold a fair in each of n towns.
Input
There are 4 integers n, m, k, s in the first line of input (1 ≤ n ≤ 10^{5}, 0 ≤ m ≤ 10^{5}, 1 ≤ s ≤ k ≤ min(n, 100)) — the number of towns, the number of roads, the number of different types of goods, the number of different types of goods necessary to hold a fair.
In the next line there are n integers a_1, a_2, …, a_n (1 ≤ a_{i} ≤ k), where a_i is the type of goods produced in the i-th town. It is guaranteed that all integers between 1 and k occur at least once among integers a_{i}.
In the next m lines roads are described. Each road is described by two integers u v (1 ≤ u, v ≤ n, u ≠ v) — the towns connected by this road. It is guaranteed that there is no more than one road between every two towns. It is guaranteed that you can go from any town to any other town via roads.
Output
Print n numbers, the i-th of them is the minimum number of coins you need to spend on travel expenses to hold a fair in town i. Separate numbers with spaces.
Examples
Input
5 5 4 3
1 2 4 3 2
1 2
2 3
3 4
4 1
4 5
Output
2 2 2 2 3
Input
7 6 3 2
1 2 3 3 2 2 1
1 2
2 3
3 4
2 5
5 6
6 7
Output
1 1 1 2 2 1 1
Note
Let's look at the first sample.
To hold a fair in town 1 you can bring goods from towns 1 (0 coins), 2 (1 coin) and 4 (1 coin). Total numbers of coins is 2.
Town 2: Goods from towns 2 (0), 1 (1), 3 (1). Sum equals 2.
Town 3: Goods from towns 3 (0), 2 (1), 4 (1). Sum equals 2.
Town 4: Goods from towns 4 (0), 1 (1), 5 (1). Sum equals 2.
Town 5: Goods from towns 5 (0), 4 (1), 3 (2). Sum equals 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr int mod = 1000000007;
constexpr int mod1 = 998244353;
vector<int> dx = {0, 1, 0, -1}, dy = {-1, 0, 1, 0};
bool inside(int y, int x, int h, int w) {
if (y < h && y >= 0 && x < w && x >= 0) return true;
return false;
}
const int inf = 1000000000;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, k, s;
cin >> n >> m >> k >> s;
vector<vector<int>> a(k);
for (int i = 0; i < (n); ++i) {
int t;
cin >> t;
t--;
a.at(t).push_back(i);
}
vector<vector<int>> g(n, vector<int>());
for (int i = 0; i < (m); ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
vector<vector<int>> ans(n, vector<int>(k));
vector<int> dist(n);
queue<int> q;
for (int i = 0; i < (k); ++i) {
for (int j = 0; j < (n); ++j) dist.at(j) = inf;
for (int j = 0; j < (a.at(i).size()); ++j) {
dist.at(a[i][j]) = 0;
q.push(a[i][j]);
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int j = 0; j < (g.at(cur).size()); ++j) {
int next = g[cur][j];
if (dist[next] > dist[cur] + 1) {
dist[next] = dist[cur] + 1;
q.push(next);
}
}
}
for (int j = 0; j < (n); ++j) {
ans[j][i] = dist[j];
}
}
for (int i = 0; i < (n); ++i) {
int sum = 0;
sort(ans[i].begin(), ans[i].end());
for (int j = 0; j < (s); ++j) sum += ans[i][j];
if (i == n - 1)
cout << sum << endl;
else
cout << sum << " ";
}
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Allen and Bessie are playing a simple number game. They both know a function f: \{0, 1\}^n → R, i. e. the function takes n binary arguments and returns a real value. At the start of the game, the variables x_1, x_2, ..., x_n are all set to -1. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an i such that x_i = -1 and either setting x_i → 0 or x_i → 1.
After n rounds all variables are set, and the game value resolves to f(x_1, x_2, ..., x_n). Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play r+1 times though, so between each game, exactly one value of f changes. In other words, between rounds i and i+1 for 1 ≤ i ≤ r, f(z_1, ..., z_n) → g_i for some (z_1, ..., z_n) ∈ \{0, 1\}^n. You are to find the expected game value in the beginning and after each change.
Input
The first line contains two integers n and r (1 ≤ n ≤ 18, 0 ≤ r ≤ 2^{18}).
The next line contains 2^n integers c_0, c_1, ..., c_{2^n-1} (0 ≤ c_i ≤ 10^9), denoting the initial values of f. More specifically, f(x_0, x_1, ..., x_{n-1}) = c_x, if x = \overline{x_{n-1} … x_0} in binary.
Each of the next r lines contains two integers z and g (0 ≤ z ≤ 2^n - 1, 0 ≤ g ≤ 10^9). If z = \overline{z_{n-1} ... z_0} in binary, then this means to set f(z_0, ..., z_{n-1}) → g.
Output
Print r+1 lines, the i-th of which denotes the value of the game f during the i-th round. Your answer must have absolute or relative error within 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
Note
Consider the second test case. If Allen goes first, he will set x_1 → 1, so the final value will be 3. If Bessie goes first, then she will set x_1 → 0 so the final value will be 2. Thus the answer is 2.5.
In the third test case, the game value will always be 1 regardless of Allen and Bessie's play.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 19;
int read() {
int s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
void print(int x, char c = '\n') {
write(x);
putchar(c);
}
int a[N];
double sum = 0;
signed main() {
int n = read(), m = read();
for (int i = 0; i < (1 << n); i++) sum += a[i] = read();
printf("%.8lf\n", sum / (1 << n));
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
sum -= a[x];
sum += a[x] = y;
printf("%.8lf\n", sum / (1 << n));
}
return 0;
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.