text
stringlengths 424
69.5k
|
|---|
### Prompt
Please provide a Cpp coded solution to the problem described below:
The nation of Panel holds an annual show called The Number Games, where each district in the nation will be represented by one contestant.
The nation has n districts numbered from 1 to n, each district has exactly one path connecting it to every other district. The number of fans of a contestant from district i is equal to 2^i.
This year, the president decided to reduce the costs. He wants to remove k contestants from the games. However, the districts of the removed contestants will be furious and will not allow anyone to cross through their districts.
The president wants to ensure that all remaining contestants are from districts that can be reached from one another. He also wishes to maximize the total number of fans of the participating contestants.
Which contestants should the president remove?
Input
The first line of input contains two integers n and k (1 ≤ k < n ≤ 10^6) — the number of districts in Panel, and the number of contestants the president wishes to remove, respectively.
The next n-1 lines each contains two integers a and b (1 ≤ a, b ≤ n, a ≠ b), that describe a road that connects two different districts a and b in the nation. It is guaranteed that there is exactly one path between every two districts.
Output
Print k space-separated integers: the numbers of the districts of which the contestants should be removed, in increasing order of district number.
Examples
Input
6 3
2 1
2 6
4 2
5 6
2 3
Output
1 3 4
Input
8 4
2 6
2 7
7 8
1 2
3 1
2 4
7 5
Output
1 3 4 5
Note
In the first sample, the maximum possible total number of fans is 2^2 + 2^5 + 2^6 = 100. We can achieve it by removing the contestants of the districts 1, 3, and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000 * 1000 + 10;
const int MAX_K = 20 + 5;
vector<int> adj[MAX_N];
int par[MAX_N][MAX_K];
bool block[MAX_N];
bool mark[MAX_N];
void dfs(int u, int dad) {
par[u][0] = u;
for (int i = 1; i < MAX_K; i++) par[u][i] = par[par[dad][i - 1]][i - 1];
for (auto v : adj[u])
if (v != dad) dfs(v, u);
}
void add(int u) {
mark[u] = true;
if (!mark[par[u][1]]) add(par[u][1]);
}
void rem(int u) {
block[u] = true;
for (auto v : adj[u])
if (v != par[u][1] && !block[v]) rem(v);
}
int dis(int u) {
int L = 0, R = 20;
while (L + 1 < R) {
int mid = (L + R) / 2;
mark[par[u][mid]] ? R = mid : L = mid;
}
return (L ? dis(par[u][L]) : 1) + (1 << L) - 1;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, k;
cin >> n >> k;
k = n - k - 1;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(n - 1, n - 1), add(n - 1);
for (int i = n - 2; ~i && k; i--)
if (!block[i] && !mark[i]) {
int x = dis(i);
x <= k ? k -= x, add(i) : rem(i);
}
for (int i = 0; i < n; i++)
if (!mark[i]) cout << i + 1 << ' ';
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
DZY loves collecting special strings which only contain lowercase letters. For each lowercase letter c DZY knows its value wc. For each special string s = s1s2... s|s| (|s| is the length of the string) he represents its value with a function f(s), where
<image>
Now DZY has a string s. He wants to insert k lowercase letters into this string in order to get the largest possible value of the resulting string. Can you help him calculate the largest possible value he could get?
Input
The first line contains a single string s (1 ≤ |s| ≤ 103).
The second line contains a single integer k (0 ≤ k ≤ 103).
The third line contains twenty-six integers from wa to wz. Each such number is non-negative and doesn't exceed 1000.
Output
Print a single integer — the largest possible value of the resulting string DZY could get.
Examples
Input
abc
3
1 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
41
Note
In the test sample DZY can obtain "abcbbc", value = 1·1 + 2·2 + 3·2 + 4·2 + 5·2 + 6·2 = 41.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int q, n, s = 0, max = 0;
cin >> n;
int i, arr[26];
for (i = 0; i < 26; i++) {
cin >> arr[i];
if (max < arr[i]) max = arr[i];
}
int k = str.length();
for (i = 0; i < k; i++) {
q = str[i] - 96;
s += (i + 1) * arr[q - 1];
}
q = (k + n + 1) * (k + n) / 2 - k * (k + 1) / 2;
cout << s + q * max;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are playing a new famous fighting game: Kortal Mombat XII. You have to perform a brutality on your opponent's character.
You are playing the game on the new generation console so your gamepad have 26 buttons. Each button has a single lowercase Latin letter from 'a' to 'z' written on it. All the letters on buttons are pairwise distinct.
You are given a sequence of hits, the i-th hit deals a_i units of damage to the opponent's character. To perform the i-th hit you have to press the button s_i on your gamepad. Hits are numbered from 1 to n.
You know that if you press some button more than k times in a row then it'll break. You cherish your gamepad and don't want to break any of its buttons.
To perform a brutality you have to land some of the hits of the given sequence. You are allowed to skip any of them, however changing the initial order of the sequence is prohibited. The total damage dealt is the sum of a_i over all i for the hits which weren't skipped.
Note that if you skip the hit then the counter of consecutive presses the button won't reset.
Your task is to skip some hits to deal the maximum possible total damage to the opponent's character and not break your gamepad buttons.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of hits and the maximum number of times you can push the same button in a row.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the damage of the i-th hit.
The third line of the input contains the string s consisting of exactly n lowercase Latin letters — the sequence of hits (each character is the letter on the button you need to press to perform the corresponding hit).
Output
Print one integer dmg — the maximum possible damage to the opponent's character you can deal without breaking your gamepad buttons.
Examples
Input
7 3
1 5 16 18 7 2 10
baaaaca
Output
54
Input
5 5
2 4 1 3 1000
aaaaa
Output
1010
Input
5 4
2 4 1 3 1000
aaaaa
Output
1009
Input
8 1
10 15 2 1 4 8 15 16
qqwweerr
Output
41
Input
6 3
14 18 9 19 2 15
cccccc
Output
52
Input
2 1
10 10
qq
Output
10
Note
In the first example you can choose hits with numbers [1, 3, 4, 5, 6, 7] with the total damage 1 + 16 + 18 + 7 + 2 + 10 = 54.
In the second example you can choose all hits so the total damage is 2 + 4 + 1 + 3 + 1000 = 1010.
In the third example you can choose all hits expect the third one so the total damage is 2 + 4 + 3 + 1000 = 1009.
In the fourth example you can choose hits with numbers [2, 3, 6, 8]. Only this way you can reach the maximum total damage 15 + 2 + 8 + 16 = 41.
In the fifth example you can choose only hits with numbers [2, 4, 6] with the total damage 18 + 19 + 15 = 52.
In the sixth example you can change either first hit or the second hit (it does not matter) with the total damage 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
char T[MAX];
int val[MAX];
int main() {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> val[i];
cin >> T;
int i = 0, j = 0;
long long ans = 0;
while (i < n) {
vector<int> v;
v.push_back(val[j]);
j++;
while (T[i] == T[j]) {
v.push_back(val[j]);
j++;
}
i = j;
int k = 0;
sort(v.begin(), v.end());
for (int i = v.size() - 1; i >= 0 && k < x; i--) {
ans += v[i];
k++;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int _;
cin >> _;
while (_--) {
string a;
cin >> a;
long long int i = 0;
long long int n = a.size();
vector<long long int> ans;
for (i = 0; i < n - 4; i++) {
if ((a[i] == 't') && (a[i + 1] == 'w') && (a[i + 2] == 'o') &&
(a[i + 3] == 'n') && (a[i + 4] == 'e')) {
ans.push_back(i + 2);
a[i + 2] = 'z';
}
}
for (i = 0; i < n - 2; i++) {
if (((a[i] == 't') && (a[i + 1] == 'w') && (a[i + 2] == 'o')) ||
((a[i] == 'o') && (a[i + 1] == 'n') && (a[i + 2] == 'e'))) {
ans.push_back(i + 1);
}
}
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You have number a, whose decimal representation quite luckily contains digits 1, 6, 8, 9. Rearrange the digits in its decimal representation so that the resulting number will be divisible by 7.
Number a doesn't contain any leading zeroes and contains digits 1, 6, 8, 9 (it also can contain another digits). The resulting number also mustn't contain any leading zeroes.
Input
The first line contains positive integer a in the decimal record. It is guaranteed that the record of number a contains digits: 1, 6, 8, 9. Number a doesn't contain any leading zeroes. The decimal representation of number a contains at least 4 and at most 106 characters.
Output
Print a number in the decimal notation without leading zeroes — the result of the permutation.
If it is impossible to rearrange the digits of the number a in the required manner, print 0.
Examples
Input
1689
Output
1869
Input
18906
Output
18690
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long n, m;
map<int, int> rt;
string t;
long ry = 0;
string p[] = {"1869", "6198", "1896", "9186", "9168", "6189", "8691"};
void df(int k) {
for (int i = 1; i <= rt[k]; ++i) {
ry = (ry * 10 + k) % 7;
cout << k;
}
}
int main() {
cin >> t;
for (int k = 0; k < t.size(); ++k) {
rt[t[k] - '0']++;
}
--rt[1];
--rt[6];
--rt[8];
--rt[9];
for (int k = 1; k <= 9; ++k) df(k);
cout << p[ry];
df(0);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The goal of the 15 puzzle problem is to complete pieces on $4 \times 4$ cells where one of the cells is empty space.
In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 15 as shown below.
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.
Constraints
* The given puzzle is solvable in at most 45 steps.
Input
The $4 \times 4$ integers denoting the pieces or space are given.
Output
Print the fewest steps in a line.
Example
Input
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
Output
8
### Response
```cpp
#include<bits/stdc++.h>
static const int N = 4;
static const int N2 = 16;
static const int LIMIT = 100;
static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = {'r', 'u', 'l', 'd'};
int MDT[N2][N2];
struct Puzzle{
int f[N2], space, MD;
};
Puzzle state;
int limit;
int path[LIMIT];
int getAllMD(Puzzle pz){
int sum = 0;
for(int i = 0; i < N2; i++){
if(pz.f[i] == N2) continue;
sum += MDT[i][pz.f[i]-1];
}
return sum;
}
bool dfs(int depth, int prev){
if(state.MD == 0) return true;
if(depth + state.MD > limit) return false;
int sx = state.space / N;
int sy = state.space % N;
Puzzle tmp;
for(int r = 0; r < 4; r++){
int tx = sx + dx[r];
int ty = sy + dy[r];
if(tx < 0 || ty < 0 || tx >= N || ty >= N){
continue;
}
if(std::max(prev, r) - std::min(prev, r) == 2) continue;
tmp = state;
state.MD -= MDT[tx*N+ty][state.f[tx*N+ty]-1];
state.MD += MDT[sx*N+sy][state.f[tx*N+ty]-1];
std::swap(state.f[tx*N+ty], state.f[sx*N+sy]);
state.space = tx * N + ty;
if(dfs(depth + 1, r)){
path[depth] = r;
return true;
}
state = tmp;
}
return false;
}
std::string iterative_deepning(Puzzle in){
in.MD = getAllMD(in);
for(limit = in.MD; limit <= LIMIT; limit++){
state = in;
if(dfs(0, -100)){
std::string ans = "";
for(int i = 0; i < limit; i++) ans += dir[path[i]];
return ans;
}
}
return "unsolvable";
}
int main(void){
for(int i = 0; i < N2; i++){
for(int j = 0; j < N2; j++){
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
Puzzle in;
for(int i = 0; i < N2; i++){
std::cin >> in.f[i];
if(in.f[i] == 0){
in.f[i] = N2;
in.space = i;
}
}
std::string ans = iterative_deepning(in);
std::cout << ans.size() << std::endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 ≤ i, j ≤ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers — matrix t. The j-th integer in the i-th line is tij (1 ≤ tij ≤ 10000; i ≠ j). The following line contains a single integer n (1 ≤ n ≤ 40) — the number of disks.
It is guaranteed that for all i (1 ≤ i ≤ 3), tii = 0.
Output
Print a single integer — the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long t[3][3];
long long mat[41][3][3][3];
long long compute(int n, int i, int j, int k) {
if (mat[n][i][j][k] != -1) return mat[n][i][j][k];
if (n == 1) {
mat[n][i][j][k] =
((t[i][j]) < (t[i][k] + t[k][j]) ? (t[i][j]) : (t[i][k] + t[k][j]));
return mat[n][i][j][k];
}
long long a = ((compute(n - 1, i, k, j)) <
(compute(n - 1, i, j, k) + compute(n - 1, j, k, i))
? (compute(n - 1, i, k, j))
: (compute(n - 1, i, j, k) + compute(n - 1, j, k, i)));
a += t[i][j];
a += ((compute(n - 1, k, j, i)) <
(compute(n - 1, k, i, j) + compute(n - 1, i, j, k))
? (compute(n - 1, k, j, i))
: (compute(n - 1, k, i, j) + compute(n - 1, i, j, k)));
long long b = ((compute(n - 1, i, j, k)) <
(compute(n - 1, i, k, j) + compute(n - 1, k, j, i))
? (compute(n - 1, i, j, k))
: (compute(n - 1, i, k, j) + compute(n - 1, k, j, i)));
b += t[i][k] + t[k][j];
b += compute(n - 1, j, i, k) +
((compute(n - 1, i, j, k)) <
(compute(n - 1, i, k, j) + compute(n - 1, k, j, i))
? (compute(n - 1, i, j, k))
: (compute(n - 1, i, k, j) + compute(n - 1, k, j, i)));
mat[n][i][j][k] = ((a) < (b) ? (a) : (b));
return mat[n][i][j][k];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
for (int i = 0; i < 41; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
for (int l = 0; l < 3; l++) {
mat[i][j][k][l] = -1;
}
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cin >> t[i][j];
}
}
int n;
cin >> n;
cout << compute(n, 0, 2, 1) << "\n";
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
In order to ensure confidentiality, the access to the "Russian Code Cup" problems is password protected during the problem development process.
To select a password, the jury can generate a special table that contains n columns and the infinite number of rows. To construct a table, the first row is fixed, and all the others are obtained by the following rule:
In the row i at position p there is a number equal to the number of times a[i - 1][p] occurs on the prefix a[i - 1][1... p].
To ensure the required level of confidentiality, the jury must be able to perform the following operations:
* Replace number a[1][p] by v and rebuild the table.
* Find the number a[x][y], which will be the new password.
Doing all these steps manually is very tedious, so the jury asks you to help him. Write a program that responds to the request of the jury.
Input
The first line contains an integer n (1 ≤ n ≤ 100000) — the number of columns. The second line contains the description of the first row of the table, that is, n integers, which are not less than 1 and do not exceed 109.
The third line of the input contains an integer m (1 ≤ m ≤ 100000) — the number of requests.
Next, each row contains a description of the request, which consists of three integers:
* If the first number is equal to 1, then the remaining two numbers are v, p (1 ≤ v ≤ 109; 1 ≤ p ≤ n). So, you should put value v in the position p in the first row.
* If the first number is equal to 2, then the remaining two numbers are x, y (1 ≤ x ≤ 105; 1 ≤ y ≤ n) — the row and column of the table cell from which you want to get value.
Output
Print an answer for each request of the second type in the order you receive them.
Examples
Input
6
1 2 2 2 3 1
3
2 2 3
1 3 3
2 3 4
Output
2
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 1e5 + 5, B = 310;
vector<int> pos[N * 2], big;
unordered_map<int, int> id;
int a[N], lc[N * 40], rc[N * 40], sum[N * 40], rt[N * 2], root[B + 5],
tag[N * 2], rub[N * 40];
int n, m, tot, cnt_id, top;
inline int newNode() {
if (top) {
int u = rub[top];
--top;
lc[u] = rc[u] = 0;
return u;
}
return ++tot;
}
void add(int &u, int l, int r, int x, int y) {
if (!u) u = newNode();
sum[u] += y;
if (l == r) {
if (!sum[u]) rub[++top] = u, u = 0;
return;
}
int mid = (l + r) >> 1;
if (mid >= x)
add(lc[u], l, mid, x, y);
else
add(rc[u], mid + 1, r, x, y);
if (!sum[u]) rub[++top] = u, u = 0;
}
int query(int u, int l, int r, int x) {
if (!u) return 0;
if (r <= x) return sum[u];
int mid = (l + r) >> 1, ans = query(lc[u], l, mid, x);
if (mid + 1 <= x) ans += query(rc[u], mid + 1, r, x);
return ans;
}
void add(int x, int y) {
if (!id.count(x)) id[x] = ++cnt_id;
x = id[x];
add(rt[x], 1, n, y, 1);
if (!tag[x] && (int)pos[x].size() + 1 > B) {
for (int i = 0; i <= B; i++) add(root[i], 1, n, pos[x][i], -1);
tag[x] = 1;
big.push_back(x);
}
if (tag[x]) return;
pos[x].push_back(y);
int tmp = (int)pos[x].size() - 1;
while (tmp && pos[x][tmp - 1] > pos[x][tmp]) {
add(root[tmp - 1], 1, n, pos[x][tmp - 1], -1);
add(root[tmp], 1, n, pos[x][tmp - 1], 1);
swap(pos[x][tmp - 1], pos[x][tmp]);
--tmp;
}
add(root[tmp], 1, n, y, 1);
}
void del(int x, int y) {
x = id[x];
add(rt[x], 1, n, y, -1);
if (tag[x]) return;
int tmp = lower_bound(pos[x].begin(), pos[x].end(), y) - pos[x].begin();
add(root[tmp], 1, n, y, -1);
while (tmp < (int)pos[x].size() - 1) {
add(root[tmp + 1], 1, n, pos[x][tmp + 1], -1);
add(root[tmp], 1, n, pos[x][tmp + 1], 1);
swap(pos[x][tmp], pos[x][tmp + 1]);
++tmp;
}
pos[x].pop_back();
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]), add(a[i], i);
read(m);
while (m--) {
int opt;
read(opt);
if (opt == 1) {
int x, y;
read(y);
read(x);
del(a[x], x);
a[x] = y;
add(a[x], x);
}
if (opt == 2) {
int x, y;
read(x);
read(y);
if (x == 1)
print(a[y], '\n');
else if (x & 1) {
int rk = query(rt[id[a[y]]], 1, n, y), ans = 0;
if (rk <= B + 1) ans += query(root[rk - 1], 1, n, y);
for (int i = 0; i < (int)big.size(); i++) {
int id = big[i];
ans += (query(rt[id], 1, n, y) >= rk);
}
print(ans, '\n');
} else {
print(query(rt[id[a[y]]], 1, n, y), '\n');
}
}
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Takahashi is not good at problems about trees in programming contests, and Aoki is helping him practice.
First, Takahashi created a tree with N vertices numbered 1 through N, and wrote 0 at each edge.
Then, Aoki gave him M queries. The i-th of them is as follows:
* Increment the number written at each edge along the path connecting vertices a_i and b_i, by one.
After Takahashi executed all of the queries, he told Aoki that, for every edge, the written number became an even number. However, Aoki forgot to confirm that the graph Takahashi created was actually a tree, and it is possible that Takahashi made a mistake in creating a tree or executing queries.
Determine whether there exists a tree that has the property mentioned by Takahashi.
Constraints
* 2 ≤ N ≤ 10^5
* 1 ≤ M ≤ 10^5
* 1 ≤ a_i,b_i ≤ N
* a_i ≠ b_i
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_M b_M
Output
Print `YES` if there exists a tree that has the property mentioned by Takahashi; print `NO` otherwise.
Examples
Input
4 4
1 2
2 4
1 3
3 4
Output
YES
Input
5 5
1 2
3 5
5 1
3 4
2 3
Output
NO
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 5;
int n , m;
int a , b;
int deg[N];
int main(){
scanf("%d %d" , &n , &m);
for(int i = 1 ; i <= m ; ++i){
scanf("%d %d" , &a , &b);
deg[a] ^= 1;
deg[b] ^= 1;
}
puts(*max_element(deg + 1 , deg + 1 + n) ? "NO" : "YES");
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Daenerys Targaryen has an army consisting of k groups of soldiers, the i-th group contains ai soldiers. She wants to bring her army to the other side of the sea to get the Iron Throne. She has recently bought an airplane to carry her army through the sea. The airplane has n rows, each of them has 8 seats. We call two seats neighbor, if they are in the same row and in seats {1, 2}, {3, 4}, {4, 5}, {5, 6} or {7, 8}.
<image> A row in the airplane
Daenerys Targaryen wants to place her army in the plane so that there are no two soldiers from different groups sitting on neighboring seats.
Your task is to determine if there is a possible arranging of her army in the airplane such that the condition above is satisfied.
Input
The first line contains two integers n and k (1 ≤ n ≤ 10000, 1 ≤ k ≤ 100) — the number of rows and the number of groups of soldiers, respectively.
The second line contains k integers a1, a2, a3, ..., ak (1 ≤ ai ≤ 10000), where ai denotes the number of soldiers in the i-th group.
It is guaranteed that a1 + a2 + ... + ak ≤ 8·n.
Output
If we can place the soldiers in the airplane print "YES" (without quotes). Otherwise print "NO" (without quotes).
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
2 2
5 8
Output
YES
Input
1 2
7 1
Output
NO
Input
1 2
4 4
Output
YES
Input
1 4
2 2 1 2
Output
YES
Note
In the first sample, Daenerys can place the soldiers like in the figure below:
<image>
In the second sample, there is no way to place the soldiers in the plane since the second group soldier will always have a seat neighboring to someone from the first group.
In the third example Daenerys can place the first group on seats (1, 2, 7, 8), and the second group an all the remaining seats.
In the fourth example she can place the first two groups on seats (1, 2) and (7, 8), the third group on seats (3), and the fourth group on seats (5, 6).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, s2, s4, s1, er = 2;
long long a[110];
bool cmp(int aa, int bb) { return aa > bb; }
long long T;
int main() {
T = 1;
while (T--) {
scanf("%d%d", &n, &k);
s2 = n * 2;
s4 = n;
s1 = 0;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
sort(a + 1, a + k + 1, cmp);
for (int i = 1; i <= k; i++) {
if (a[i] >= 4) m = min(a[i] / 4, s4), s4 -= m, a[i] -= (m * 4);
if (a[i] == 3 && s4 > 0) s4 -= 1, a[i] -= 3;
if (a[i] >= 2) m = min((a[i]) / 2, s2), s2 -= m, a[i] -= m * 2;
if (a[i] > 0) {
if (s1 > 0 && a[i] == 1)
while (s1 > 0 && a[i] > 0) a[i]--, s1--;
if (a[i] == 0) continue;
if (s4 > 0) {
if (a[i] == 2)
s4--, s1++, a[i] = 0;
else if (a[i] == 1)
s4--, s2++, a[i]--;
}
if (s2 > 0 && a[i] > 0) s2--, m = min(a[i], er), a[i] = a[i] - m;
if (a[i] > 0 && s1 > 0)
while (a[i] && s1) s1--, a[i]--;
if (a[i] <= 0) continue;
printf("NO\n");
return 0;
}
}
printf("YES\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Bearland has n cities, numbered 1 through n. There are m bidirectional roads. The i-th road connects two distinct cities ai and bi. No two roads connect the same pair of cities. It's possible to get from any city to any other city (using one or more roads).
The distance between cities a and b is defined as the minimum number of roads used to travel between a and b.
Limak is a grizzly bear. He is a criminal and your task is to catch him, or at least to try to catch him. You have only two days (today and tomorrow) and after that Limak is going to hide forever.
Your main weapon is BCD (Bear Criminal Detector). Where you are in some city, you can use BCD and it tells you the distance between you and a city where Limak currently is. Unfortunately, BCD can be used only once a day.
You don't know much about Limak's current location. You assume that he is in one of n cities, chosen uniformly at random (each city with probability <image>). You decided for the following plan:
1. Choose one city and use BCD there.
* After using BCD you can try to catch Limak (but maybe it isn't a good idea). In this case you choose one city and check it. You win if Limak is there. Otherwise, Limak becomes more careful and you will never catch him (you loose).
2. Wait 24 hours to use BCD again. You know that Limak will change his location during that time. In detail, he will choose uniformly at random one of roads from his initial city, and he will use the chosen road, going to some other city.
3. Tomorrow, you will again choose one city and use BCD there.
4. Finally, you will try to catch Limak. You will choose one city and check it. You will win if Limak is there, and loose otherwise.
Each time when you choose one of cities, you can choose any of n cities. Let's say it isn't a problem for you to quickly get somewhere.
What is the probability of finding Limak, if you behave optimally?
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 400, <image>) — the number of cities and the number of roads, respectively.
Then, m lines follow. The i-th of them contains two integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — cities connected by the i-th road.
No two roads connect the same pair of cities. It's possible to get from any city to any other city.
Output
Print one real number — the probability of finding Limak, if you behave optimally. Your answer will be considered correct if its absolute error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if |a - b| ≤ 10 - 6.
Examples
Input
3 3
1 2
1 3
2 3
Output
0.833333333333
Input
5 4
1 2
3 1
5 1
1 4
Output
1.000000000000
Input
4 4
1 2
1 3
2 3
1 4
Output
0.916666666667
Input
5 5
1 2
2 3
3 4
4 5
1 5
Output
0.900000000000
Note
In the first sample test, there are three cities and there is a road between every pair of cities. Let's analyze one of optimal scenarios.
1. Use BCD in city 1.
* With probability <image> Limak is in this city and BCD tells you that the distance is 0. You should try to catch him now and you win for sure.
* With probability <image> the distance is 1 because Limak is in city 2 or city 3. In this case you should wait for the second day.
2. You wait and Limak moves to some other city.
* There is probability <image> that Limak was in city 2 and then went to city 3.
* <image> that he went from 2 to 1.
* <image> that he went from 3 to 2.
* <image> that he went from 3 to 1.
3. Use BCD again in city 1 (though it's allowed to use it in some other city).
* If the distance is 0 then you're sure Limak is in this city (you win).
* If the distance is 1 then Limak is in city 2 or city 3. Then you should guess that he is in city 2 (guessing city 3 would be fine too).
You loose only if Limak was in city 2 first and then he moved to city 3. The probability of loosing is <image>. The answer is <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct outputer;
struct outputable {};
const double pi = acos(double(-1));
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 400;
struct Input {
int n;
vector<int> e[N];
bool read() {
int m;
if (!(cin >> n >> m)) {
return 0;
}
for (int i = int(0); i < int(m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
e[x].emplace_back(y);
e[y].emplace_back(x);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
double ans;
void write() { cout << ans << endl; }
};
namespace Main {
struct Solution : Data {
int d[N][N];
double a[N + 2], cur_a[N + 2];
double b[N + 2][N];
double c[N][3];
void solve() {
;
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(n); ++j) {
d[i][j] = N;
}
}
for (int i = int(0); i < int(n); ++i) {
d[i][i] = 0;
for (int j = int(0); j < int(((int)(e[i]).size())); ++j) {
d[i][e[i][j]] = 1;
}
}
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(n); ++j) {
for (int k = int(0); k < int(n); ++k) {
umn(d[j][k], d[j][i] + d[i][k]);
}
}
}
ans = 0;
memset(b, 0, sizeof b);
for (int i = int(0); i < int(n); ++i) {
;
;
;
double cur = 0;
memset(a, 0, sizeof a);
for (int j = int(0); j < int(n); ++j) {
int l1 = d[i][j] + 1;
cur -= a[l1];
umx(a[l1], double(1) / n);
cur += a[l1];
};
;
memset(c, 0, sizeof c);
for (int j = int(0); j < int(n); ++j) {
for (int k : e[j]) {
c[k][d[i][j] + 1 - d[i][k]] += double(1) / (n * ((int)(e[j]).size()));
}
}
for (int j = int(0); j < int(n); ++j) {
;
}
for (int j = int(0); j < int(n); ++j) {
memset(cur_a, 0, sizeof cur_a);
;
;
for (int k = int(0); k < int(n); ++k) {
for (int t = int(0); t < int(3); ++t) {
int l1 = d[i][k] + t;
int l2 = d[j][k];
;
cur_a[l1] -= b[l1][l2];
umx(b[l1][l2], c[k][t]);
cur_a[l1] += b[l1][l2];
cur -= a[l1];
umx(a[l1], cur_a[l1]);
cur += a[l1];
}
}
for (int k = int(0); k < int(n + 2); ++k) {
;
}
for (int k = int(0); k < int(n); ++k) {
for (int t = int(0); t < int(3); ++t) {
int l1 = d[i][k] + t;
int l2 = d[j][k];
b[l1][l2] = 0;
}
}
};
;
umx(ans, cur);
}
}
void clear() { *this = Solution(); }
};
} // namespace Main
Main::Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
One day n cells of some array decided to play the following game. Initially each cell contains a number which is equal to it's ordinal number (starting from 1). Also each cell determined it's favourite number. On it's move i-th cell can exchange it's value with the value of some other j-th cell, if |i - j| = di, where di is a favourite number of i-th cell. Cells make moves in any order, the number of moves is unlimited.
The favourite number of each cell will be given to you. You will also be given a permutation of numbers from 1 to n. You are to determine whether the game could move to this state.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of cells in the array. The second line contains n distinct integers from 1 to n — permutation. The last line contains n integers from 1 to n — favourite numbers of the cells.
Output
If the given state is reachable in the described game, output YES, otherwise NO.
Examples
Input
5
5 4 3 2 1
1 1 1 1 1
Output
YES
Input
7
4 3 5 1 2 7 6
4 6 6 1 6 6 1
Output
NO
Input
7
4 2 5 1 3 7 6
4 6 6 1 6 6 1
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[105], bk[105], tot, q[105];
bool f[105][105];
inline void bfs(int x) {
q[0] = x;
int h = 0, t = 1;
while (h < t) {
for (int i = 1; i <= n; i++) {
if (!f[i][q[h]] || bk[i]) continue;
bk[i] = tot;
q[t++] = i;
}
h++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
int d;
scanf("%d", &d);
if (i > d) f[i - d][i] = f[i][i - d] = 1;
if (i + d <= n) f[i + d][i] = f[i][i + d] = 1;
}
for (int i = 1; i <= n; i++) {
if (bk[i]) continue;
bk[i] = ++tot;
bfs(i);
}
for (int i = 1; i <= n; i++)
if (bk[i] != bk[a[i]]) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Once little Vasya read an article in a magazine on how to make beautiful handmade garland from colored paper. Vasya immediately went to the store and bought n colored sheets of paper, the area of each sheet is 1 square meter.
The garland must consist of exactly m pieces of colored paper of arbitrary area, each piece should be of a certain color. To make the garland, Vasya can arbitrarily cut his existing colored sheets into pieces. Vasya is not obliged to use all the sheets to make the garland.
Vasya wants the garland to be as attractive as possible, so he wants to maximize the total area of m pieces of paper in the garland. Calculate what the maximum total area of the pieces of paper in the garland Vasya can get.
Input
The first line contains a non-empty sequence of n (1 ≤ n ≤ 1000) small English letters ("a"..."z"). Each letter means that Vasya has a sheet of paper of the corresponding color.
The second line contains a non-empty sequence of m (1 ≤ m ≤ 1000) small English letters that correspond to the colors of the pieces of paper in the garland that Vasya wants to make.
Output
Print an integer that is the maximum possible total area of the pieces of paper in the garland Vasya wants to get or -1, if it is impossible to make the garland from the sheets he's got. It is guaranteed that the answer is always an integer.
Examples
Input
aaabbac
aabbccac
Output
6
Input
a
z
Output
-1
Note
In the first test sample Vasya can make an garland of area 6: he can use both sheets of color b, three (but not four) sheets of color a and cut a single sheet of color c in three, for example, equal pieces. Vasya can use the resulting pieces to make a garland of area 6.
In the second test sample Vasya cannot make a garland at all — he doesn't have a sheet of color z.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 0;
string s, t, k;
cin >> t >> s;
k = t;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < t.size(); j++) {
if (s[i] == t[j]) {
c++;
t.erase(j, 1);
break;
} else if (!(k.find(s[i]) != -1)) {
cout << -1;
return 0;
}
}
}
cout << c;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are N dots in a two-dimensional plane. The coordinates of the i-th dot are (x_i, y_i).
We will repeat the following operation as long as possible:
* Choose four integers a, b, c, d (a \neq c, b \neq d) such that there are dots at exactly three of the positions (a, b), (a, d), (c, b) and (c, d), and add a dot at the remaining position.
We can prove that we can only do this operation a finite number of times. Find the maximum number of times we can do the operation.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq x_i, y_i \leq 10^5
* If i \neq j, x_i \neq x_j or y_i \neq y_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
:
x_N y_N
Output
Print the maximum number of times we can do the operation.
Examples
Input
3
1 1
5 1
5 5
Output
1
Input
2
10 10
20 20
Output
0
Input
9
1 1
2 1
3 1
4 1
5 1
1 2
1 3
1 4
1 5
Output
16
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
const ll INF=1e18;
vector<vector<ll>>x(100005);
vector<vector<ll>>y(100005);
vector<vector<ll>> used(2, vector<ll> (100005,0));
ll cx,cy;
void dfs(int t, int n){
if (used[n][t]==1)return;
used[n][t]=1;
if (n==0){
cx++;
n++;
n%=2;
// cout<<"t"<<t<<"cx"<<cx<<endl;
for (ll to:x[t]){
dfs(to,n);
// return;
}
}
else if(n==1){
cy++;
// cout<<"t"<<t<<"cy"<<cy<<endl;
n++;
n%=2;
for (ll to:y[t]){
dfs(to,n);
// return;
}
}
}
int main() {
ll n;
cin >> n;
vector<P> v(n);
rep(i,n){
ll a1,b1;
cin>>a1>>b1;
v[i]=make_pair(a1,b1);
x[a1].push_back(b1);
y[b1].push_back(a1);
}
ll ans=0;
rep(i,n){
cx=0;
cy=0;
dfs(v[i].first,0);
// cout<<"i"<<i<<cx<<" "<<cy<<endl;
ans+=cx*cy;
}
ans-=n;
cout<<ans;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Luba has to do n chores today. i-th chore takes ai units of time to complete. It is guaranteed that for every <image> the condition ai ≥ ai - 1 is met, so the sequence is sorted.
Also Luba can work really hard on some chores. She can choose not more than k any chores and do each of them in x units of time instead of ai (<image>).
Luba is very responsible, so she has to do all n chores, and now she wants to know the minimum time she needs to do everything. Luba cannot do two chores simultaneously.
Input
The first line contains three integers n, k, x (1 ≤ k ≤ n ≤ 100, 1 ≤ x ≤ 99) — the number of chores Luba has to do, the number of chores she can do in x units of time, and the number x itself.
The second line contains n integer numbers ai (2 ≤ ai ≤ 100) — the time Luba has to spend to do i-th chore.
It is guaranteed that <image>, and for each <image> ai ≥ ai - 1.
Output
Print one number — minimum time Luba needs to do all n chores.
Examples
Input
4 2 2
3 6 7 10
Output
13
Input
5 2 1
100 100 100 100 100
Output
302
Note
In the first example the best option would be to do the third and the fourth chore, spending x = 2 time on each instead of a3 and a4, respectively. Then the answer is 3 + 6 + 2 + 2 = 13.
In the second example Luba can choose any two chores to spend x time on them instead of ai. So the answer is 100·3 + 2·1 = 302.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e6;
const int mod1 = 1e9 + 7;
const int mod2 = 998244353;
const long long inf = 1e18;
const double pi = 3.1415926535897932384626;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long mpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long inv(long long a, long long m) { return mpow(a, m - 2, m); }
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long ncr(long long n, long long k) {
if (n < k) return 0;
long long C[n + 1][k + 1];
long long i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]);
}
}
return C[n][k];
}
void solve() {
int n, k, x;
cin >> n >> k >> x;
int c = k * x;
int p = n - k;
int a[n], sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < p; i++) {
sum += a[i];
}
cout << sum + c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t start, end;
start = clock();
solve();
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
cerr << "\nTime : " << fixed << time_taken << setprecision(5) << " s \n";
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given a huge decimal number consisting of n digits. It is guaranteed that this number has no leading zeros. Each digit of this number is either 0 or 1.
You may perform several (possibly zero) operations with this number. During each operation you are allowed to change any digit of your number; you may change 0 to 1 or 1 to 0. It is possible that after some operation you can obtain a number with leading zeroes, but it does not matter for this problem.
You are also given two integers 0 ≤ y < x < n. Your task is to calculate the minimum number of operations you should perform to obtain the number that has remainder 10^y modulo 10^x. In other words, the obtained number should have remainder 10^y when divided by 10^x.
Input
The first line of the input contains three integers n, x, y (0 ≤ y < x < n ≤ 2 ⋅ 10^5) — the length of the number and the integers x and y, respectively.
The second line of the input contains one decimal number consisting of n digits, each digit of this number is either 0 or 1. It is guaranteed that the first digit of the number is 1.
Output
Print one integer — the minimum number of operations you should perform to obtain the number having remainder 10^y modulo 10^x. In other words, the obtained number should have remainder 10^y when divided by 10^x.
Examples
Input
11 5 2
11010100101
Output
1
Input
11 5 1
11010100101
Output
3
Note
In the first example the number will be 11010100100 after performing one operation. It has remainder 100 modulo 100000.
In the second example the number will be 11010100010 after performing three operations. It has remainder 10 modulo 100000.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int main() {
int n, x, y, ans = 0;
cin >> n >> x >> y;
string s;
cin >> s;
for (int i = n - x; i < n; i++) {
if (i == n - 1 - y) {
if (s[i] != '1') ans++;
} else {
if (s[i] != '0') ans++;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Valera has n counters numbered from 1 to n. Some of them are connected by wires, and each of the counters has a special button.
Initially, all the counters contain number 0. When you press a button on a certain counter, the value it has increases by one. Also, the values recorded in all the counters, directly connected to it by a wire, increase by one.
Valera and Ignat started having a dispute, the dispute is as follows. Ignat thought of a sequence of n integers a1, a2, ..., an. Valera should choose some set of distinct counters and press buttons on each of them exactly once (on other counters the buttons won't be pressed). If after that there is a counter with the number i, which has value ai, then Valera loses the dispute, otherwise he wins the dispute.
Help Valera to determine on which counters he needs to press a button to win the dispute.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105), that denote the number of counters Valera has and the number of pairs of counters connected by wires.
Each of the following m lines contains two space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that mean that counters with numbers ui and vi are connected by a wire. It is guaranteed that each pair of connected counters occurs exactly once in the input.
The last line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 105), where ai is the value that Ignat choose for the i-th counter.
Output
If Valera can't win the dispute print in the first line -1.
Otherwise, print in the first line integer k (0 ≤ k ≤ n). In the second line print k distinct space-separated integers — the numbers of the counters, where Valera should push buttons to win the dispute, in arbitrary order.
If there exists multiple answers, you are allowed to print any of them.
Examples
Input
5 5
2 3
4 1
1 5
5 3
2 1
1 1 2 0 2
Output
2
1 2
Input
4 2
1 2
3 4
0 0 0 0
Output
3
1 3 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXX = 1e6;
vector<int> vec[MAXX], ans;
int c[MAXX], cnt[MAXX];
queue<int> qu;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
vec[a].push_back(b);
vec[b].push_back(a);
}
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n; i++)
if (c[i] == cnt[i]) qu.push(i);
while (qu.size() > 0) {
int v = qu.front();
qu.pop();
if (cnt[v] != c[v]) continue;
cnt[v]++;
ans.push_back(v);
for (int i = 0; i < vec[v].size(); i++) {
int u = vec[v][i];
cnt[u]++;
if (cnt[u] == c[u]) qu.push(u);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Lindsey Buckingham told Stevie Nicks ["Go your own way"](https://www.youtube.com/watch?v=6ul-cZyuYq4). Nicks is now sad and wants to go away as quickly as possible, but she lives in a 2D hexagonal world.
Consider a hexagonal tiling of the plane as on the picture below.
<image>
Nicks wishes to go from the cell marked (0, 0) to a certain cell given by the coordinates. She may go from a hexagon to any of its six neighbors you want, but there is a cost associated with each of them. The costs depend only on the direction in which you travel. Going from (0, 0) to (1, 1) will take the exact same cost as going from (-2, -1) to (-1, 0). The costs are given in the input in the order c_1, c_2, c_3, c_4, c_5, c_6 as in the picture below.
<image>
Print the smallest cost of a path from the origin which has coordinates (0, 0) to the given cell.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^{4}). Description of the test cases follows.
The first line of each test case contains two integers x and y (-10^{9} ≤ x, y ≤ 10^{9}) representing the coordinates of the target hexagon.
The second line of each test case contains six integers c_1, c_2, c_3, c_4, c_5, c_6 (1 ≤ c_1, c_2, c_3, c_4, c_5, c_6 ≤ 10^{9}) representing the six costs of the making one step in a particular direction (refer to the picture above to see which edge is for each value).
Output
For each testcase output the smallest cost of a path from the origin to the given cell.
Example
Input
2
-3 1
1 3 5 7 9 11
1000000000 1000000000
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
18
1000000000000000000
Note
The picture below shows the solution for the first sample. The cost 18 is reached by taking c_3 3 times and c_2 once, amounting to 5+5+5+3=18.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll c[10];
int dx[] = {1, 0, -1, -1, 0, 1};
int dy[] = {1, 1, 0, -1, -1, 0};
int main() {
int t;
cin >> t;
while (t--) {
ll x, y;
cin >> x >> y;
for (int i = 0; i < 6; ++i) cin >> c[i];
long long ans = 5e18;
for (int i = 0; i < 6; ++i) {
for (int j = i; j < 6; ++j) {
int det = dx[i] * dy[j] - dx[j] * dy[i];
if (det != 0) {
long long t1 = (x * dy[j] - y * dx[j]) / det;
long long t2 = (dx[i] * y - dy[i] * x) / det;
if (t1 >= 0 && t2 >= 0) {
ans = min(ans, t1 * c[i] + t2 * c[j]);
}
}
}
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given string s consists of opening and closing brackets of four kinds <>, {}, [], (). There are two types of brackets: opening and closing. You can replace any bracket by another of the same type. For example, you can replace < by the bracket {, but you can't replace it by ) or >.
The following definition of a regular bracket sequence is well-known, so you can be familiar with it.
Let's define a regular bracket sequence (RBS). Empty string is RBS. Let s1 and s2 be a RBS then the strings <s1>s2, {s1}s2, [s1]s2, (s1)s2 are also RBS.
For example the string "[[(){}]<>]" is RBS, but the strings "[)()" and "][()()" are not.
Determine the least number of replaces to make the string s RBS.
Input
The only line contains a non empty string s, consisting of only opening and closing brackets of four kinds. The length of s does not exceed 106.
Output
If it's impossible to get RBS from s print Impossible.
Otherwise print the least number of replaces needed to get RBS from s.
Examples
Input
[<}){}
Output
2
Input
{()}[]
Output
0
Input
]]
Output
Impossible
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long sum = 0;
stack<char> sol;
string s;
cin >> s;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == '(' || s[i] == '{' || s[i] == '[' || s[i] == '<') {
sol.push(s[i]);
} else if (sol.empty()) {
cout << "Impossible";
return 0;
} else if (s[i] == ')') {
if (sol.top() == '(')
sol.pop();
else {
sum++;
sol.pop();
}
} else if (s[i] == '}') {
if (sol.top() == '{')
sol.pop();
else {
sum++;
sol.pop();
}
} else if (s[i] == ']') {
if (sol.top() == '[')
sol.pop();
else {
sum++;
sol.pop();
}
} else if (s[i] == '>') {
if (sol.top() == '<')
sol.pop();
else {
sum++;
sol.pop();
}
}
}
if (sol.empty())
cout << sum;
else
cout << "Impossible";
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Koa the Koala has a binary string s of length n. Koa can perform no more than n-1 (possibly zero) operations of the following form:
In one operation Koa selects positions i and i+1 for some i with 1 ≤ i < |s| and sets s_i to max(s_i, s_{i+1}). Then Koa deletes position i+1 from s (after the removal, the remaining parts are concatenated).
Note that after every operation the length of s decreases by 1.
How many different binary strings can Koa obtain by doing no more than n-1 (possibly zero) operations modulo 10^9+7 (1000000007)?
Input
The only line of input contains binary string s (1 ≤ |s| ≤ 10^6). For all i (1 ≤ i ≤ |s|) s_i = 0 or s_i = 1.
Output
On a single line print the answer to the problem modulo 10^9+7 (1000000007).
Examples
Input
000
Output
3
Input
0101
Output
6
Input
0001111
Output
16
Input
00101100011100
Output
477
Note
In the first sample Koa can obtain binary strings: 0, 00 and 000.
In the second sample Koa can obtain binary strings: 1, 01, 11, 011, 101 and 0101. For example:
* to obtain 01 from 0101 Koa can operate as follows: 0101 → 0(10)1 → 011 → 0(11) → 01.
* to obtain 11 from 0101 Koa can operate as follows: 0101 → (01)01 → 101 → 1(01) → 11.
Parentheses denote the two positions Koa selected in each operation.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007, MX = 1000100;
int n, m, i, lft, cur, sum, pos, a[MX];
long long rgh;
char s[MX];
bool was;
int main() {
scanf("%s", s);
n = strlen(s);
for (lft = rgh = -1, i = 0; i < n; i++)
if (s[i] == '1') {
was = true;
rgh = i;
} else if (!was)
lft = i;
if (!was) {
printf("%d\n", n);
return 0;
}
a[0] = sum = 1;
for (i = lft + 1; i <= rgh; i++)
if (s[i] == '0') {
++pos;
sum = (sum + md - a[pos]) % md;
a[pos] = cur;
sum = (sum + a[pos]) % md;
} else {
cur = (cur + sum) % md;
pos = 0;
}
cur = (cur * (lft + 2LL)) % md;
cur = (cur * (n - rgh)) % md;
printf("%d\n", cur);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given N items.
The value of the i-th item (1 \leq i \leq N) is v_i.
Your have to select at least A and at most B of these items.
Under this condition, find the maximum possible arithmetic mean of the values of selected items.
Additionally, find the number of ways to select items so that the mean of the values of selected items is maximized.
Constraints
* 1 \leq N \leq 50
* 1 \leq A,B \leq N
* 1 \leq v_i \leq 10^{15}
* Each v_i is an integer.
Input
The input is given from Standard Input in the following format:
N A B
v_1
v_2
...
v_N
Output
Print two lines.
The first line should contain the maximum possible arithmetic mean of the values of selected items. The output should be considered correct if the absolute or relative error is at most 10^{-6}.
The second line should contain the number of ways to select items so that the mean of the values of selected items is maximized.
Examples
Input
5 2 2
1 2 3 4 5
Output
4.500000
1
Input
4 2 3
10 20 10 10
Output
15.000000
3
Input
5 1 5
1000000000000000 999999999999999 999999999999998 999999999999997 999999999999996
Output
1000000000000000.000000
1
### Response
```cpp
#include<cstdio>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
ll v[55];
ll ans=0;
void cnt(int a,int b){
double sum=1;
if(a>b/2)
a=b-a;
for(int i=b,j=1;i>=b-a+1;i--,j++){
sum*=i*1.0/j;
}
ans+=sum;
}
bool cmp(ll a,ll b){
return a>b;//从大到小排序
}
int main(){
int n,min_,max_;
scanf("%d %d %d",&n,&min_,&max_);
for(int i=1;i<=n;i++){
scanf("%lld",&v[i]);
}
sort(v+1,v+n+1,cmp);
int num=min_;
double ave=0;
ave+=v[1];
int same=1,dsam;
for(int i=2;i<=min_;i++){
ave+=v[i];
if(v[i]==v[i-1]){
same++;
}
else {
same=1;
}
}
ave/=num;//计算选最少的数时最大平均值
dsam=min_-same;//已选择的不同的数
for(int i=min_+1;v[i]==v[min_]&&i<=n;i++){
same++;//已选择+未选择的相同的数
}
if(dsam==0){//如果所有的数都相同
for(int k=min_;k<=max_;k++){
if(k>same)
break;
cnt(k,same);
}
}
else {
cnt(min_-dsam,same);
}
printf("%.6lf\n%lld\n",ave,ans);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
A social network for dogs called DH (DogHouse) has k special servers to recompress uploaded videos of cute cats. After each video is uploaded, it should be recompressed on one (any) of the servers, and only after that it can be saved in the social network.
We know that each server takes one second to recompress a one minute fragment. Thus, any server takes m seconds to recompress a m minute video.
We know the time when each of the n videos were uploaded to the network (in seconds starting from the moment all servers started working). All videos appear at different moments of time and they are recompressed in the order they appear. If some video appeared at time s, then its recompressing can start at that very moment, immediately. Some videos can await recompressing when all the servers are busy. In this case, as soon as a server is available, it immediately starts recompressing another video. The videos that await recompressing go in a queue. If by the moment the videos started being recompressed some servers are available, then any of them starts recompressing the video.
For each video find the moment it stops being recompressed.
Input
The first line of the input contains integers n and k (1 ≤ n, k ≤ 5·105) — the number of videos and servers, respectively.
Next n lines contain the descriptions of the videos as pairs of integers si, mi (1 ≤ si, mi ≤ 109), where si is the time in seconds when the i-th video appeared and mi is its duration in minutes. It is guaranteed that all the si's are distinct and the videos are given in the chronological order of upload, that is in the order of increasing si.
Output
Print n numbers e1, e2, ..., en, where ei is the time in seconds after the servers start working, when the i-th video will be recompressed.
Examples
Input
3 2
1 5
2 5
3 5
Output
6
7
11
Input
6 1
1 1000000000
2 1000000000
3 1000000000
4 1000000000
5 1000000000
6 3
Output
1000000001
2000000001
3000000001
4000000001
5000000001
5000000004
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &n) {
char c;
n = 0;
long long x = 1;
while (!isdigit(c = fgetc(stdin)) && c != '-')
;
if (c == '-') x = -1, c = fgetc(stdin);
while (isdigit(c)) n = n * 10 + c - '0', c = fgetc(stdin);
n *= x;
}
inline void read(int &n) {
long long x;
read(x);
n = x;
}
template <typename T1, typename T2>
inline void read(T1 &a, T2 &b) {
read(a);
read(b);
}
template <typename T1, typename T2, typename T3>
inline void read(T1 &a, T2 &b, T3 &c) {
read(a);
read(b);
read(c);
}
template <typename T1, typename T2, typename T3, typename T4>
inline void read(T1 &a, T2 &b, T3 &c, T4 &d) {
read(a);
read(b);
read(c);
read(d);
}
priority_queue<long long> servers;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (__typeof(0) i = (0) - ((0) > (m)), a = (m) - ((0) > (m)); i != a;
i += 1 - 2 * ((0) > (m)))
servers.push(1);
for (__typeof(0) i = (0) - ((0) > (n)), a = (n) - ((0) > (n)); i != a;
i += 1 - 2 * ((0) > (n))) {
int s, t;
scanf("%d%d", &s, &t);
long long e = max(-servers.top(), (long long)s + 1) + t - 1;
servers.pop();
servers.push(-(e + 1));
printf("%I64d\n", e);
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Andrew and Eugene are playing a game. Initially, Andrew has string s, consisting of digits. Eugene sends Andrew multiple queries of type "di → ti", that means "replace all digits di in string s with substrings equal to ti". For example, if s = 123123, then query "2 → 00" transforms s to 10031003, and query "3 → " ("replace 3 by an empty string") transforms it to s = 1212. After all the queries Eugene asks Andrew to find the remainder after division of number with decimal representation equal to s by 1000000007 (109 + 7). When you represent s as a decimal number, please ignore the leading zeroes; also if s is an empty string, then it's assumed that the number equals to zero.
Andrew got tired of processing Eugene's requests manually and he asked you to write a program for that. Help him!
Input
The first line contains string s (1 ≤ |s| ≤ 105), consisting of digits — the string before processing all the requests.
The second line contains a single integer n (0 ≤ n ≤ 105) — the number of queries.
The next n lines contain the descriptions of the queries. The i-th query is described by string "di->ti", where di is exactly one digit (from 0 to 9), ti is a string consisting of digits (ti can be an empty string). The sum of lengths of ti for all queries doesn't exceed 105. The queries are written in the order in which they need to be performed.
Output
Print a single integer — remainder of division of the resulting number by 1000000007 (109 + 7).
Examples
Input
123123
1
2->00
Output
10031003
Input
123123
1
3->
Output
1212
Input
222
2
2->0
0->7
Output
777
Input
1000000008
0
Output
1
Note
Note that the leading zeroes are not removed from string s after the replacement (you can see it in the third sample).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const long double pi = acos(-1.0);
int n;
int m;
const int mod = 1e9 + 7;
string s;
char buf[100100];
int a[10], b[10];
int v[100100][10];
string ss[100100];
int res[100100];
int len10[100100];
long long len[100100];
long long pow10(long long l) {
long long res = 1, mul = 10;
for (; l > 0; l >>= 1) {
if (l & 1) res = (res * mul) % mod;
mul = (mul * mul) % mod;
}
return res;
}
int main() {
cin >> ss[0];
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
char ch;
scanf("%c->", &ch);
ch -= '0';
gets(buf);
ss[i] = buf;
if (a[ch]) b[ch] = a[ch];
a[ch] = i;
for (int j = b[ch]; j < i; j++) v[j][ch] = i;
}
for (int i = n; i >= 0; i--) {
long long l = 0;
long long h = 0;
for (int j = 0; j < ((int)(ss[i]).size()); j++) {
int k = v[i][ss[i][j] - '0'];
if (k) {
h = h * len10[k] + res[k];
l = (l + len[k]) % (mod - 1);
} else {
h = h * 10 + ss[i][j] - '0';
l++;
}
h %= mod;
}
len[i] = l;
len10[i] = pow10(l);
res[i] = h;
}
printf("%d\n", res[0]);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a rectangle grid. That grid's size is n × m. Let's denote the coordinate system on the grid. So, each point on the grid will have coordinates — a pair of integers (x, y) (0 ≤ x ≤ n, 0 ≤ y ≤ m).
Your task is to find a maximum sub-rectangle on the grid (x1, y1, x2, y2) so that it contains the given point (x, y), and its length-width ratio is exactly (a, b). In other words the following conditions must hold: 0 ≤ x1 ≤ x ≤ x2 ≤ n, 0 ≤ y1 ≤ y ≤ y2 ≤ m, <image>.
The sides of this sub-rectangle should be parallel to the axes. And values x1, y1, x2, y2 should be integers.
<image>
If there are multiple solutions, find the rectangle which is closest to (x, y). Here "closest" means the Euclid distance between (x, y) and the center of the rectangle is as small as possible. If there are still multiple solutions, find the lexicographically minimum one. Here "lexicographically minimum" means that we should consider the sub-rectangle as sequence of integers (x1, y1, x2, y2), so we can choose the lexicographically minimum one.
Input
The first line contains six integers n, m, x, y, a, b (1 ≤ n, m ≤ 109, 0 ≤ x ≤ n, 0 ≤ y ≤ m, 1 ≤ a ≤ n, 1 ≤ b ≤ m).
Output
Print four integers x1, y1, x2, y2, which represent the founded sub-rectangle whose left-bottom point is (x1, y1) and right-up point is (x2, y2).
Examples
Input
9 9 5 5 2 1
Output
1 3 9 7
Input
100 100 52 50 46 56
Output
17 8 86 92
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long qq;
long long l, mm, r;
long long lx, rx, ly, ry, ta, tb;
long long n, m, x, y, a, b;
long long span;
long long stepp;
long long gcd(long long a, long long b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
bool cp(long long mid) {
ta = mid * a;
tb = mid * b;
lx = max(0ll, x - ta);
rx = min(n, x + ta);
ly = max(0ll, y - tb);
ry = min(m, y + tb);
if (lx + ta <= rx && ly + tb <= ry) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> x >> y >> a >> b;
qq = gcd(a, b);
a /= qq;
b /= qq;
l = 0;
r = 1000000000;
while (l < r) {
mm = l + r + 1;
mm /= 2;
if (cp(mm))
l = mm;
else
r = mm - 1;
}
mm = cp(l);
span = ta;
rx -= ta;
stepp = span / 2 + (span % 2 > 0);
lx = min(rx, max(lx, x - stepp));
span = tb;
ry -= tb;
stepp = span / 2 + (span % 2 > 0);
ly = min(ry, max(ly, y - stepp));
cout << lx << " " << ly << " " << lx + ta << " " << ly + tb << endl;
cin.get();
cin.get();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given $n$ packages of $w_i$ kg from a belt conveyor in order ($i = 0, 1, ... n-1$). You should load all packages onto $k$ trucks which have the common maximum load $P$. Each truck can load consecutive packages (more than or equals to zero) from the belt conveyor unless the total weights of the packages in the sequence does not exceed the maximum load $P$.
Write a program which reads $n$, $k$ and $w_i$, and reports the minimum value of the maximum load $P$ to load all packages from the belt conveyor.
Constraints
* $1 \leq n \leq 100,000$
* $1 \leq k \leq 100,000$
* $1 \leq w_i \leq 10,000$
Input
In the first line, two integers $n$ and $k$ are given separated by a space character. In the following $n$ lines, $w_i$ are given respectively.
Output
Print the minimum value of $P$ in a line.
Examples
Input
5 3
8
1
7
3
9
Output
10
Input
4 2
1
2
2
6
Output
6
### Response
```cpp
#include<iostream>
using namespace std;
int n, k;
long long int T[100000];
long long sum;
long long l;
int check(long long p) {
int m = 0;
for (int i = 0; i < k; i++) {
long long s = 0;
while (s + T[m] <= p) {
s += T[m];
m++;
if (m >= n) {
return n;
}
}
}
return m;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> T[i];
sum += T[i];
}
l = sum / k;
while (check(l) != n) {
l++;
}
cout << l << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
As you must know, the maximum clique problem in an arbitrary graph is NP-hard. Nevertheless, for some graphs of specific kinds it can be solved effectively.
Just in case, let us remind you that a clique in a non-directed graph is a subset of the vertices of a graph, such that any two vertices of this subset are connected by an edge. In particular, an empty set of vertexes and a set consisting of a single vertex, are cliques.
Let's define a divisibility graph for a set of positive integers A = {a1, a2, ..., an} as follows. The vertices of the given graph are numbers from set A, and two numbers ai and aj (i ≠ j) are connected by an edge if and only if either ai is divisible by aj, or aj is divisible by ai.
You are given a set of non-negative integers A. Determine the size of a maximum clique in a divisibility graph for set A.
Input
The first line contains integer n (1 ≤ n ≤ 106), that sets the size of set A.
The second line contains n distinct positive integers a1, a2, ..., an (1 ≤ ai ≤ 106) — elements of subset A. The numbers in the line follow in the ascending order.
Output
Print a single number — the maximum size of a clique in a divisibility graph for set A.
Examples
Input
8
3 4 6 8 10 18 21 24
Output
3
Note
In the first sample test a clique of size 3 is, for example, a subset of vertexes {3, 6, 18}. A clique of a larger size doesn't exist in this graph.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1100001];
bool x[1100001];
int dp[1100001];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
x[a[i]] = true;
dp[a[i]] = 1;
}
for (int i = 1; i <= 1000000; ++i) {
if (x[i]) {
for (int j = i + i; j <= 1000000; j += i)
if (x[j]) dp[j] = max(dp[j], dp[i] + 1);
}
}
int mx = 0;
for (int i = 1; i <= 1000000; ++i) {
mx = max(mx, dp[i]);
}
cout << mx;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You have been blessed as a child of Omkar. To express your gratitude, please solve this problem for Omkar!
An array a of length n is called complete if all elements are positive and don't exceed 1000, and for all indices x,y,z (1 ≤ x,y,z ≤ n), a_{x}+a_{y} ≠ a_{z} (not necessarily distinct).
You are given one integer n. Please find any complete array of length n. It is guaranteed that under given constraints such array exists.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 1000) — the number of test cases. Description of the test cases follows.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000).
It is guaranteed that the sum of n over all test cases does not exceed 1000.
Output
For each test case, print a complete array on a single line. All elements have to be integers between 1 and 1000 and for all indices x,y,z (1 ≤ x,y,z ≤ n) (not necessarily distinct), a_{x}+a_{y} ≠ a_{z} must hold.
If multiple solutions exist, you may print any.
Example
Input
2
5
4
Output
1 5 3 77 12
384 384 44 44
Note
It can be shown that the outputs above are valid for each test case. For example, 44+44 ≠ 384.
Below are some examples of arrays that are NOT complete for the 1st test case:
[1,2,3,4,5]
Notice that a_{1}+a_{2} = a_{3}.
[1,3000,1,300,1]
Notice that a_{2} = 3000 > 1000.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cout << "1"
<< " ";
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
And here goes another problem on arrays. You are given positive integer len and array a which consists of n integers a1, a2, ..., an. Let's introduce two characteristics for the given array.
* Let's consider an arbitrary interval of the array with length len, starting in position i. Value <image>, is the modular sum on the chosen interval. In other words, the modular sum is the sum of integers on the chosen interval with length len, taken in its absolute value.
* Value <image> is the optimal sum of the array. In other words, the optimal sum of an array is the maximum of all modular sums on various intervals of array with length len.
Your task is to calculate the optimal sum of the given array a. However, before you do the calculations, you are allowed to produce no more than k consecutive operations of the following form with this array: one operation means taking an arbitrary number from array ai and multiply it by -1. In other words, no more than k times you are allowed to take an arbitrary number ai from the array and replace it with - ai. Each number of the array is allowed to choose an arbitrary number of times.
Your task is to calculate the maximum possible optimal sum of the array after at most k operations described above are completed.
Input
The first line contains two integers n, len (1 ≤ len ≤ n ≤ 105) — the number of elements in the array and the length of the chosen subinterval of the array, correspondingly.
The second line contains a sequence consisting of n integers a1, a2, ..., an (|ai| ≤ 109) — the original array.
The third line contains a single integer k (0 ≤ k ≤ n) — the maximum allowed number of operations.
All numbers in lines are separated by a single space.
Output
In a single line print the maximum possible optimal sum after no more than k acceptable operations are fulfilled.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
5 3
0 -2 3 -5 1
2
Output
10
Input
5 2
1 -3 -10 4 1
3
Output
14
Input
3 3
-2 -5 4
1
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, len, k, ans;
cin >> n >> len;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
cin >> k;
long long sum = 0, sumout = 0;
multiset<long long> negout;
multiset<long long> negin;
for (int i = 0; i < len; i++) {
sum += abs(a[i]);
if (a[i] < 0) {
if (negin.size() < k)
negin.insert(abs(a[i]));
else if (k && *negin.begin() < abs(a[i])) {
sumout += *negin.begin();
negout.insert(*negin.begin());
negin.erase(negin.begin());
negin.insert(abs(a[i]));
} else {
sumout += abs(a[i]);
negout.insert(abs(a[i]));
}
}
}
ans = sum - 2 * sumout;
multiset<long long>::iterator it;
for (int j = len; j < n; j++) {
sum -= abs(a[j - len]);
if (a[j - len] < 0) {
it = negout.find(abs(a[j - len]));
if (it != negout.end()) {
sumout -= abs(a[j - len]);
negout.erase(it);
} else {
negin.erase(negin.find(abs(a[j - len])));
if (negout.size()) {
it = negout.end();
it--;
sumout -= *it;
negin.insert(*it);
negout.erase(it);
}
}
}
sum += abs(a[j]);
if (a[j] < 0) {
if (negin.size() < k)
negin.insert(abs(a[j]));
else if (k && *negin.begin() < abs(a[j])) {
sumout += *negin.begin();
negout.insert(*negin.begin());
negin.erase(negin.begin());
negin.insert(abs(a[j]));
} else {
sumout += abs(a[j]);
negout.insert(abs(a[j]));
}
}
ans = max(ans, sum - 2 * sumout);
}
for (int i = 0; i < n; i++) a[i] = -a[i];
negout.clear();
negin.clear();
sum = 0;
sumout = 0;
for (int i = 0; i < len; i++) {
sum += abs(a[i]);
if (a[i] < 0) {
if (negin.size() < k)
negin.insert(abs(a[i]));
else if (k && *negin.begin() < abs(a[i])) {
sumout += *negin.begin();
negout.insert(*negin.begin());
negin.erase(negin.begin());
negin.insert(abs(a[i]));
} else {
sumout += abs(a[i]);
negout.insert(abs(a[i]));
}
}
}
ans = max(ans, sum - 2 * sumout);
for (int j = len; j < n; j++) {
sum -= abs(a[j - len]);
if (a[j - len] < 0) {
it = negout.find(abs(a[j - len]));
if (it != negout.end()) {
sumout -= abs(a[j - len]);
negout.erase(it);
} else {
negin.erase(negin.find(abs(a[j - len])));
if (negout.size()) {
it = negout.end();
it--;
sumout -= *it;
negin.insert(*it);
negout.erase(it);
}
}
}
sum += abs(a[j]);
if (a[j] < 0) {
if (negin.size() < k)
negin.insert(abs(a[j]));
else if (k && *negin.begin() < abs(a[j])) {
sumout += *negin.begin();
negout.insert(*negin.begin());
negin.erase(negin.begin());
negin.insert(abs(a[j]));
} else {
sumout += abs(a[j]);
negout.insert(abs(a[j]));
}
}
ans = max(ans, sum - 2 * sumout);
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You a captain of a ship. Initially you are standing in a point (x_1, y_1) (obviously, all positions in the sea can be described by cartesian plane) and you want to travel to a point (x_2, y_2).
You know the weather forecast — the string s of length n, consisting only of letters U, D, L and R. The letter corresponds to a direction of wind. Moreover, the forecast is periodic, e.g. the first day wind blows to the side s_1, the second day — s_2, the n-th day — s_n and (n+1)-th day — s_1 again and so on.
Ship coordinates change the following way:
* if wind blows the direction U, then the ship moves from (x, y) to (x, y + 1);
* if wind blows the direction D, then the ship moves from (x, y) to (x, y - 1);
* if wind blows the direction L, then the ship moves from (x, y) to (x - 1, y);
* if wind blows the direction R, then the ship moves from (x, y) to (x + 1, y).
The ship can also either go one of the four directions or stay in place each day. If it goes then it's exactly 1 unit of distance. Transpositions of the ship and the wind add up. If the ship stays in place, then only the direction of wind counts. For example, if wind blows the direction U and the ship moves the direction L, then from point (x, y) it will move to the point (x - 1, y + 1), and if it goes the direction U, then it will move to the point (x, y + 2).
You task is to determine the minimal number of days required for the ship to reach the point (x_2, y_2).
Input
The first line contains two integers x_1, y_1 (0 ≤ x_1, y_1 ≤ 10^9) — the initial coordinates of the ship.
The second line contains two integers x_2, y_2 (0 ≤ x_2, y_2 ≤ 10^9) — the coordinates of the destination point.
It is guaranteed that the initial coordinates and destination point coordinates are different.
The third line contains a single integer n (1 ≤ n ≤ 10^5) — the length of the string s.
The fourth line contains the string s itself, consisting only of letters U, D, L and R.
Output
The only line should contain the minimal number of days required for the ship to reach the point (x_2, y_2).
If it's impossible then print "-1".
Examples
Input
0 0
4 6
3
UUU
Output
5
Input
0 3
0 0
3
UDD
Output
3
Input
0 0
0 1
1
L
Output
-1
Note
In the first example the ship should perform the following sequence of moves: "RRRRU". Then its coordinates will change accordingly: (0, 0) → (1, 1) → (2, 2) → (3, 3) → (4, 4) → (4, 6).
In the second example the ship should perform the following sequence of moves: "DD" (the third day it should stay in place). Then its coordinates will change accordingly: (0, 3) → (0, 3) → (0, 1) → (0, 0).
In the third example the ship can never reach the point (0, 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double PI = 3.1415926535897932384626;
int main() {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long int n;
cin >> n;
string s;
cin >> s;
x2 -= x1;
y2 -= y1;
vector<pair<long long int, long long int> > v;
v.push_back({0, 0});
for (int i = 0; i < n; i++) {
long long int xd = 0, yd = 0;
if (s[i] == 'U') {
yd++;
}
if (s[i] == 'D') {
yd--;
}
if (s[i] == 'R') {
xd++;
}
if (s[i] == 'L') {
xd--;
}
v.push_back(v[v.size() - 1]);
v[i + 1].first += xd;
v[i + 1].second += yd;
}
long long int xd = v[n].first, yd = v[n].second;
long long int l = 0, r = 1e12 + 10, mid;
if (abs(xd) + abs(yd) == n)
if (abs((r)*xd - x2) + abs((r)*yd - y2) > n * (r)) {
cout << "-1" << endl;
return 0;
}
r = 1e16;
while (l <= r) {
mid = (l + r) / 2;
long long int a = mid / n;
long long int b = mid % n;
long long int ax = a * xd, ay = a * yd;
ax += v[b].first;
ay += v[b].second;
long long int dis = abs(ax - x2) + abs(ay - y2);
if (dis <= mid) {
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << l << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, x, v[12], i, j, s = 0;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> x;
v[x]++;
}
for (i = 1; i < m; i++) {
for (j = i + 1; j <= m; j++) s = s + v[i] * v[j];
}
cout << s;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The only difference between easy and hard versions is the constraints.
Polycarp has to write a coursework. The coursework consists of m pages.
Polycarp also has n cups of coffee. The coffee in the i-th cup has a_i caffeine in it. Polycarp can drink some cups of coffee (each one no more than once). He can drink cups in any order. Polycarp drinks each cup instantly and completely (i.e. he cannot split any cup into several days).
Surely, courseworks are not usually being written in a single day (in a perfect world of Berland, at least). Some of them require multiple days of hard work.
Let's consider some day of Polycarp's work. Consider Polycarp drinks k cups of coffee during this day and caffeine dosages of cups Polycarp drink during this day are a_{i_1}, a_{i_2}, ..., a_{i_k}. Then the first cup he drinks gives him energy to write a_{i_1} pages of coursework, the second cup gives him energy to write max(0, a_{i_2} - 1) pages, the third cup gives him energy to write max(0, a_{i_3} - 2) pages, ..., the k-th cup gives him energy to write max(0, a_{i_k} - k + 1) pages.
If Polycarp doesn't drink coffee during some day, he cannot write coursework at all that day.
Polycarp has to finish his coursework as soon as possible (spend the minimum number of days to do it). Your task is to find out this number of days or say that it is impossible.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 10^4) — the number of cups of coffee and the number of pages in the coursework.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the caffeine dosage of coffee in the i-th cup.
Output
If it is impossible to write the coursework, print -1. Otherwise print the minimum number of days Polycarp needs to do it.
Examples
Input
5 8
2 3 1 1 2
Output
4
Input
7 10
1 3 4 2 1 4 2
Output
2
Input
5 15
5 5 5 5 5
Output
1
Input
5 16
5 5 5 5 5
Output
2
Input
5 26
5 5 5 5 5
Output
-1
Note
In the first example Polycarp can drink fourth cup during first day (and write 1 page), first and second cups during second day (and write 2 + (3 - 1) = 4 pages), fifth cup during the third day (and write 2 pages) and third cup during the fourth day (and write 1 page) so the answer is 4. It is obvious that there is no way to write the coursework in three or less days in this test.
In the second example Polycarp can drink third, fourth and second cups during first day (and write 4 + (2 - 1) + (3 - 2) = 6 pages) and sixth cup during second day (and write 4 pages) so the answer is 2. It is obvious that Polycarp cannot write the whole coursework in one day in this test.
In the third example Polycarp can drink all cups of coffee during first day and write 5 + (5 - 1) + (5 - 2) + (5 - 3) + (5 - 4) = 15 pages of coursework.
In the fourth example Polycarp cannot drink all cups during first day and should drink one of them during the second day. So during first day he will write 5 + (5 - 1) + (5 - 2) + (5 - 3) = 14 pages of coursework and during second day he will write 5 pages of coursework. This is enough to complete it.
In the fifth example Polycarp cannot write the whole coursework at all, even if he will drink one cup of coffee during each day, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC Optimize("O3")
using namespace std;
const int N = 2e5, OO = 0x3f3f3f3f;
int n, m, arr[N];
bool valid(int num) {
long long tot = 0;
int x;
for (int i = 0, day = 0; i < n; day++) {
x = num;
while (i < n && x--) tot += max(arr[i++] - day, 0);
}
return tot >= m;
}
int bs() {
int lo = 1, hi = n, mid, ans = -1;
while (lo <= hi) {
mid = lo + (hi - lo) / 2;
if (valid(mid)) {
hi = mid - 1;
ans = mid;
} else
lo = mid + 1;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", arr + i);
sort(arr, arr + n);
reverse(arr, arr + n);
printf("%d", bs());
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 ≤ i ≤ j ≤ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 ≤ n ≤ 105, 2 ≤ l ≤ 109, 1 ≤ x < y ≤ l) — the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v — the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 ≤ pi ≤ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MX = 100000;
const long long MOD = 1000000007;
long long fast_exp(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
exp /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, l, x, y;
cin >> n >> l >> x >> y;
vector<long long> v(n);
for (int i = 0, _i = (n); i < _i; ++i) cin >> v[i];
bool f1, f2;
f1 = f2 = false;
for (int i = 0, _i = (n); i < _i; ++i) {
if (binary_search(v.begin() + i, v.end(), v[i] + x)) f1 = true;
if (binary_search(v.begin() + i, v.end(), v[i] + y)) f2 = true;
if (f1 && f2) {
cout << 0;
return 0;
}
}
if (f1 || f2) {
cout << 1 << "\n";
cout << (f1 ? y : x);
return 0;
}
for (int i = 0, _i = (n); i < _i; ++i) {
long long p = v[i] + x;
if (p >= 0 && p <= l &&
(binary_search(v.begin(), v.end(), p - y) ||
binary_search(v.begin(), v.end(), p + y))) {
cout << 1 << "\n" << p;
return 0;
}
p = v[i] - x;
if (p >= 0 && p <= l &&
(binary_search(v.begin(), v.end(), p - y) ||
binary_search(v.begin(), v.end(), p + y))) {
cout << 1 << "\n" << p;
return 0;
}
p = v[i] + y;
if (p >= 0 && p <= l &&
(binary_search(v.begin(), v.end(), p - x) ||
binary_search(v.begin(), v.end(), p + x))) {
cout << 1 << "\n" << p;
return 0;
}
p = v[i] - y;
if (p >= 0 && p <= l &&
(binary_search(v.begin(), v.end(), p - x) ||
binary_search(v.begin(), v.end(), p + x))) {
cout << 1 << "\n" << p;
return 0;
}
}
cout << 2 << "\n";
cout << x << " " << y;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
As you might remember from the previous round, Vova is currently playing a strategic game known as Rage of Empires.
Vova managed to build a large army, but forgot about the main person in the army - the commander. So he tries to hire a commander, and he wants to choose the person who will be respected by warriors.
Each warrior is represented by his personality — an integer number pi. Each commander has two characteristics — his personality pj and leadership lj (both are integer numbers). Warrior i respects commander j only if <image> (<image> is the bitwise excluding OR of x and y).
Initially Vova's army is empty. There are three different types of events that can happen with the army:
* 1 pi — one warrior with personality pi joins Vova's army;
* 2 pi — one warrior with personality pi leaves Vova's army;
* 3 pi li — Vova tries to hire a commander with personality pi and leadership li.
For each event of the third type Vova wants to know how many warriors (counting only those who joined the army and haven't left yet) respect the commander he tries to hire.
Input
The first line contains one integer q (1 ≤ q ≤ 100000) — the number of events.
Then q lines follow. Each line describes the event:
* 1 pi (1 ≤ pi ≤ 108) — one warrior with personality pi joins Vova's army;
* 2 pi (1 ≤ pi ≤ 108) — one warrior with personality pi leaves Vova's army (it is guaranteed that there is at least one such warrior in Vova's army by this moment);
* 3 pi li (1 ≤ pi, li ≤ 108) — Vova tries to hire a commander with personality pi and leadership li. There is at least one event of this type.
Output
For each event of the third type print one integer — the number of warriors who respect the commander Vova tries to hire in the event.
Example
Input
5
1 3
1 4
3 6 3
2 4
3 6 3
Output
1
0
Note
In the example the army consists of two warriors with personalities 3 and 4 after first two events. Then Vova tries to hire a commander with personality 6 and leadership 3, and only one warrior respects him (<image>, and 2 < 3, but <image>, and 5 ≥ 3). Then warrior with personality 4 leaves, and when Vova tries to hire that commander again, there are no warriors who respect him.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
struct node {
node* ch[2] = {0, 0};
int size = 0;
};
void add(node* n, int x) {
for (int i = int(30) - 1; i >= (0); --i) {
int c = (((x) >> (i)) & 1);
if (n->ch[c] == 0) {
n->ch[c] = new node();
}
n = n->ch[c];
n->size++;
}
}
void rem(node* n, int x) {
for (int i = int(30) - 1; i >= (0); --i) {
int c = (((x) >> (i)) & 1);
n = n->ch[c];
n->size--;
}
}
int get(node* n, int y, int l) {
int res = 0;
for (int i = int(30) - 1; i >= (0); --i) {
if (!n) {
break;
}
int tz = (((y) >> (i)) & 1);
if ((((l) >> (i)) & 1)) {
res += n->ch[tz] ? n->ch[tz]->size : 0;
n = n->ch[tz ^ 1];
} else {
n = n->ch[tz];
}
}
return res;
}
void solve(istream& cin, ostream& cout) {
int n;
cin >> n;
node* root = new node();
for (int i = (0); i < int(n); ++i) {
int t;
cin >> t;
if (t == 1) {
int x;
cin >> x;
add(root, x);
} else if (t == 2) {
int x;
cin >> x;
rem(root, x);
} else {
int y, l;
cin >> y >> l;
cout << get(root, y, l) << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Vasya is currently at a car rental service, and he wants to reach cinema. The film he has bought a ticket for starts in t minutes. There is a straight road of length s from the service to the cinema. Let's introduce a coordinate system so that the car rental service is at the point 0, and the cinema is at the point s.
There are k gas stations along the road, and at each of them you can fill a car with any amount of fuel for free! Consider that this operation doesn't take any time, i.e. is carried out instantly.
There are n cars in the rental service, i-th of them is characterized with two integers ci and vi — the price of this car rent and the capacity of its fuel tank in liters. It's not allowed to fuel a car with more fuel than its tank capacity vi. All cars are completely fueled at the car rental service.
Each of the cars can be driven in one of two speed modes: normal or accelerated. In the normal mode a car covers 1 kilometer in 2 minutes, and consumes 1 liter of fuel. In the accelerated mode a car covers 1 kilometer in 1 minutes, but consumes 2 liters of fuel. The driving mode can be changed at any moment and any number of times.
Your task is to choose a car with minimum price such that Vasya can reach the cinema before the show starts, i.e. not later than in t minutes. Assume that all cars are completely fueled initially.
Input
The first line contains four positive integers n, k, s and t (1 ≤ n ≤ 2·105, 1 ≤ k ≤ 2·105, 2 ≤ s ≤ 109, 1 ≤ t ≤ 2·109) — the number of cars at the car rental service, the number of gas stations along the road, the length of the road and the time in which the film starts.
Each of the next n lines contains two positive integers ci and vi (1 ≤ ci, vi ≤ 109) — the price of the i-th car and its fuel tank capacity.
The next line contains k distinct integers g1, g2, ..., gk (1 ≤ gi ≤ s - 1) — the positions of the gas stations on the road in arbitrary order.
Output
Print the minimum rent price of an appropriate car, i.e. such car that Vasya will be able to reach the cinema before the film starts (not later than in t minutes). If there is no appropriate car, print -1.
Examples
Input
3 1 8 10
10 8
5 7
11 9
3
Output
10
Input
2 2 10 18
10 4
20 6
5 3
Output
20
Note
In the first sample, Vasya can reach the cinema in time using the first or the third cars, but it would be cheaper to choose the first one. Its price is equal to 10, and the capacity of its fuel tank is 8. Then Vasya can drive to the first gas station in the accelerated mode in 3 minutes, spending 6 liters of fuel. After that he can full the tank and cover 2 kilometers in the normal mode in 4 minutes, spending 2 liters of fuel. Finally, he drives in the accelerated mode covering the remaining 3 kilometers in 3 minutes and spending 6 liters of fuel.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, k, s, t;
int gas[MAXN];
struct Node {
int c, v;
friend bool operator<(const Node &p, const Node &q) { return p.c < q.c; }
} P[MAXN];
int pre[MAXN];
int check(int o) {
int tt = 0;
for (int i = 1; i <= k; i++) {
int x = gas[i] - gas[i - 1];
if (o < x) return 2147483647;
tt += max(x, 2 * x - (o - x));
}
return tt;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &P[i].c, &P[i].v);
for (int i = 1; i <= k; i++) scanf("%d", &gas[i]);
sort(gas + 1, gas + k + 1);
gas[++k] = s;
int l = 1, r = n;
sort(P + 1, P + n + 1);
for (int i = 1; i <= n; i++) pre[i] = max(pre[i - 1], P[i].v);
while (l < r) {
int mid = (l + r) >> 1;
int o = pre[mid];
int tt = check(o);
if (tt <= t)
r = mid;
else
l = mid + 1;
}
if (check(pre[l]) > t)
puts("-1");
else
printf("%d\n", P[l].c);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given matrix a of size n × m, its elements are integers. We will assume that the rows of the matrix are numbered from top to bottom from 1 to n, the columns are numbered from left to right from 1 to m. We will denote the element on the intersecting of the i-th row and the j-th column as aij.
We'll call submatrix i1, j1, i2, j2 (1 ≤ i1 ≤ i2 ≤ n; 1 ≤ j1 ≤ j2 ≤ m) such elements aij of the given matrix that i1 ≤ i ≤ i2 AND j1 ≤ j ≤ j2. We'll call the area of the submatrix number (i2 - i1 + 1)·(j2 - j1 + 1). We'll call a submatrix inhomogeneous, if all its elements are distinct.
Find the largest (in area) inhomogenous submatrix of the given matrix.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 400) — the number of rows and columns of the matrix, correspondingly.
Each of the next n lines contains m integers aij (1 ≤ aij ≤ 160000) — the elements of the matrix.
Output
Print a single integer — the area of the optimal inhomogenous submatrix.
Examples
Input
3 3
1 3 1
4 5 6
2 6 1
Output
6
Input
3 4
5 2 3 1
3 3 5 3
4 4 4 5
Output
4
Input
2 6
1 2 3 4 5 6
8 6 7 8 9 1
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[405][405];
short int up[405][405][405];
int f[405][405];
int ret;
bool bo[160010];
void init() {
int i, j, k, l, r;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
ret = 0;
for (l = 1; l <= m; l++) {
for (r = l + 1; r <= m; r++) {
int now = n;
for (i = n; i >= 1; i--) {
now = min(now, i);
while (now && a[now][l] != a[now][r] && !bo[a[now][l]] &&
!bo[a[now][r]]) {
bo[a[now][l]] = bo[a[now][r]] = 1;
now--;
}
up[i][l][r] = i - now;
bo[a[i][l]] = bo[a[i][r]] = 0;
}
}
int now = n;
for (i = n; i >= 1; i--) {
now = min(now, i);
while (now && !bo[a[now][l]]) {
bo[a[now][l]] = 1;
now--;
}
ret = max(i - now, ret);
bo[a[i][l]] = 0;
}
}
}
void solve() {
int i, j, k, l, r, len;
for (i = 1; i <= n; i++) {
memset(f, 0, sizeof(f));
for (l = 1; l <= m - 1; l++) {
f[l][l + 1] = up[i][l][l + 1];
ret = max(ret, (int)f[l][l + 1] * 2);
}
for (len = 3; len <= m; len++) {
for (l = 1; l <= m - len + 1; l++) {
r = l + len - 1;
f[l][r] = min(min(f[l + 1][r], f[l][r - 1]), (int)up[i][l][r]);
ret = max(ret, (int)f[l][r] * (r - l + 1));
}
}
}
printf("%d\n", ret);
}
int main() {
init();
solve();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Developing tools for creation of locations maps for turn-based fights in a new game, Petya faced the following problem.
A field map consists of hexagonal cells. Since locations sizes are going to be big, a game designer wants to have a tool for quick filling of a field part with identical enemy units. This action will look like following: a game designer will select a rectangular area on the map, and each cell whose center belongs to the selected rectangle will be filled with the enemy unit.
More formally, if a game designer selected cells having coordinates (x1, y1) and (x2, y2), where x1 ≤ x2 and y1 ≤ y2, then all cells having center coordinates (x, y) such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2 will be filled. Orthogonal coordinates system is set up so that one of cell sides is parallel to OX axis, all hexagon centers have integer coordinates and for each integer x there are cells having center with such x coordinate and for each integer y there are cells having center with such y coordinate. It is guaranteed that difference x2 - x1 is divisible by 2.
Working on the problem Petya decided that before painting selected units he wants to output number of units that will be painted on the map.
Help him implement counting of these units before painting.
<image>
Input
The only line of input contains four integers x1, y1, x2, y2 ( - 109 ≤ x1 ≤ x2 ≤ 109, - 109 ≤ y1 ≤ y2 ≤ 109) — the coordinates of the centers of two cells.
Output
Output one integer — the number of cells to be filled.
Examples
Input
1 1 5 5
Output
13
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x1, y1, x2, y2;
long long area;
cin >> x1 >> y1 >> x2 >> y2;
if ((y2 - y1) % 2 == 0) {
area = ((y2 - y1) / 2 + 1) * ((x2 - x1) / 2 + 1) +
((y2 - y1) / 2) * ((x2 - x1) / 2);
} else
area = ((y2 - y1 + 1) / 2) * (x2 - x1 + 1);
cout << area;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Inaka has a disc, the circumference of which is n units. The circumference is equally divided by n points numbered clockwise from 1 to n, such that points i and i + 1 (1 ≤ i < n) are adjacent, and so are points n and 1.
There are m straight segments on the disc, the endpoints of which are all among the aforementioned n points.
Inaka wants to know if her image is rotationally symmetrical, i.e. if there is an integer k (1 ≤ k < n), such that if all segments are rotated clockwise around the center of the circle by k units, the new image will be the same as the original one.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number of segments, respectively.
The i-th of the following m lines contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) that describe a segment connecting points a_i and b_i.
It is guaranteed that no segments coincide.
Output
Output one line — "Yes" if the image is rotationally symmetrical, and "No" otherwise (both excluding quotation marks).
You can output each letter in any case (upper or lower).
Examples
Input
12 6
1 3
3 7
5 7
7 11
9 11
11 3
Output
Yes
Input
9 6
4 5
5 6
7 8
8 9
1 2
2 3
Output
Yes
Input
10 3
1 2
3 2
7 2
Output
No
Input
10 2
1 6
2 7
Output
Yes
Note
The first two examples are illustrated below. Both images become the same as their respective original ones after a clockwise rotation of 120 degrees around the center.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 2e5 + 5;
struct HASH {
size_t operator()(const pair<int, int>& x) const {
return hash<long long>()(((long long)x.first) ^
(((long long)x.second) << 32));
}
};
pair<int, int> edge[MAXN];
unordered_set<pair<int, int>, HASH> st;
void impossible() {
cout << "No\n";
exit(0);
}
void possible() {
cout << "Yes\n";
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
edge[i] = {min(u, v), max(u, v)};
st.insert(edge[i]);
}
for (int k = 1; k < n; k++) {
if (n % k) continue;
bool flag = true;
for (int i = 1; i <= m; i++) {
int u = edge[i].first, v = edge[i].second;
if (!st.count({(u + k) % n, (v + k) % n}) &&
!st.count({(v + k) % n, (u + k) % n})) {
flag = false;
break;
}
}
if (flag) possible();
}
impossible();
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are n cities in the kingdom X, numbered from 1 through n. People travel between cities by some one-way roads. As a passenger, JATC finds it weird that from any city u, he can't start a trip in it and then return back to it using the roads of the kingdom. That is, the kingdom can be viewed as an acyclic graph.
Being annoyed by the traveling system, JATC decides to meet the king and ask him to do something. In response, the king says that he will upgrade some cities to make it easier to travel. Because of the budget, the king will only upgrade those cities that are important or semi-important. A city u is called important if for every city v ≠ u, there is either a path from u to v or a path from v to u. A city u is called semi-important if it is not important and we can destroy exactly one city v ≠ u so that u becomes important.
The king will start to act as soon as he finds out all those cities. Please help him to speed up the process.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the number of cities and the number of one-way roads.
Next m lines describe the road system of the kingdom. Each of them contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), denoting one-way road from u_i to v_i.
It is guaranteed, that the kingdoms' roads make an acyclic graph, which doesn't contain multiple edges and self-loops.
Output
Print a single integer — the number of cities that the king has to upgrade.
Examples
Input
7 7
1 2
2 3
3 4
4 7
2 5
5 4
6 4
Output
4
Input
6 7
1 2
2 3
3 4
1 5
5 3
2 6
6 4
Output
4
Note
In the first example:
<image>
* Starting at the city 1 we can reach all the other cities, except for the city 6. Also, from the city 6 we cannot reach the city 1. Therefore, if we destroy the city 6 then the city 1 will become important. So 1 is a semi-important city.
* For city 2, the set of cities that cannot reach 2 and cannot be reached by 2 is \{6\}. Therefore, destroying city 6 will make the city 2 important. So city 2 is also semi-important.
* For city 3, the set is \{5, 6\}. As you can see, destroying either city 5 or 6 will not make the city 3 important. Therefore, it is neither important nor semi-important.
* For city 4, the set is empty. So 4 is an important city.
* The set for city 5 is \{3, 6\} and the set for city 6 is \{3, 5\}. Similarly to city 3, both of them are not important nor semi-important.
* The city 7 is important since we can reach it from all other cities.
So we have two important cities (4 and 7) and two semi-important cities (1 and 2).
In the second example, the important cities are 1 and 4. The semi-important cities are 2 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gi() {
T f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int INF = 0x3f3f3f3f, N = 300003, M = N << 1;
int n, m;
int tot, head[N], ver[M], nxt[M];
queue<int> q;
int in[N];
struct Edge {
int u, v;
} a[N];
int cnt, f[N];
inline void add(int u, int v) {
ver[++tot] = v, nxt[tot] = head[u], head[u] = tot, ++in[v];
}
inline void toposort() {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i += 1)
if (!in[i]) q.push(i);
cnt = n;
while (!q.empty()) {
int u = q.front(), sz = q.size();
q.pop();
--cnt;
if (sz == 1) f[u] += cnt;
if (sz == 2) {
int v = q.front();
bool ok = true;
for (int i = head[v]; i; i = nxt[i]) {
int p = ver[i];
if (in[p] == 1) {
ok = false;
break;
}
}
if (ok)
f[u] += cnt - 1;
else
f[u] = -INF;
}
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
if (!(--in[v])) q.push(v);
}
}
}
int main() {
n = gi<int>(), m = gi<int>();
for (int i = 1; i <= m; i += 1) {
a[i].u = gi<int>(), a[i].v = gi<int>();
add(a[i].u, a[i].v);
}
toposort();
tot = 0;
memset(head, 0, sizeof head);
memset(in, 0, sizeof in);
for (int i = 1; i <= m; i += 1) add(a[i].v, a[i].u);
toposort();
int ans = 0;
for (int i = 1; i <= n; i += 1)
if (f[i] >= n - 2) ++ans;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Petya has n positive integers a1, a2, ..., an.
His friend Vasya decided to joke and replaced all digits in Petya's numbers with a letters. He used the lowercase letters of the Latin alphabet from 'a' to 'j' and replaced all digits 0 with one letter, all digits 1 with another letter and so on. For any two different digits Vasya used distinct letters from 'a' to 'j'.
Your task is to restore Petya's numbers. The restored numbers should be positive integers without leading zeros. Since there can be multiple ways to do it, determine the minimum possible sum of all Petya's numbers after the restoration. It is guaranteed that before Vasya's joke all Petya's numbers did not have leading zeros.
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the number of Petya's numbers.
Each of the following lines contains non-empty string si consisting of lowercase Latin letters from 'a' to 'j' — the Petya's numbers after Vasya's joke. The length of each string does not exceed six characters.
Output
Determine the minimum sum of all Petya's numbers after the restoration. The restored numbers should be positive integers without leading zeros. It is guaranteed that the correct restore (without leading zeros) exists for all given tests.
Examples
Input
3
ab
de
aj
Output
47
Input
5
abcdef
ghij
bdef
accbd
g
Output
136542
Input
3
aa
jj
aa
Output
44
Note
In the first example, you need to replace the letter 'a' with the digit 1, the letter 'b' with the digit 0, the letter 'd' with the digit 2, the letter 'e' with the digit 3, and the letter 'j' with the digit 4. So after the restoration numbers will look like [10, 23, 14]. The sum of them is equal to 47, which is the minimum possible sum of the numbers after the correct restoration.
In the second example the numbers after the restoration can look like: [120468, 3579, 2468, 10024, 3].
In the second example the numbers after the restoration can look like: [11, 22, 11].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 62) - 1;
const long long MOD = 1e9 + 7;
const int MAX = 1e9;
const long long int N = 102;
using namespace std;
int bPow(int a, int b) {
int res = 1;
while (b) {
if (b & 1ll) {
res = 1ll * res * a % MOD;
}
b >>= 1;
a = 1ll * a * a % MOD;
}
return res;
}
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> mpf(N, 0);
void sieve() {
for (int i = 2; i < N; ++i) {
if (!mpf[i])
for (int j = 2 * i; j < N; j += i) {
mpf[j] = i;
}
}
}
void solve() {
int n;
cin >> n;
map<char, int> values;
set<char> startChars;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
startChars.insert(s[0]);
reverse(s.begin(), s.end());
int it = 1;
for (auto j : s) {
values[j] += it;
it *= 10;
}
}
vector<pair<int, char>> a;
for (auto val : values) {
a.emplace_back(val.second, val.first);
}
sort(a.rbegin(), a.rend());
bool start = false;
int it = 1, ans = 0;
for (auto i : a) {
if (startChars.find(i.second) == startChars.end() and !start) {
start = true;
} else {
ans += it * i.first;
it++;
}
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int a[n + 1];
int i;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 0;
int dist = INT_MAX;
for (i = k + 1; i <= n; i++) {
int mid = (a[i] + a[i - k]) / 2;
int temp = max(a[i] - mid, mid - a[i - k]);
if (temp < dist) {
ans = mid;
dist = temp;
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int , int> P2;
typedef pair<pair<int , int> , int> P3;
typedef pair<pair<int , int> , pair<int , int> > P4;
#define PB(a) push_back(a)
#define MP(a , b) make_pair((a) , (b))
#define M3P(a , b , c) make_pair(make_pair((a) , (b)) , (c))
#define M4P(a , b , c , d) make_pair(make_pair((a) , (b)) , make_pair((c) , (d)))
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
const int MC = 1e5 + 3;
const LL mod = 998244353;
map<pair<int,int>,int> S;
int p1[MC],p2[MC],p0[MC];
int main(){
LL N,M; cin >> N >> M;
fill(p0,p0+MC,-1);
fill(p1,p1+MC,-1);
fill(p2,p2+MC,-1);
LL z = N*(N+1)/2;
repp(i,0,M){
LL a,b,c; cin >> a >> b >> c;
if(a == b) p0[a] = c;
if(a > b) swap(a,b);
auto it = S.find(MP(a,b));
if(it != S.end()){
if(b-a >= 3){
if((*it).second != c) return cout << 0 << endl, 0;
} else if(b-a == 2){
p2[a] = ((*it).second != c);
} else if(b-a == 1){
p1[a] = ((*it).second != c);
}
} else {
S[MP(a,b)] = c;
--z;
}
}
repp(i,1,N+1){
if(p2[i] == 0){
if(p0[i+1] == 1) return cout << 0 << endl, 0;
if(p0[i+1] == -1) --z;
p0[i+1] = 0;
} else if(p2[i] == 1){
if(p0[i+1] == 0) return cout << 0 << endl, 0;
if(p0[i+1] == -1) --z;
p0[i+1] = 1;
}
if(p1[i] == 0){
if(p0[i] != -1 && p0[i+1] != -1 && p0[i] != p0[i+1]) return cout << 0 << endl, 0;
if(p0[i] == -1 || p0[i+1] == -1) --z;
if(p0[i] != -1) p0[i+1] = p0[i];
else p0[i] = p0[i+1];
} else if(p1[i] == 1){
if(p0[i] != -1 && p0[i+1] != -1 && p0[i] == p0[i+1]) return cout << 0 << endl, 0;
if(p0[i] == -1 || p0[i+1] == -1) --z;
if(p0[i] != -1) p0[i+1] = 1-p0[i];
else if(p0[i+1] != -1) p0[i] = 1-p0[i+1];
}
}
LL ans = 1;
for(LL k = 2 ; z > 0 ; k = k*k%mod){
if(z&1) (ans *= k) %= mod;
z /= 2;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Bike is interested in permutations. A permutation of length n is an integer sequence such that each integer from 0 to (n - 1) appears exactly once in it. For example, [0, 2, 1] is a permutation of length 3 while both [0, 2, 2] and [1, 2, 3] is not.
A permutation triple of permutations of length n (a, b, c) is called a Lucky Permutation Triple if and only if <image>. The sign ai denotes the i-th element of permutation a. The modular equality described above denotes that the remainders after dividing ai + bi by n and dividing ci by n are equal.
Now, he has an integer n and wants to find a Lucky Permutation Triple. Could you please help him?
Input
The first line contains a single integer n (1 ≤ n ≤ 105).
Output
If no Lucky Permutation Triple of length n exists print -1.
Otherwise, you need to print three lines. Each line contains n space-seperated integers. The first line must contain permutation a, the second line — permutation b, the third — permutation c.
If there are multiple solutions, print any of them.
Examples
Input
5
Output
1 4 3 2 0
1 0 2 4 3
2 4 0 1 3
Input
2
Output
-1
Note
In Sample 1, the permutation triple ([1, 4, 3, 2, 0], [1, 0, 2, 4, 3], [2, 4, 0, 1, 3]) is Lucky Permutation Triple, as following holds:
* <image>;
* <image>;
* <image>;
* <image>;
* <image>.
In Sample 2, you can easily notice that no lucky permutation triple exists.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
puts("-1");
return 0;
}
vector<int> v, vv;
for (int i = 0; i < n; i++) {
v.push_back(i);
printf("%d ", i);
}
puts("");
for (int i = 1; i < n; i++) {
printf("%d ", i);
vv.push_back(i);
}
vv.push_back(0);
puts("0");
for (int i = 0; i < n; i++) printf("%d ", (v[i] + vv[i]) % n);
puts("");
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Vanya has a table consisting of 100 rows, each row contains 100 cells. The rows are numbered by integers from 1 to 100 from bottom to top, the columns are numbered from 1 to 100 from left to right.
In this table, Vanya chose n rectangles with sides that go along borders of squares (some rectangles probably occur multiple times). After that for each cell of the table he counted the number of rectangles it belongs to and wrote this number into it. Now he wants to find the sum of values in all cells of the table and as the table is too large, he asks you to help him find the result.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of rectangles.
Each of the following n lines contains four integers x1, y1, x2, y2 (1 ≤ x1 ≤ x2 ≤ 100, 1 ≤ y1 ≤ y2 ≤ 100), where x1 and y1 are the number of the column and row of the lower left cell and x2 and y2 are the number of the column and row of the upper right cell of a rectangle.
Output
In a single line print the sum of all values in the cells of the table.
Examples
Input
2
1 1 2 3
2 2 3 3
Output
10
Input
2
1 1 3 3
1 1 3 3
Output
18
Note
Note to the first sample test:
Values of the table in the first three rows and columns will be as follows:
121
121
110
So, the sum of values will be equal to 10.
Note to the second sample test:
Values of the table in the first three rows and columns will be as follows:
222
222
222
So, the sum of values will be equal to 18.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
vector<long long int> b;
int m[1000][1000];
int main() {
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
m[i][j] = 0;
}
}
int n, x, y, x2, y2, c = 0;
cin >> n;
while (n--) {
cin >> x >> y >> x2 >> y2;
x--;
y--;
for (int i = x; i < x2; i++) {
for (int j = y; j < y2; j++) {
m[i][j]++;
c++;
}
}
}
cout << c << endl;
return 0;
}
``` |
### Prompt
Please formulate 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 = (int)2e5 + 50;
int n, k;
int a[N], dp[N], vis[N];
vector<int> G[N];
int getval(int comp, int im0) {
if (im0 != -1)
return 1 + comp + im0;
else
return -(1 + comp);
}
void dfs(int v, int mn) {
int comp = 0, imcomp = -1;
vis[v] = 1;
for (int nxt : G[v]) {
if (vis[nxt]) continue;
if (a[nxt] >= mn) dfs(nxt, mn);
if (dp[nxt] < 0)
comp += -dp[nxt];
else
imcomp = max(imcomp, dp[nxt]);
}
dp[v] = getval(comp, imcomp);
}
void reroot(int v, int p, int mn, int up_val, int& res) {
int comp = 0, im[2] = {-1, -1};
vector<int> vs;
if (p != -1) vs.push_back(up_val);
for (int nxt : G[v])
if (nxt != p) vs.push_back(dp[nxt]);
for (int val : vs) {
if (val < 0)
comp += -val;
else
for (int j = 0; j < (2); ++j)
if (val > im[j]) swap(val, im[j]);
}
res = max(res, 1 + comp + max(0, im[0]));
for (int nxt : G[v]) {
if (nxt == p || a[nxt] < mn) continue;
if (dp[nxt] < 0)
reroot(nxt, v, mn, getval(comp + dp[nxt], im[0]), res);
else {
reroot(nxt, v, mn, getval(comp, (dp[nxt] == im[0] ? im[1] : im[0])), res);
}
}
}
int solve(int mn) {
fill(vis, vis + n, 0);
fill(dp, dp + n, 0);
int res = 0;
for (int i = 0; i < (n); ++i) {
if (vis[i] || a[i] < mn) continue;
dfs(i, mn);
reroot(i, -1, mn, -1, res);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < (n); ++i) cin >> a[i];
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
int l = 0, r = (int)1e6 + 1, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (solve(mid) >= k)
l = mid;
else
r = mid;
}
cout << l << '\n';
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
### 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;
}
int main() {
string s;
cin >> s;
long long cntb = 0;
long long ans = 0;
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'b') {
cntb++;
cntb %= (long long)(1000 * 1000 * 1000 + 7);
} else {
ans += cntb;
ans %= (long long)(1000 * 1000 * 1000 + 7);
cntb *= 2;
cntb %= (long long)(1000 * 1000 * 1000 + 7);
}
}
ans %= (long long)(1000 * 1000 * 1000 + 7);
cout << ans;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 ≤ n ≤ 2000) — the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int pushes = 0;
int buttons;
cin >> buttons;
for (int i = 1; i <= buttons; i++) {
pushes += 1 + (i * (buttons - i));
}
cout << pushes << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Welcome! Everything is fine.
You have arrived in The Medium Place, the place between The Good Place and The Bad Place. You are assigned a task that will either make people happier or torture them for eternity.
You have a list of k pairs of people who have arrived in a new inhabited neighborhood. You need to assign each of the 2k people into one of the 2k houses. Each person will be the resident of exactly one house, and each house will have exactly one resident.
Of course, in the neighborhood, it is possible to visit friends. There are 2k - 1 roads, each of which connects two houses. It takes some time to traverse a road. We will specify the amount of time it takes in the input. The neighborhood is designed in such a way that from anyone's house, there is exactly one sequence of distinct roads you can take to any other house. In other words, the graph with the houses as vertices and the roads as edges is a tree.
The truth is, these k pairs of people are actually soulmates. We index them from 1 to k. We denote by f(i) the amount of time it takes for the i-th pair of soulmates to go to each other's houses.
As we have said before, you will need to assign each of the 2k people into one of the 2k houses. You have two missions, one from the entities in The Good Place and one from the entities of The Bad Place. Here they are:
* The first mission, from The Good Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is minimized. Let's define this minimized sum as G. This makes sure that soulmates can easily and efficiently visit each other;
* The second mission, from The Bad Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is maximized. Let's define this maximized sum as B. This makes sure that soulmates will have a difficult time to visit each other.
What are the values of G and B?
Input
The first line of input contains a single integer t (1 ≤ t ≤ 500) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer k denoting the number of pairs of people (1 ≤ k ≤ 10^5). The next 2k - 1 lines describe the roads; the i-th of them contains three space-separated integers a_i, b_i, t_i which means that the i-th road connects the a_i-th and b_i-th houses with a road that takes t_i units of time to traverse (1 ≤ a_i, b_i ≤ 2k, a_i ≠ b_i, 1 ≤ t_i ≤ 10^6). It is guaranteed that the given roads define a tree structure.
It is guaranteed that the sum of the k in a single file is at most 3 ⋅ 10^5.
Output
For each test case, output a single line containing two space-separated integers G and B.
Example
Input
2
3
1 2 3
3 2 4
2 4 3
4 5 6
5 6 5
2
1 2 1
1 3 2
1 4 3
Output
15 33
6 6
Note
For the sample test case, we have a minimum sum equal to G = 15. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 5 and 6, giving us f(1) = 5;
* The second pair of people get assigned to houses 1 and 4, giving us f(2) = 6;
* The third pair of people get assigned to houses 3 and 2, giving us f(3) = 4.
Note that the sum of the f(i) is 5 + 6 + 4 = 15.
We also have a maximum sum equal to B = 33. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 1 and 4, giving us f(1) = 6;
* The second pair of people get assigned to houses 6 and 2, giving us f(2) = 14;
* The third pair of people get assigned to houses 3 and 5, giving us f(3) = 13.
Note that the sum of the f(i) is 6 + 14 + 13 = 33.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 500;
const int INF = 1e9;
int fst[N], nxt[N], mm;
struct Edge {
int v, w;
} e[N];
void ade(int u, int v, int w) {
e[++mm] = (Edge){v, w}, nxt[mm] = fst[u], fst[u] = mm;
}
long long f[N], sum, dep[N];
int n, root, rsize;
int siz[N];
void dfs(int u, int fa) {
siz[u] = 1;
f[u] = 0;
int mx = 0;
for (int i = fst[u]; i; i = nxt[i]) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
siz[u] += siz[v];
mx = max(mx, siz[v]);
f[u] += f[v];
if (siz[v] & 1) f[u] += e[i].w;
}
mx = max(mx, n - siz[u]);
if (mx < rsize) rsize = mx, root = u;
}
void dfs2(int u, int fa) {
sum += dep[u];
for (int i = fst[u]; i; i = nxt[i]) {
int v = e[i].v;
if (v == fa) continue;
dep[v] = dep[u] + e[i].w;
dfs2(v, u);
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
n *= 2;
for (int i = 1; i <= n; i++) fst[i] = 0;
mm = 0;
for (int i = 1, u, v, w; i < n; i++)
scanf("%d%d%d", &u, &v, &w), ade(u, v, w), ade(v, u, w);
root = 0, rsize = INF;
dfs(1, 0);
dep[root] = 0;
sum = 0;
dfs2(root, 0);
printf("%lld ", f[1]);
printf("%lld\n", sum);
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are n segments [l_i, r_i] for 1 ≤ i ≤ n. You should divide all segments into two non-empty groups in such way that there is no pair of segments from different groups which have at least one common point, or say that it's impossible to do it. Each segment should belong to exactly one group.
To optimize testing process you will be given multitest.
Input
The first line contains one integer T (1 ≤ T ≤ 50000) — the number of queries. Each query contains description of the set of segments. Queries are independent.
First line of each query contains single integer n (2 ≤ n ≤ 10^5) — number of segments. It is guaranteed that ∑{n} over all queries does not exceed 10^5.
The next n lines contains two integers l_i, r_i per line (1 ≤ l_i ≤ r_i ≤ 2 ⋅ 10^5) — the i-th segment.
Output
For each query print n integers t_1, t_2, ..., t_n (t_i ∈ \{1, 2\}) — for each segment (in the same order as in the input) t_i equals 1 if the i-th segment will belongs to the first group and 2 otherwise.
If there are multiple answers, you can print any of them. If there is no answer, print -1.
Example
Input
3
2
5 5
2 3
3
3 5
2 3
2 3
3
3 3
4 4
5 5
Output
2 1
-1
1 1 2
Note
In the first query the first and the second segments should be in different groups, but exact numbers don't matter.
In the second query the third segment intersects with the first and the second segments, so they should be in the same group, but then the other group becomes empty, so answer is -1.
In the third query we can distribute segments in any way that makes groups non-empty, so any answer of 6 possible is correct.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 2, oo = 1e9, M = 1e6;
long long const OO = 1e18;
double const eps = 1e-6, PI = acos(-1);
int mod = oo + 7;
int n, an[N];
pair<pair<int, int>, int> seg[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> seg[i].first.first >> seg[i].first.second;
seg[i].second = i;
an[i] = 0;
}
sort(seg, seg + n);
int r = seg[0].first.second;
int i = 1;
for (; i < n; i++)
if (seg[i].first.first > r)
break;
else
r = max(r, seg[i].first.second);
if (i == n) {
cout << -1 << '\n';
continue;
}
for (int j = 0; j < i; j++) an[seg[j].second] = 1;
for (int j = i; j < n; j++) an[seg[j].second] = 2;
bool y = 0;
for (int i = 0; i < n - 1; i++)
if (an[i] != an[i + 1]) y = 1;
if (y)
for (int i = 0; i < n; i++) cout << an[i] << ' ';
else
cout << -1;
cout << '\n';
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
The goal of the 15 puzzle problem is to complete pieces on $4 \times 4$ cells where one of the cells is empty space.
In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 15 as shown below.
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.
Constraints
* The given puzzle is solvable in at most 45 steps.
Input
The $4 \times 4$ integers denoting the pieces or space are given.
Output
Print the fewest steps in a line.
Example
Input
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
Output
8
### Response
```cpp
#include<stdio.h>
#include<iostream>
#include<cmath>
#include<string>
#include<cassert>
using namespace std;
#define N 4
#define N2 16
#define LIMIT 100
static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = { 'r', 'u', 'l', 'd'};
int MDT[N2][N2];
struct Puzzle{int f[N2], space, MD;};
Puzzle state;
int limit;
int path[LIMIT];
int getAllMD(Puzzle pz){
int sum = 0;
for(int i = 0 ; i < N2 ; i++){
if(pz.f[i] == N2) continue;
sum += MDT[i][pz.f[i] - 1];
}
return sum;
}
bool isSolved(){
for(int i = 0 ; i < N2 ; i++) if(state.f[i] != i + 1) return false;
return true;
}
bool dfs(int depth, int prev){
if(state.MD == 0) return true;
if(depth + state.MD > limit) return false;
int sx = state.space / N;
int sy = state.space % N;
Puzzle tmp;
for(int r = 0 ; r < 4 ; r++){
int tx = sx + dx[r];
int ty = sy + dy[r];
if(tx < 0 || ty < 0 || tx >= N || ty >= N) continue;
if(max(prev, r)-min(prev, r) == 2) continue;
tmp = state;
state.MD -= MDT[tx * N + ty][state.f[tx * N + ty] - 1];
state.MD += MDT[sx * N + sy][state.f[tx * N + ty] - 1];
swap(state.f[tx * N + ty], state.f[sx * N + sy]);
state.space = tx * N + ty;
if(dfs(depth + 1, r)) {path[depth] = r; return true;}
state = tmp;
}
return false;
}
string iterative_deepening(Puzzle in){
in.MD = getAllMD(in);
for(limit = in.MD ; limit <= LIMIT ; limit++){
state = in;
if(dfs(0, -100)){
string ans = "";
for(int i = 0 ; i < limit ; i++) ans += dir[path[i]];
return ans;
}
}
return "ubsolvable";
}
int main(){
for(int i = 0 ; i < N2 ; i++)
for(int j = 0 ; j < N2 ; j++)
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
Puzzle in;
for(int i = 0 ; i < N2 ; i++){
cin >> in.f[i];
if(in.f[i] == 0){
in.f[i] = N2;
in.space = i;
}
}
string ans = iterative_deepening(in);
cout << ans.size() << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
This year Alex has finished school, and now he is a first-year student of Berland State University. For him it was a total surprise that even though he studies programming, he still has to attend physical education lessons. The end of the term is very soon, but, unfortunately, Alex still hasn't attended a single lesson!
Since Alex doesn't want to get expelled, he wants to know the number of working days left until the end of the term, so he can attend physical education lessons during these days. But in BSU calculating the number of working days is a complicated matter:
There are n days left before the end of the term (numbered from 1 to n), and initially all of them are working days. Then the university staff sequentially publishes q orders, one after another. Each order is characterised by three numbers l, r and k:
* If k = 1, then all days from l to r (inclusive) become non-working days. If some of these days are made working days by some previous order, then these days still become non-working days;
* If k = 2, then all days from l to r (inclusive) become working days. If some of these days are made non-working days by some previous order, then these days still become working days.
Help Alex to determine the number of working days left after each order!
Input
The first line contains one integer n, and the second line — one integer q (1 ≤ n ≤ 109, 1 ≤ q ≤ 3·105) — the number of days left before the end of the term, and the number of orders, respectively.
Then q lines follow, i-th line containing three integers li, ri and ki representing i-th order (1 ≤ li ≤ ri ≤ n, 1 ≤ ki ≤ 2).
Output
Print q integers. i-th of them must be equal to the number of working days left until the end of the term after the first i orders are published.
Example
Input
4
6
1 2 1
3 4 1
2 3 2
1 3 2
2 4 1
1 4 2
Output
2
0
2
3
1
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& fout, const vector<T>& vec) {
for (const auto& el : vec) {
fout << el << ' ';
}
return fout;
}
template <class T>
istream& operator>>(istream& fin, vector<T>& vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cin >> vec[i];
}
return fin;
}
vector<int> res;
vector<int> an;
vector<int> bn;
bool dfs(int k = 0, int skip_check = 0, int mask = 0) { return 0; }
set<pair<int, int>> removed;
int n, q;
int lft;
void add(int l, int r, int k) {
vector<pair<int, int>> to_remove;
vector<pair<int, int>> to_add;
if (k == 1) to_add.push_back({r, l});
auto pos = removed.upper_bound({r, l});
while (true) {
if (pos == removed.end()) {
if (pos == removed.begin()) break;
std::advance(pos, -1);
continue;
}
if (pos->second >= r) {
if (pos == removed.begin()) break;
std::advance(pos, -1);
continue;
}
if (pos->first <= l) break;
to_remove.push_back(*pos);
if (pos->second < l) {
to_add.push_back({l, pos->second});
}
if (pos->first > r) {
to_add.push_back({pos->first, r});
}
if (pos == removed.begin()) break;
std::advance(pos, -1);
}
for (auto el : to_remove) {
lft += el.first - el.second;
removed.erase(el);
}
for (auto el : to_add) {
lft -= el.first - el.second;
removed.insert(el);
}
}
int Solve() {
cin >> n >> q;
lft = n;
while (q--) {
int l, r, k;
cin >> l >> r >> k;
switch (k) {
case 1:
add(l, r + 1, k);
break;
case 2:
add(l, r + 1, k);
break;
}
std::cout << lft << '\n';
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Codeforces is a wonderful platform and one its feature shows how much someone contributes to the community. Every registered user has contribution — an integer number, not necessarily positive. There are n registered users and the i-th of them has contribution ti.
Limak is a little polar bear and he's new into competitive programming. He doesn't even have an account in Codeforces but he is able to upvote existing blogs and comments. We assume that every registered user has infinitely many blogs and comments.
* Limak can spend b minutes to read one blog and upvote it. Author's contribution will be increased by 5.
* Limak can spend c minutes to read one comment and upvote it. Author's contribution will be increased by 1.
Note that it's possible that Limak reads blogs faster than comments.
Limak likes ties. He thinks it would be awesome to see a tie between at least k registered users. To make it happen he is going to spend some time on reading and upvoting. After that, there should exist an integer value x that at least k registered users have contribution exactly x.
How much time does Limak need to achieve his goal?
Input
The first line contains four integers n, k, b and c (2 ≤ k ≤ n ≤ 200 000, 1 ≤ b, c ≤ 1000) — the number of registered users, the required minimum number of users with the same contribution, time needed to read and upvote a blog, and time needed to read and upvote a comment, respectively.
The second line contains n integers t1, t2, ..., tn (|ti| ≤ 109) where ti denotes contribution of the i-th registered user.
Output
Print the minimum number of minutes Limak will spend to get a tie between at least k registered users.
Examples
Input
4 3 100 30
12 2 6 1
Output
220
Input
4 3 30 100
12 2 6 1
Output
190
Input
6 2 987 789
-8 42 -4 -65 -8 -8
Output
0
Note
In the first sample, there are 4 registered users and Limak wants a tie between at least 3 of them. Limak should behave as follows.
* He spends 100 minutes to read one blog of the 4-th user and increase his contribution from 1 to 6.
* Then he spends 4·30 = 120 minutes to read four comments of the 2-nd user and increase his contribution from 2 to 6 (four times it was increaded by 1).
In the given scenario, Limak spends 100 + 4·30 = 220 minutes and after that each of users 2, 3, 4 has contribution 6.
In the second sample, Limak needs 30 minutes to read a blog and 100 minutes to read a comment. This time he can get 3 users with contribution equal to 12 by spending 100 + 3·30 = 190 minutes:
* Spend 2·30 = 60 minutes to read two blogs of the 1-st user to increase his contribution from 2 to 12.
* Spend 30 + 100 minutes to read one blog and one comment of the 3-rd user. His contribution will change from 6 to 6 + 5 + 1 = 12.
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 2e5;
const int SHIFT = 1e9;
using namespace std;
int arr[MAXN];
vector<int> conds[5];
vector<int> lvls[5];
int ptrs[5][2];
long long b, c;
long long countCost(int lvl, int elem) {
return ((lvl - elem) / 5) * b + ((lvl - elem) % 5) * c;
}
int main() {
int n, k;
cin >> n >> k >> b >> c;
b = min(b, 5 * c);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
arr[i] += SHIFT;
}
sort(arr, arr + n);
for (int i = 0; i < n; ++i) {
conds[arr[i] % 5].push_back(arr[i]);
for (int j = 0; j < 5; ++j) lvls[(arr[i] + j) % 5].push_back(arr[i] + j);
}
long long ans = 2e18;
for (int t = 0; t < 5; ++t) {
fill(ptrs[0], ptrs[0] + 10, 0);
int cnt = 0;
long long cost = 0;
int prev = 0;
for (int lvl : lvls[t]) {
cost += cnt * countCost(lvl, prev);
prev = lvl;
for (int r = 0; r < 5; ++r)
while (ptrs[r][1] < (int)conds[r].size() &&
conds[r][ptrs[r][1]] <= lvl) {
cost += countCost(lvl, conds[r][ptrs[r][1]]);
ptrs[r][1]++;
cnt++;
}
while (cnt > k) {
long long worst = -1;
for (int r = 0; r < 5; ++r)
if (ptrs[r][0] < ptrs[r][1])
worst = max(worst, countCost(lvl, conds[r][ptrs[r][0]]));
for (int r = 0; r < 5; ++r)
if (ptrs[r][0] < ptrs[r][1] &&
worst == countCost(lvl, conds[r][ptrs[r][0]])) {
cost -= worst;
ptrs[r][0]++;
cnt--;
break;
}
}
if (cnt == k) ans = min(ans, cost);
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve 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 <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
if (n & 1)
return puts("No"), 0;
std::string str;
std::cin >> str;
puts(str.substr(0, n/2) == str.substr(n/2, n/2) ? "Yes" : "No");
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
M-kun is a competitor in AtCoder, whose highest rating is X.
In this site, a competitor is given a kyu (class) according to his/her highest rating. For ratings from 400 through 1999, the following kyus are given:
* From 400 through 599: 8-kyu
* From 600 through 799: 7-kyu
* From 800 through 999: 6-kyu
* From 1000 through 1199: 5-kyu
* From 1200 through 1399: 4-kyu
* From 1400 through 1599: 3-kyu
* From 1600 through 1799: 2-kyu
* From 1800 through 1999: 1-kyu
What kyu does M-kun have?
Constraints
* 400 \leq X \leq 1999
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the kyu M-kun has, as an integer. For example, if he has 8-kyu, print `8`.
Examples
Input
725
Output
7
Input
1600
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int x;
int main(){
cin >> x;
cout << 8 - (x - 400) / 200;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Andrew plays a game called "Civilization". Dima helps him.
The game has n cities and m bidirectional roads. The cities are numbered from 1 to n. Between any pair of cities there either is a single (unique) path, or there is no path at all. A path is such a sequence of distinct cities v1, v2, ..., vk, that there is a road between any contiguous cities vi and vi + 1 (1 ≤ i < k). The length of the described path equals to (k - 1). We assume that two cities lie in the same region if and only if, there is a path connecting these two cities.
During the game events of two types take place:
1. Andrew asks Dima about the length of the longest path in the region where city x lies.
2. Andrew asks Dima to merge the region where city x lies with the region where city y lies. If the cities lie in the same region, then no merging is needed. Otherwise, you need to merge the regions as follows: choose a city from the first region, a city from the second region and connect them by a road so as to minimize the length of the longest path in the resulting region. If there are multiple ways to do so, you are allowed to choose any of them.
Dima finds it hard to execute Andrew's queries, so he asks you to help him. Help Dima.
Input
The first line contains three integers n, m, q (1 ≤ n ≤ 3·105; 0 ≤ m < n; 1 ≤ q ≤ 3·105) — the number of cities, the number of the roads we already have and the number of queries, correspondingly.
Each of the following m lines contains two integers, ai and bi (ai ≠ bi; 1 ≤ ai, bi ≤ n). These numbers represent the road between cities ai and bi. There can be at most one road between two cities.
Each of the following q lines contains one of the two events in the following format:
* 1 xi. It is the request Andrew gives to Dima to find the length of the maximum path in the region that contains city xi (1 ≤ xi ≤ n).
* 2 xi yi. It is the request Andrew gives to Dima to merge the region that contains city xi and the region that contains city yi (1 ≤ xi, yi ≤ n). Note, that xi can be equal to yi.
Output
For each event of the first type print the answer on a separate line.
Examples
Input
6 0 6
2 1 2
2 3 4
2 5 6
2 3 2
2 5 3
1 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int par[300001], res[300001];
int fnd(int x) {
if (par[x] == x) return x;
return par[x] = fnd(par[x]);
}
void uni(int x, int y) {
int a = fnd(x);
int b = fnd(y);
if (a == b) return;
int c = res[a];
c = (c + 1) / 2;
int d = res[b];
d = (d + 1) / 2;
int e = max(res[a], res[b]);
res[a] = c + d + 1;
res[a] = max(res[a], e);
par[b] = a;
}
int vis[300001];
vector<int> vc[300001];
int dfs(int c, int p) {
vis[c] = 1;
if (p == 0)
par[c] = c;
else
par[c] = p;
int ret = 0;
int m2 = 0;
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] != p) {
int t = dfs(vc[c][i], c) + 1;
if (t > ret) {
m2 = ret;
ret = t;
} else if (t > m2)
m2 = t;
else if (t == ret)
m2 = t;
res[c] = max(res[c], res[vc[c][i]]);
}
}
res[c] = max(res[c], ret + m2);
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, c, d = 0, e, f = 0, g = 0, h = 0, x, y, z;
cin >> a >> b >> c;
for (int i = (0); i < (b); ++i) {
cin >> d >> e;
vc[d].push_back(e);
vc[e].push_back(d);
}
for (int i = 1; i <= a; i++) {
if (vis[i] == 0) {
dfs(i, 0);
}
}
for (int i = (0); i < (c); ++i) {
cin >> d >> e;
if (d == 1) {
f = fnd(e);
cout << res[f] << endl;
} else {
cin >> f;
uni(e, f);
}
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Valera is a coder. Recently he wrote a funny program. The pseudo code for this program is given below:
//input: integers x, k, p
a = x;
for(step = 1; step <= k; step = step + 1){
rnd = [random integer from 1 to 100];
if(rnd <= p)
a = a * 2;
else
a = a + 1;
}
s = 0;
while(remainder after dividing a by 2 equals 0){
a = a / 2;
s = s + 1;
}
Now Valera wonders: given the values x, k and p, what is the expected value of the resulting number s?
Input
The first line of the input contains three integers x, k, p (1 ≤ x ≤ 109; 1 ≤ k ≤ 200; 0 ≤ p ≤ 100).
Output
Print the required expected value. Your answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
1 1 50
Output
1.0000000000000
Input
5 3 0
Output
3.0000000000000
Input
5 3 25
Output
1.9218750000000
Note
If the concept of expected value is new to you, you can read about it by the link:
http://en.wikipedia.org/wiki/Expected_value
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(0)
using namespace std;
inline int read(void) {
int n = 0;
bool b = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') b = 0;
c = getchar();
}
while (c >= '0' && c <= '9') n = (n << 3) + (n << 1) + c - 48, c = getchar();
return b ? n : -n;
}
int x, k, ans;
double p, f[210][210];
int main() {
x = read();
k = read();
p = read();
p /= 100.0;
for (int i = 0; i <= k; ++i) {
for (int j = x + i; !(j & 1); j >>= 1) {
++f[0][i];
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j <= k; ++j) {
if (j) f[i + 1][j - 1] += (1 - p) * f[i][j];
if ((j << 1) <= k) f[i + 1][j << 1] += p * (f[i][j] + 1);
}
}
printf("%.15lf", f[k][0]);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Lena is a programmer. She got a task to solve at work.
There is an empty set of pairs of integers and n queries to process. Each query is one of three types:
1. Add a pair (a, b) to the set.
2. Remove a pair added in the query number i. All queries are numbered with integers from 1 to n.
3. For a given integer q find the maximal value x·q + y over all pairs (x, y) from the set.
Help Lena to process the queries.
Input
The first line of input contains integer n (1 ≤ n ≤ 3·105) — the number of queries.
Each of the next n lines starts with integer t (1 ≤ t ≤ 3) — the type of the query.
A pair of integers a and b ( - 109 ≤ a, b ≤ 109) follows in the query of the first type.
An integer i (1 ≤ i ≤ n) follows in the query of the second type. It is guaranteed that i is less than the number of the query, the query number i has the first type and the pair from the i-th query is not already removed.
An integer q ( - 109 ≤ q ≤ 109) follows in the query of the third type.
Output
For the queries of the third type print on a separate line the desired maximal value of x·q + y.
If there are no pairs in the set print "EMPTY SET".
Example
Input
7
3 1
1 2 3
3 1
1 -1 100
3 1
2 4
3 1
Output
EMPTY SET
5
99
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 bruh(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rofl(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e6 + 2;
const int M = 1e5;
const int mod = 0;
const int inf = 1e9;
const long long INF = 3e18 + 1;
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
void files() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
struct node {
node *l, *r;
pair<long long, long long> val;
node(pair<long long, long long> val = {0, -INF}) : val(val) {
l = nullptr;
r = nullptr;
}
} *r = new node();
struct li_chao {
stack<pair<node *, pair<long long, long long>>> s;
void save() { s.push({nullptr, {-INF, -INF}}); }
void rollback() {
while (s.top().first != nullptr) {
s.top().first->val = s.top().second;
s.pop();
}
s.pop();
}
node *upd(pair<long long, long long> val, node *v = r, long long tl = -inf,
long long tr = inf) {
if (v == nullptr) v = new node();
if (tl == tr) return v;
long long tm = tl + tr >> 1;
if (v->val.first * tm + v->val.second <= val.first * tm + val.second) {
s.push({v, v->val});
swap(val, v->val);
}
if (v->val.first * tl + v->val.second <= val.first * tl + val.second)
v->l = upd(val, v->l, tl, tm);
else
v->r = upd(val, v->r, tm + 1, tr);
return v;
}
long long get(long long x, node *v = r, long long tl = -inf,
long long tr = inf) {
if (v == nullptr) return -INF;
long long tm = tl + tr >> 1;
if (tl == tr) return v->val.first * x + v->val.second;
if (x <= tm)
return max(v->val.first * x + v->val.second, get(x, v->l, tl, tm));
else
return max(v->val.first * x + v->val.second, get(x, v->r, tm + 1, tr));
}
} LI;
int n, del[N];
pair<long long, long long> was[N];
long long ans[N];
struct tree {
vector<pair<long long, long long>> t[N];
pair<long long, long long> q[N];
set<pair<long long, long long>> vals;
void upd(int l, int r, pair<long long, long long> val, int v = 1, int tl = 1,
int tr = n) {
if (l <= tl && tr <= r) {
t[v].push_back(val);
return;
}
if (r < tl || tr < l) return;
int tm = tl + tr >> 1;
upd(l, r, val, v * 2, tl, tm);
upd(l, r, val, v * 2 + 1, tm + 1, tr);
}
void dfs(int v = 1, int tl = 1, int tr = n) {
LI.save();
for (auto it : t[v]) {
r = LI.upd(it);
}
if (tl == tr) {
ans[tl] = LI.get(q[tl].first);
LI.rollback();
return;
}
int tm = tl + tr >> 1;
dfs(v * 2, tl, tm);
dfs(v * 2 + 1, tm + 1, tr);
LI.rollback();
}
} t;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
ans[i] = -INF;
long long tp, a, b;
cin >> tp >> a;
if (tp == 1) {
cin >> b;
was[i] = {a, b};
del[i] = -1;
}
if (tp == 2) {
t.upd(a, i - 1, was[a]);
del[a] = 1;
}
if (tp == 3) {
t.q[i] = {a, 1};
}
}
for (int i = 1; i <= n; ++i) {
if (del[i] == -1) {
t.upd(i, n, was[i]);
}
}
t.dfs();
for (int i = 1; i <= n; ++i) {
if (t.q[i].second == 1) {
if (ans[i] == -INF)
cout << "EMPTY SET\n";
else
cout << ans[i] << '\n';
}
}
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Ali is Hamed's little brother and tomorrow is his birthday. Hamed wants his brother to earn his gift so he gave him a hard programming problem and told him if he can successfully solve it, he'll get him a brand new laptop. Ali is not yet a very talented programmer like Hamed and although he usually doesn't cheat but this time is an exception. It's about a brand new laptop. So he decided to secretly seek help from you. Please solve this problem for Ali.
An n-vertex weighted rooted tree is given. Vertex number 1 is a root of the tree. We define d(u, v) as the sum of edges weights on the shortest path between vertices u and v. Specifically we define d(u, u) = 0. Also let's define S(v) for each vertex v as a set containing all vertices u such that d(1, u) = d(1, v) + d(v, u). Function f(u, v) is then defined using the following formula:
<image>
The goal is to calculate f(u, v) for each of the q given pair of vertices. As the answer can be rather large it's enough to print it modulo 109 + 7.
Input
In the first line of input an integer n (1 ≤ n ≤ 105), number of vertices of the tree is given.
In each of the next n - 1 lines three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n, 1 ≤ ci ≤ 109) are given indicating an edge between ai and bi with weight equal to ci.
In the next line an integer q (1 ≤ q ≤ 105), number of vertex pairs, is given.
In each of the next q lines two space-separated integers ui, vi (1 ≤ ui, vi ≤ n) are given meaning that you must calculate f(ui, vi).
It is guaranteed that the given edges form a tree.
Output
Output q lines. In the i-th line print the value of f(ui, vi) modulo 109 + 7.
Examples
Input
5
1 2 1
4 3 1
3 5 1
1 3 1
5
1 1
1 5
2 4
2 1
3 5
Output
10
1000000005
1000000002
23
1000000002
Input
8
1 2 100
1 3 20
2 4 2
2 5 1
3 6 1
3 7 2
6 8 5
6
1 8
2 3
5 8
2 6
4 7
6 1
Output
999968753
49796
999961271
999991235
999958569
45130
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int mo = 1e9 + 7;
struct Val {
int x2, x1, x0;
friend Val operator+(const Val &a, const Val &b) {
return Val{(a.x2 + b.x2) % mo, (a.x1 + b.x1) % mo, (a.x0 + b.x0) % mo};
}
friend Val operator-(const Val &a, const Val &b) {
return Val{(a.x2 - b.x2) % mo, (a.x1 - b.x1) % mo, (a.x0 - b.x0) % mo};
}
friend Val operator*(const Val &a, const int d) {
Val c;
c.x2 = (a.x2 + 2ll * d * a.x1 + (long long)d * d % mo * a.x0) % mo;
c.x1 = (a.x1 + 1ll * d * a.x0) % mo;
c.x0 = a.x0;
return c;
}
} f[120000], g[120000], sum[120000];
int w[120000], ff[21][120000], dep[120000], Q, n;
vector<pair<int, int> > E[120000];
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; --i)
if (dep[x] - dep[y] >= 1 << i) x = ff[i][x];
if (x == y) return x;
for (int i = 20; i >= 0; --i)
if (ff[i][x] != ff[i][y]) x = ff[i][x], y = ff[i][y];
return ff[0][x];
}
void dfs(int x, int fa) {
ff[0][x] = fa;
for (int i = 1; i <= 20; ++i) ff[i][x] = ff[i - 1][ff[i - 1][x]];
f[x].x2 = f[x].x1 = 0;
f[x].x0 = 1;
for (auto e : E[x])
if (e.first != fa) {
dep[e.first] = dep[x] + 1;
w[e.first] = (w[x] + e.second) % mo;
dfs(e.first, x);
f[x] = f[x] + f[e.first] * e.second;
}
}
void dp(int x, int fa) {
Val tmp = {0, 0, 1};
for (auto e : E[x])
if (e.first != fa) tmp = tmp + f[e.first] * e.second;
for (auto e : E[x])
if (e.first != fa) {
int y = e.first;
sum[y] = (sum[x] + (tmp - f[y] * e.second)) * e.second;
g[y] = (tmp + g[x] - f[y] * e.second) * e.second;
dp(y, x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
E[x].push_back(make_pair(y, k));
E[y].push_back(make_pair(x, k));
}
dfs(1, 0);
dp(1, 0);
scanf("%d", &Q);
for (int _ = 1; _ <= Q; ++_) {
int u, v;
scanf("%d%d", &u, &v);
int lca = LCA(u, v), dist = ((long long)w[u] + w[v] - 2 * w[lca]) % mo, ans;
if (lca == v)
ans = (2ll * (f[u].x2 + (sum[u] - sum[v] * dist).x2) - (f[u] + g[u]).x2) %
mo;
else
ans = (2ll * (f[v] * dist).x2 - (f[u] + g[u]).x2) % mo;
printf("%d\n", (ans + mo) % mo);
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Polycarp takes part in a math show. He is given n tasks, each consists of k subtasks, numbered 1 through k. It takes him tj minutes to solve the j-th subtask of any task. Thus, time required to solve a subtask depends only on its index, but not on the task itself. Polycarp can solve subtasks in any order.
By solving subtask of arbitrary problem he earns one point. Thus, the number of points for task is equal to the number of solved subtasks in it. Moreover, if Polycarp completely solves the task (solves all k of its subtasks), he recieves one extra point. Thus, total number of points he recieves for the complete solution of the task is k + 1.
Polycarp has M minutes of time. What is the maximum number of points he can earn?
Input
The first line contains three integer numbers n, k and M (1 ≤ n ≤ 45, 1 ≤ k ≤ 45, 0 ≤ M ≤ 2·109).
The second line contains k integer numbers, values tj (1 ≤ tj ≤ 1000000), where tj is the time in minutes required to solve j-th subtask of any task.
Output
Print the maximum amount of points Polycarp can earn in M minutes.
Examples
Input
3 4 11
1 2 3 4
Output
6
Input
5 5 10
1 2 4 8 16
Output
7
Note
In the first example Polycarp can complete the first task and spend 1 + 2 + 3 + 4 = 10 minutes. He also has the time to solve one subtask of the second task in one minute.
In the second example Polycarp can solve the first subtask of all five tasks and spend 5·1 = 5 minutes. Also he can solve the second subtasks of two tasks and spend 2·2 = 4 minutes. Thus, he earns 5 + 2 = 7 points in total.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t[100], k;
int get(int m, int n) {
int res = 0;
vector<int> a;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
a.push_back(t[j]);
}
}
sort(a.begin(), a.end());
for (int i = 0; i < (int(a.size())); i++) {
if (m >= a[i]) {
m -= a[i];
res++;
}
}
return res;
}
int main() {
int n, m, sum = 0;
scanf("%d %d %d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &t[i]);
sum += t[i];
}
sort(t + 1, t + k + 1);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (m < sum * i) {
break;
}
ans = max(ans, (k + 1) * i + get(m - sum * i, n - i));
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Heidi has finally found the mythical Tree of Life – a legendary combinatorial structure which is said to contain a prophecy crucially needed to defeat the undead armies.
On the surface, the Tree of Life is just a regular undirected tree well-known from computer science. This means that it is a collection of n points (called vertices), some of which are connected using n - 1 line segments (edges) so that each pair of vertices is connected by a path (a sequence of one or more edges).
To decipher the prophecy, Heidi needs to perform a number of steps. The first is counting the number of lifelines in the tree – these are paths of length 2, i.e., consisting of two edges. Help her!
Input
The first line of the input contains a single integer n – the number of vertices in the tree (1 ≤ n ≤ 10000). The vertices are labeled with the numbers from 1 to n. Then n - 1 lines follow, each describing one edge using two space-separated numbers a b – the labels of the vertices connected by the edge (1 ≤ a < b ≤ n). It is guaranteed that the input represents a tree.
Output
Print one integer – the number of lifelines in the tree.
Examples
Input
4
1 2
1 3
1 4
Output
3
Input
5
1 2
2 3
3 4
3 5
Output
4
Note
In the second sample, there are four lifelines: paths between vertices 1 and 3, 2 and 4, 2 and 5, and 4 and 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> point[10010];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) point[i].clear();
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
point[a].push_back(b);
point[b].push_back(a);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = point[i].size();
ans += t * (t - 1) / 2;
}
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You have a string s — a sequence of commands for your toy robot. The robot is placed in some cell of a rectangular grid. He can perform four commands:
* 'W' — move one cell up;
* 'S' — move one cell down;
* 'A' — move one cell left;
* 'D' — move one cell right.
Let Grid(s) be the grid of minimum possible area such that there is a position in the grid where you can place the robot in such a way that it will not fall from the grid while running the sequence of commands s. For example, if s = DSAWWAW then Grid(s) is the 4 × 3 grid:
1. you can place the robot in the cell (3, 2);
2. the robot performs the command 'D' and moves to (3, 3);
3. the robot performs the command 'S' and moves to (4, 3);
4. the robot performs the command 'A' and moves to (4, 2);
5. the robot performs the command 'W' and moves to (3, 2);
6. the robot performs the command 'W' and moves to (2, 2);
7. the robot performs the command 'A' and moves to (2, 1);
8. the robot performs the command 'W' and moves to (1, 1).
<image>
You have 4 extra letters: one 'W', one 'A', one 'S', one 'D'. You'd like to insert at most one of these letters in any position of sequence s to minimize the area of Grid(s).
What is the minimum area of Grid(s) you can achieve?
Input
The first line contains one integer T (1 ≤ T ≤ 1000) — the number of queries.
Next T lines contain queries: one per line. This line contains single string s (1 ≤ |s| ≤ 2 ⋅ 10^5, s_i ∈ \{W, A, S, D\}) — the sequence of commands.
It's guaranteed that the total length of s over all queries doesn't exceed 2 ⋅ 10^5.
Output
Print T integers: one per query. For each query print the minimum area of Grid(s) you can achieve.
Example
Input
3
DSAWWAW
D
WA
Output
8
2
4
Note
In the first query you have to get string DSAWW\underline{D}AW.
In second and third queries you can not decrease the area of Grid(s).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int n = s.length();
vector<long long> x(n + 1, 0), y(n + 1, 0);
for (int i = 0; i < n; i++) {
x[i + 1] = x[i];
y[i + 1] = y[i];
if (s[i] == 'W')
x[i + 1]++;
else if (s[i] == 'A')
y[i + 1]--;
else if (s[i] == 'S')
x[i + 1]--;
else
y[i + 1]++;
}
vector<long long> xlh(n + 1), xll(n + 1), ylh(n + 1), yll(n + 1);
for (int i = 1; i <= n; i++) {
xlh[i] = max(xlh[i - 1], x[i]);
xll[i] = min(xll[i - 1], x[i]);
ylh[i] = max(ylh[i - 1], y[i]);
yll[i] = min(yll[i - 1], y[i]);
}
vector<long long> xrh(n + 1), xrl(n + 1), yrh(n + 1), yrl(n + 1);
xrh[n] = xrl[n] = x[n];
yrh[n] = yrl[n] = y[n];
for (int i = n - 1; i >= 0; i--) {
xrh[i] = max(xrh[i + 1], x[i]);
xrl[i] = min(xrl[i + 1], x[i]);
yrh[i] = max(yrh[i + 1], y[i]);
yrl[i] = min(yrl[i + 1], y[i]);
}
long long ans = (xlh[n] - xll[n] + 1) * (ylh[n] - yll[n] + 1);
for (int i = 0; i < n; i++) {
ans = min(ans, (max({xlh[i], xrh[i] + 1, x[i] + 1}) -
min({xll[i], xrl[i] + 1, x[i] + 1}) + 1) *
(max(ylh[i], yrh[i]) - min(yll[i], yrl[i]) + 1));
ans = min(ans, (max({xlh[i], xrh[i] - 1, x[i] - 1}) -
min({xll[i], xrl[i] - 1, x[i] - 1}) + 1) *
(max(ylh[i], yrh[i]) - min(yll[i], yrl[i]) + 1));
ans = min(ans, (max(xlh[i], xrh[i]) - min(xll[i], xrl[i]) + 1) *
(max({ylh[i], yrh[i] - 1, y[i] - 1}) -
min({yll[i], yrl[i] - 1, y[i] - 1}) + 1));
ans = min(ans, (max(xlh[i], xrh[i]) - min(xll[i], xrl[i]) + 1) *
(max({ylh[i], yrh[i] + 1, y[i] + 1}) -
min({yll[i], yrl[i] + 1, y[i] + 1}) + 1));
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Mahmoud was trying to solve the vertex cover problem on trees. The problem statement is:
Given an undirected tree consisting of n nodes, find the minimum number of vertices that cover all the edges. Formally, we need to find a set of vertices such that for each edge (u, v) that belongs to the tree, either u is in the set, or v is in the set, or both are in the set. Mahmoud has found the following algorithm:
* Root the tree at node 1.
* Count the number of nodes at an even depth. Let it be evenCnt.
* Count the number of nodes at an odd depth. Let it be oddCnt.
* The answer is the minimum between evenCnt and oddCnt.
The depth of a node in a tree is the number of edges in the shortest path between this node and the root. The depth of the root is 0.
Ehab told Mahmoud that this algorithm is wrong, but he didn't believe because he had tested his algorithm against many trees and it worked, so Ehab asked you to find 2 trees consisting of n nodes. The algorithm should find an incorrect answer for the first tree and a correct answer for the second one.
Input
The only line contains an integer n (2 ≤ n ≤ 105), the number of nodes in the desired trees.
Output
The output should consist of 2 independent sections, each containing a tree. The algorithm should find an incorrect answer for the tree in the first section and a correct answer for the tree in the second. If a tree doesn't exist for some section, output "-1" (without quotes) for that section only.
If the answer for a section exists, it should contain n - 1 lines, each containing 2 space-separated integers u and v (1 ≤ u, v ≤ n), which means that there's an undirected edge between node u and node v. If the given graph isn't a tree or it doesn't follow the format, you'll receive wrong answer verdict.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
-1
1 2
Input
8
Output
1 2
1 3
2 4
2 5
3 6
4 7
4 8
1 2
1 3
2 4
2 5
2 6
3 7
6 8
Note
In the first sample, there is only 1 tree with 2 nodes (node 1 connected to node 2). The algorithm will produce a correct answer in it so we printed - 1 in the first section, but notice that we printed this tree in the second section.
In the second sample:
In the first tree, the algorithm will find an answer with 4 nodes, while there exists an answer with 3 nodes like this: <image> In the second tree, the algorithm will find an answer with 3 nodes which is correct: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 6)
cout << -1 << endl;
else {
cout << "1 2" << endl;
cout << "2 3" << endl;
cout << "2 4" << endl;
cout << "4 5" << endl;
cout << "4 6" << endl;
for (int i = 7; i <= n; i++) cout << "4 " << i << "\n";
}
for (int i = 0; i < n - 1; i++) cout << i + 1 << " " << i + 2 << "\n";
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Polycarpus has a hobby — he develops an unusual social network. His work is almost completed, and there is only one more module to implement — the module which determines friends. Oh yes, in this social network one won't have to add friends manually! Pairs of friends are deduced in the following way. Let's assume that user A sent user B a message at time t1, and user B sent user A a message at time t2. If 0 < t2 - t1 ≤ d, then user B's message was an answer to user A's one. Users A and B are considered to be friends if A answered at least one B's message or B answered at least one A's message.
You are given the log of messages in chronological order and a number d. Find all pairs of users who will be considered to be friends.
Input
The first line of the input contains two integers n and d (1 ≤ n, d ≤ 1000). The next n lines contain the messages log. The i-th line contains one line of the log formatted as "Ai Bi ti" (without the quotes), which means that user Ai sent a message to user Bi at time ti (1 ≤ i ≤ n). Ai and Bi are non-empty strings at most 20 characters long, consisting of lowercase letters ('a' ... 'z'), and ti is an integer (0 ≤ ti ≤ 10000). It is guaranteed that the lines are given in non-decreasing order of ti's and that no user sent a message to himself. The elements in the lines are separated by single spaces.
Output
In the first line print integer k — the number of pairs of friends. In the next k lines print pairs of friends as "Ai Bi" (without the quotes). You can print users in pairs and the pairs themselves in any order. Each pair must be printed exactly once.
Examples
Input
4 1
vasya petya 1
petya vasya 2
anya ivan 2
ivan anya 4
Output
1
petya vasya
Input
1 1000
a b 0
Output
0
Note
In the first sample test case Vasya and Petya are friends because their messages' sending times are one second apart. Anya and Ivan are not, because their messages' sending times differ by more than one second.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ektamessage {
string sender, receiver;
int time;
};
int main() {
int i, j, n, d;
vector<ektamessage> v;
vector<pair<string, string> > ans;
map<pair<string, string>, vector<int> > pathaise;
map<pair<string, string>, int> nisi;
ektamessage x;
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> x.sender >> x.receiver >> x.time;
v.push_back(x);
pathaise[make_pair(x.sender, x.receiver)].push_back(x.time);
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (v[i].sender == v[j].receiver && v[i].receiver == v[j].sender &&
v[i].time != v[j].time && abs(v[i].time - v[j].time) <= d &&
!nisi[make_pair(v[i].sender, v[j].sender)] &&
!nisi[make_pair(v[i].sender, v[j].sender)]) {
ans.push_back(make_pair(v[i].sender, v[j].sender));
nisi[make_pair(v[i].sender, v[j].sender)] = 1;
nisi[make_pair(v[j].sender, v[i].sender)] = 1;
}
}
}
int len = ans.size();
cout << len << "\n";
for (i = 0; i < len; i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Input
The only line of input contains three integers a1, a2, a3 (1 ≤ a1, a2, a3 ≤ 20), separated by spaces.
Output
Output a single integer.
Examples
Input
2 3 2
Output
5
Input
13 14 1
Output
14
Input
14 5 9
Output
464
Input
17 18 3
Output
53
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
long double eps = 1e-9;
long long pp = 1000000007;
long long mo(long long a, long long pp) {
if (a >= 0 && a < pp) return a;
a %= pp;
if (a < 0) a += pp;
return a;
}
long long powmod(long long a, long long b, long long pp) {
long long ans = 1;
for (; b; b >>= 1, a = mo(a * a, pp))
if (b & 1) ans = mo(ans * a, pp);
return ans;
}
long long read() {
long long ans = 0;
char last = ' ', ch = getchar();
while (ch < '0' || ch > '9') last = ch, ch = getchar();
while (ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
int main() {
int x, y, tep, n;
cin >> x >> y >> n;
for (int i = 2; i <= n; i++) {
tep = x + y;
x = y;
y = tep;
}
cout << y << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Ramesses came to university to algorithms practice, and his professor, who is a fairly known programmer, gave him the following task.
You are given two matrices A and B of size n × m, each of which consists of 0 and 1 only. You can apply the following operation to the matrix A arbitrary number of times: take any submatrix of the matrix A that has at least two rows and two columns, and invert the values in its corners (i.e. all corners of the submatrix that contain 0, will be replaced by 1, and all corners of the submatrix that contain 1, will be replaced by 0). You have to answer whether you can obtain the matrix B from the matrix A.
<image> An example of the operation. The chosen submatrix is shown in blue and yellow, its corners are shown in yellow.
Ramesses don't want to perform these operations by himself, so he asks you to answer this question.
A submatrix of matrix M is a matrix which consist of all elements which come from one of the rows with indices x_1, x_1+1, …, x_2 of matrix M and one of the columns with indices y_1, y_1+1, …, y_2 of matrix M, where x_1, x_2, y_1, y_2 are the edge rows and columns of the submatrix. In other words, a submatrix is a set of elements of source matrix which form a solid rectangle (i.e. without holes) with sides parallel to the sides of the original matrix. The corners of the submatrix are cells (x_1, y_1), (x_1, y_2), (x_2, y_1), (x_2, y_2), where the cell (i,j) denotes the cell on the intersection of the i-th row and the j-th column.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 500) — the number of rows and the number of columns in matrices A and B.
Each of the next n lines contain m integers: the j-th integer in the i-th line is the j-th element of the i-th row of the matrix A (0 ≤ A_{ij} ≤ 1).
Each of the next n lines contain m integers: the j-th integer in the i-th line is the j-th element of the i-th row of the matrix B (0 ≤ B_{ij} ≤ 1).
Output
Print "Yes" (without quotes) if it is possible to transform the matrix A to the matrix B using the operations described above, and "No" (without quotes), if it is not possible. You can print each letter in any case (upper or lower).
Examples
Input
3 3
0 1 0
0 1 0
1 0 0
1 0 0
1 0 0
1 0 0
Output
Yes
Input
6 7
0 0 1 1 0 0 1
0 1 0 0 1 0 1
0 0 0 1 0 0 1
1 0 1 0 1 0 0
0 1 0 0 1 0 1
0 1 0 1 0 0 1
1 1 0 1 0 1 1
0 1 1 0 1 0 0
1 1 0 1 0 0 1
1 0 1 0 0 1 0
0 1 1 0 1 0 0
0 1 1 1 1 0 1
Output
Yes
Input
3 4
0 1 0 1
1 0 1 0
0 1 0 1
1 1 1 1
1 1 1 1
1 1 1 1
Output
No
Note
The examples are explained below.
<image> Example 1. <image> Example 2. <image> Example 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[510][510], b[510][510];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> b[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] == b[i][j]) continue;
a[i][j] ^= 1;
a[i][1] ^= 1;
a[1][j] ^= 1;
a[1][1] ^= 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] != b[i][j]) {
cout << "No";
return 0;
}
cout << "Yes";
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The academic year has just begun, but lessons and olympiads have already occupied all the free time. It is not a surprise that today Olga fell asleep on the Literature. She had a dream in which she was on a stairs.
The stairs consists of n steps. The steps are numbered from bottom to top, it means that the lowest step has number 1, and the highest step has number n. Above each of them there is a pointer with the direction (up or down) Olga should move from this step. As soon as Olga goes to the next step, the direction of the pointer (above the step she leaves) changes. It means that the direction "up" changes to "down", the direction "down" — to the direction "up".
Olga always moves to the next step in the direction which is shown on the pointer above the step.
If Olga moves beyond the stairs, she will fall and wake up. Moving beyond the stairs is a moving down from the first step or moving up from the last one (it means the n-th) step.
In one second Olga moves one step up or down according to the direction of the pointer which is located above the step on which Olga had been at the beginning of the second.
For each step find the duration of the dream if Olga was at this step at the beginning of the dream.
Olga's fall also takes one second, so if she was on the first step and went down, she would wake up in the next second.
Input
The first line contains single integer n (1 ≤ n ≤ 106) — the number of steps on the stairs.
The second line contains a string s with the length n — it denotes the initial direction of pointers on the stairs. The i-th character of string s denotes the direction of the pointer above i-th step, and is either 'U' (it means that this pointer is directed up), or 'D' (it means this pointed is directed down).
The pointers are given in order from bottom to top.
Output
Print n numbers, the i-th of which is equal either to the duration of Olga's dream or to - 1 if Olga never goes beyond the stairs, if in the beginning of sleep she was on the i-th step.
Examples
Input
3
UUD
Output
5 6 3
Input
10
UUDUDUUDDU
Output
5 12 23 34 36 27 18 11 6 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[1000010];
long long n = 0, i, up = 0, down = 0, l = 0, r = 0, x = 0, y = 0;
cin >> n;
cin >> c + 1;
for (i = 1; i <= n; i++) {
x += 2 * up;
y -= 2 * down;
if (c[i - 1] == 'U') up++, x++;
if (c[i - 1] == 'D') down--, y++;
while (down - 1 < up && r < n)
if (c[++r] == 'D') {
down++;
y += 2 * (r - i) + 1;
}
while (down < up && r == n)
if (c[++l] == 'U') {
up--;
x -= 2 * (i - l) - 1;
}
if (down - 1 == up)
cout << x + y + i - 1 << " ";
else
cout << x + y + n - i + 1 << " ";
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
We know that prime numbers are positive integers that have exactly two distinct positive divisors. Similarly, we'll call a positive integer t Т-prime, if t has exactly three distinct positive divisors.
You are given an array of n positive integers. For each of them determine whether it is Т-prime or not.
Input
The first line contains a single positive integer, n (1 ≤ n ≤ 105), showing how many numbers are in the array. The next line contains n space-separated integers xi (1 ≤ xi ≤ 1012).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is advised to use the cin, cout streams or the %I64d specifier.
Output
Print n lines: the i-th line should contain "YES" (without the quotes), if number xi is Т-prime, and "NO" (without the quotes), if it isn't.
Examples
Input
3
4 5 6
Output
YES
NO
NO
Note
The given test has three numbers. The first number 4 has exactly three divisors — 1, 2 and 4, thus the answer for this number is "YES". The second number 5 has two divisors (1 and 5), and the third number 6 has four divisors (1, 2, 3, 6), hence the answer for them is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool prime[1000010];
void sieve() {
prime[0] = prime[1] = 1;
for (int i = 2; i * i < 1000010; ++i)
if (!prime[i])
for (int j = i * i; j <= 1000010; j += i) prime[j] = 1;
}
int main() {
sieve();
int n;
long long int x, sq;
scanf("%d", &n);
while (n--) {
scanf("%I64d", &x);
sq = sqrt(x);
puts(!prime[sq] && sq * sq == x ? "YES" : "NO");
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Iahub is so happy about inventing bubble sort graphs that he's staying all day long at the office and writing permutations. Iahubina is angry that she is no more important for Iahub. When Iahub goes away, Iahubina comes to his office and sabotage his research work.
The girl finds an important permutation for the research. The permutation contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n). She replaces some of permutation elements with -1 value as a revenge.
When Iahub finds out his important permutation is broken, he tries to recover it. The only thing he remembers about the permutation is it didn't have any fixed point. A fixed point for a permutation is an element ak which has value equal to k (ak = k). Your job is to proof to Iahub that trying to recover it is not a good idea. Output the number of permutations which could be originally Iahub's important permutation, modulo 1000000007 (109 + 7).
Input
The first line contains integer n (2 ≤ n ≤ 2000). On the second line, there are n integers, representing Iahub's important permutation after Iahubina replaces some values with -1.
It's guaranteed that there are no fixed points in the given permutation. Also, the given sequence contains at least two numbers -1 and each positive number occurs in the sequence at most once. It's guaranteed that there is at least one suitable permutation.
Output
Output a single integer, the number of ways Iahub could recover his permutation, modulo 1000000007 (109 + 7).
Examples
Input
5
-1 -1 4 3 -1
Output
2
Note
For the first test example there are two permutations with no fixed points are [2, 5, 4, 3, 1] and [5, 1, 4, 3, 2]. Any other permutation would have at least one fixed point.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long pow(long long num, long long power) {
if (power == 0) return 1;
if (power == 1) return num;
long long t = pow(num, power / 2);
return power % 2 ? t * t * num : t * t;
}
int check(int);
int binarysearch(int len) {
int lo = 1, hi = len, mid, flag;
while (lo <= hi) {
mid = hi + lo >> 1;
(flag = check(mid)) ? lo = mid + 1 : hi = mid - 1;
}
return mid - 1 + flag;
}
const int N = 1000 * 100 + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
int debug = 1;
int check(int a) { return a; }
inline int inp() {
int n = 0, s = 1, c = getchar();
if (c == '-') s = -1;
while (c < 48) c = getchar();
while (c > 47) n = (n << 3) + (n << 1) + c - '0', c = getchar();
return n * s;
}
int a[N];
int vis1[N], vis2[N];
long long dp[2005][2005], fact[2005];
int solve(int a, int b) {
if (a == 0) return fact[b];
if (b < 0) return 0;
if (a < 0) return 0;
if (dp[a][b] != -1) return dp[a][b];
long long &res = dp[a][b];
res = 0;
if (b) res = (res + (long long)b * solve(a - 1, b) % MOD) % MOD;
res = (res + (long long)(a - 1) * solve(a - 2, b + 1) % MOD) % MOD;
return res;
}
int main() {
ios::sync_with_stdio(false);
int i, j, n, t;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i + 1];
for (i = 1; i < n + 1; i++)
if (a[i] != -1) {
vis1[a[i]] = 1;
} else {
vis2[i] = 1;
}
fact[0] = 1;
for (i = 1; i < 2005; i++) fact[i] = fact[i - 1] * (long long)i % MOD;
for (i = 0; i < 2005; i++)
for (j = 0; j < 2005; j++) dp[i][j] = -1;
int c, d;
c = d = 0;
for (i = 1; i < n + 1; i++) {
if (vis1[i] && vis2[i])
d++;
else if (vis2[i])
c++;
}
cout << solve(c, d);
cin >> i;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
### Response
```cpp
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int N,k,pre,sum=0;
cin>>N;
for(int i=1;i<=N;i++){
k=0;pre=i;
while(pre>0){k++;pre/=10;}
sum+=k%2;
}
cout<<sum;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int n;
map<pair<long long int, long long int>, long long int> val;
long long int get_lca(long long int x, long long int y) {
vector<long long int> a, b;
a.clear();
b.clear();
while (x > 0) {
a.push_back(x);
x >>= 1;
}
while (y > 0) {
b.push_back(y);
y >>= 1;
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
long long int j = 0;
for (j = 0; j < a.size() && j < b.size(); j++) {
if (a[j] != b[j]) break;
}
return a[j - 1];
}
void upd(long long int x, long long int l, long long int w) {
long long int y = x % 2;
x >>= 1;
while (x > 0) {
val[{x, y}] += w;
y = x % 2;
x >>= 1;
}
y = l % 2;
l >>= 1;
while (l > 0) {
val[{l, y}] -= w;
y = l % 2;
l >>= 1;
}
}
long long int get(long long int x, long long int l) {
long long int an = 0;
long long int y = x % 2;
x >>= 1;
while (x > 0 && x >= l) {
an += val[{x, y}];
y = x % 2;
x >>= 1;
}
return an;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
long long int t, u, v, w;
cin >> t >> u >> v;
if (t == 1) {
cin >> w;
long long int l = get_lca(u, v);
upd(u, l, w);
upd(v, l, w);
} else {
long long int l = get_lca(u, v);
long long int an = get(u, l) + get(v, l);
cout << an << '\n';
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The Smart Beaver from ABBYY has a long history of cooperating with the "Institute of Cytology and Genetics". Recently, the Institute staff challenged the Beaver with a new problem. The problem is as follows.
There is a collection of n proteins (not necessarily distinct). Each protein is a string consisting of lowercase Latin letters. The problem that the scientists offered to the Beaver is to select a subcollection of size k from the initial collection of proteins so that the representativity of the selected subset of proteins is maximum possible.
The Smart Beaver from ABBYY did some research and came to the conclusion that the representativity of a collection of proteins can be evaluated by a single number, which is simply calculated. Let's suppose we have a collection {a1, ..., ak} consisting of k strings describing proteins. The representativity of this collection is the following value:
<image>
where f(x, y) is the length of the longest common prefix of strings x and y; for example, f("abc", "abd") = 2, and f("ab", "bcd") = 0.
Thus, the representativity of collection of proteins {"abc", "abd", "abe"} equals 6, and the representativity of collection {"aaa", "ba", "ba"} equals 2.
Having discovered that, the Smart Beaver from ABBYY asked the Cup contestants to write a program that selects, from the given collection of proteins, a subcollection of size k which has the largest possible value of representativity. Help him to solve this problem!
Input
The first input line contains two integers n and k (1 ≤ k ≤ n), separated by a single space. The following n lines contain the descriptions of proteins, one per line. Each protein is a non-empty string of no more than 500 characters consisting of only lowercase Latin letters (a...z). Some of the strings may be equal.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 20
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 100
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 2000
Output
Print a single number denoting the largest possible value of representativity that a subcollection of size k of the given collection of proteins can have.
Examples
Input
3 2
aba
bzd
abq
Output
2
Input
4 3
eee
rrr
ttt
qqq
Output
0
Input
4 3
aaa
abba
abbc
abbd
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int sum = 0, w[N], f[N * 2][N];
string s[N];
bool compare(string a, string b) { return (a < b); }
int min(int a, int b) { return (a < b ? a : b); }
int work(int l, int r) {
int d = ++sum;
if (l < r) {
int i, j, left, right, b = l;
for (i = l + 1; i < r; i++)
if (w[i] < w[b]) b = i;
left = work(l, b);
right = work(b + 1, r);
for (i = 0; i <= b + 1 - l; i++)
for (j = 0; j <= r - b; j++)
if (f[d][i + j] < f[left][i] + f[right][j] + w[b] * i * j)
f[d][i + j] = f[left][i] + f[right][j] + w[b] * i * j;
}
return (d);
}
int main() {
memset(f, 0, sizeof(f));
int n, k, i, j, temp;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + n + 1, compare);
for (i = 1; i < n; i++) {
temp = min(s[i].size(), s[i + 1].size());
w[i] = temp;
for (j = 0; j < temp; j++)
if (s[i][j] != s[i + 1][j]) {
w[i] = j;
break;
}
}
work(1, n);
cout << f[1][k];
return (0);
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, numa, numb, numn, k;
numa = numb = 0;
numn = 1;
cin >> k >> a >> b;
n = k;
if (n == 2 * a + b) {
cout << 2 << endl;
} else if (a > b) {
for (numn = 1; numn <= 6; numn++, n = k) {
if (numa == 4 && numb == 2) break;
while (numa < 4) {
if (n - a >= 0) {
n = n - a;
numa++;
}
if (n - a < 0) break;
}
while (numb < 2) {
if (n - b >= 0) {
numb++;
n = n - b;
}
if (n - b < 0) break;
}
if (numa == 4 && numb == 2) break;
}
cout << numn << endl;
} else {
for (numn = 1; numn <= 6; numn++, n = k) {
if (numa == 4 && numb == 2) break;
while (numb < 2) {
if (n - b >= 0) {
numb++;
n = n - b;
}
if (n - b < 0) break;
}
while (numa < 4) {
if (n - a >= 0) {
n = n - a;
numa++;
}
if (n - a < 0) break;
}
if (numa == 4 && numb == 2) break;
}
cout << numn << endl;
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
In Japan, temperature is usually expressed using the Celsius (℃) scale. In America, they used the Fahrenheit (℉) scale instead. $20$ degrees Celsius is roughly equal to $68$ degrees Fahrenheit. A phrase such as "Today’s temperature is $68$ degrees" is commonly encountered while you are in America.
A value in Fahrenheit can be converted to Celsius by first subtracting $32$ and then multiplying by $\frac{5}{9}$. A simplified method may be used to produce a rough estimate: first subtract $30$ and then divide by $2$. Using the latter method, $68$ Fahrenheit is converted to $19$ Centigrade, i.e., $\frac{(68-30)}{2}$.
Make a program to convert Fahrenheit to Celsius using the simplified method: $C = \frac{F - 30}{2}$.
Input
The input is given in the following format.
$F$
The input line provides a temperature in Fahrenheit $F$ ($30 \leq F \leq 100$), which is an integer divisible by $2$.
Output
Output the converted Celsius temperature in a line.
Examples
Input
68
Output
19
Input
50
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
int f;
cin >> f;
cout << (f-30)/2 << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. "Rozdil").
However, Rozdil is dangerous to settle, so the Little Elephant wants to go to some other town. The Little Elephant doesn't like to spend much time on travelling, so for his journey he will choose a town that needs minimum time to travel to. If there are multiple such cities, then the Little Elephant won't go anywhere.
For each town except for Rozdil you know the time needed to travel to this town. Find the town the Little Elephant will go to or print "Still Rozdil", if he stays in Rozdil.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of cities. The next line contains n integers, separated by single spaces: the i-th integer represents the time needed to go from town Rozdil to the i-th town. The time values are positive integers, not exceeding 109.
You can consider the cities numbered from 1 to n, inclusive. Rozdil is not among the numbered cities.
Output
Print the answer on a single line — the number of the town the Little Elephant will go to. If there are multiple cities with minimum travel time, print "Still Rozdil" (without the quotes).
Examples
Input
2
7 4
Output
2
Input
7
7 4 47 100 4 9 12
Output
Still Rozdil
Note
In the first sample there are only two cities where the Little Elephant can go. The travel time for the first town equals 7, to the second one — 4. The town which is closest to Rodzil (the only one) is the second one, so the answer is 2.
In the second sample the closest cities are cities two and five, the travelling time to both of them equals 4, so the answer is "Still Rozdil".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
long long arr[n];
long long arr2[n];
for (long long i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
arr2[i] = arr[i];
}
sort(arr2, arr2 + n);
if (arr2[0] == arr2[1]) {
printf("Still Rozdil\n");
} else {
long long x = arr2[0];
for (long long i = 0; i < n; i++) {
if (arr[i] == x) {
printf("%lld\n", i + 1);
}
}
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The administration of the Tomsk Region firmly believes that it's time to become a megacity (that is, get population of one million). Instead of improving the demographic situation, they decided to achieve its goal by expanding the boundaries of the city.
The city of Tomsk can be represented as point on the plane with coordinates (0; 0). The city is surrounded with n other locations, the i-th one has coordinates (xi, yi) with the population of ki people. You can widen the city boundaries to a circle of radius r. In such case all locations inside the circle and on its border are included into the city.
Your goal is to write a program that will determine the minimum radius r, to which is necessary to expand the boundaries of Tomsk, so that it becomes a megacity.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 103; 1 ≤ s < 106) — the number of locatons around Tomsk city and the population of the city. Then n lines follow. The i-th line contains three integers — the xi and yi coordinate values of the i-th location and the number ki of people in it (1 ≤ ki < 106). Each coordinate is an integer and doesn't exceed 104 in its absolute value.
It is guaranteed that no two locations are at the same point and no location is at point (0; 0).
Output
In the output, print "-1" (without the quotes), if Tomsk won't be able to become a megacity. Otherwise, in the first line print a single real number — the minimum radius of the circle that the city needs to expand to in order to become a megacity.
The answer is considered correct if the absolute or relative error don't exceed 10 - 6.
Examples
Input
4 999998
1 1 1
2 2 1
3 3 1
2 -2 1
Output
2.8284271
Input
4 999998
1 1 2
2 2 1
3 3 1
2 -2 1
Output
1.4142136
Input
2 1
1 1 999997
2 2 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
struct city {
float d;
int k;
};
int main() {
int n, s;
scanf("%d %d", &n, &s);
struct city cities[n];
float x, y;
for (int i = 0; i < n; i++) {
scanf("%f %f %d", &x, &y, &cities[i].k);
cities[i].d = sqrt(x * x + y * y);
}
struct city temp;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (cities[i].d > cities[j].d) {
temp = cities[i];
cities[i] = cities[j];
cities[j] = temp;
}
}
}
for (int i = 0; i < n; i++) {
s = s + cities[i].k;
if (s >= 1000000) {
printf("%f", cities[i].d);
return 0;
}
}
printf("%d", -1);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given a positive integer X. Find the largest perfect power that is at most X. Here, a perfect power is an integer that can be represented as b^p, where b is an integer not less than 1 and p is an integer not less than 2.
Constraints
* 1 ≤ X ≤ 1000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the largest perfect power that is at most X.
Examples
Input
10
Output
9
Input
1
Output
1
Input
999
Output
961
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int X;
cin >> X;
int ans = 1;
for(int i = 2; i < X; ++i) {
for(int j = 2; pow(i, j) <= X; ++j) {
ans = max(ans, int(pow(i, j)));
}
}
cout << ans << endl;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Example
Input
3
y 7
y 6
n 5
Output
1
### Response
```cpp
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
inline char nc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
char c=nc(),b=1;
for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
inline void read(char &x){
for (x=nc();!(x>='a' && x<='z');x=nc());
}
const int N=1005;
int n,ans;
int a[N],b[N];
int main(){
char order;
read(n);
for (int i=1;i<=n;i++){
read(order); read(a[i]);
if (order=='y') b[i]=1;
}
for (int i=1;i<=n;i++){
int t=0;
for (int j=1;j<=n;j++)
if (b[j] && (!t || a[j]<a[t]))
t=j;
if (!t) break;
for (int j=t-1;j;j--)
if (!b[j] && a[j]>=a[t])
break;
else if (b[j])
a[j]=-1;
for (int j=t+1;j<=n;j++)
if (!b[j] && a[j]>=a[t])
break;
else if (b[j])
a[j]=-1;
a[t]=-1;
int pnt=0;
for (int j=1;j<=n;j++)
if (a[j]!=-1)
a[++pnt]=a[j],b[pnt]=b[j];
n=pnt;
++ans;
}
printf("%d\n",ans);
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given positive integers X and Y. If there exists a positive integer not greater than 10^{18} that is a multiple of X but not a multiple of Y, choose one such integer and print it. If it does not exist, print -1.
Constraints
* 1 ≤ X,Y ≤ 10^9
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print a positive integer not greater than 10^{18} that is a multiple of X but not a multiple of Y, or print -1 if it does not exist.
Examples
Input
8 6
Output
16
Input
3 3
Output
-1
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int x,y;
cin>>x>>y;
cout<<(x%y==0 ? -1 : x)<<endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
In Berland recently a new collection of toys went on sale. This collection consists of 109 types of toys, numbered with integers from 1 to 109. A toy from the new collection of the i-th type costs i bourles.
Tania has managed to collect n different types of toys a1, a2, ..., an from the new collection. Today is Tanya's birthday, and her mother decided to spend no more than m bourles on the gift to the daughter. Tanya will choose several different types of toys from the new collection as a gift. Of course, she does not want to get a type of toy which she already has.
Tanya wants to have as many distinct types of toys in her collection as possible as the result. The new collection is too diverse, and Tanya is too little, so she asks you to help her in this.
Input
The first line contains two integers n (1 ≤ n ≤ 100 000) and m (1 ≤ m ≤ 109) — the number of types of toys that Tanya already has and the number of bourles that her mom is willing to spend on buying new toys.
The next line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the types of toys that Tanya already has.
Output
In the first line print a single integer k — the number of different types of toys that Tanya should choose so that the number of different types of toys in her collection is maximum possible. Of course, the total cost of the selected toys should not exceed m.
In the second line print k distinct space-separated integers t1, t2, ..., tk (1 ≤ ti ≤ 109) — the types of toys that Tanya should choose.
If there are multiple answers, you may print any of them. Values of ti can be printed in any order.
Examples
Input
3 7
1 3 4
Output
2
2 5
Input
4 14
4 6 12 8
Output
4
7 2 3 1
Note
In the first sample mom should buy two toys: one toy of the 2-nd type and one toy of the 5-th type. At any other purchase for 7 bourles (assuming that the toys of types 1, 3 and 4 have already been bought), it is impossible to buy two and more toys.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long m;
cin >> n >> m;
vector<long long> A(n);
vector<long long> B(100000);
int count = 0;
for (int ii = 0; ii < n; ++ii) cin >> A[ii];
sort(A.begin(), A.end());
long long i = 0;
int j = 0;
while (m > i) {
i++;
if (j < n) {
if (i == A[j]) {
j++;
continue;
}
}
B[count++] = i;
m -= i;
}
cout << count << "\n";
for (j = 0; j < count; j++) {
cout << B[j] << " ";
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
There are n beacons located at distinct positions on a number line. The i-th beacon has position ai and power level bi. When the i-th beacon is activated, it destroys all beacons to its left (direction of decreasing coordinates) within distance bi inclusive. The beacon itself is not destroyed however. Saitama will activate the beacons one at a time from right to left. If a beacon is destroyed, it cannot be activated.
Saitama wants Genos to add a beacon strictly to the right of all the existing beacons, with any position and any power level, such that the least possible number of beacons are destroyed. Note that Genos's placement of the beacon means it will be the first beacon activated. Help Genos by finding the minimum number of beacons that could be destroyed.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 100 000) — the initial number of beacons.
The i-th of next n lines contains two integers ai and bi (0 ≤ ai ≤ 1 000 000, 1 ≤ bi ≤ 1 000 000) — the position and power level of the i-th beacon respectively. No two beacons will have the same position, so ai ≠ aj if i ≠ j.
Output
Print a single integer — the minimum number of beacons that could be destroyed if exactly one beacon is added.
Examples
Input
4
1 9
3 1
6 1
7 4
Output
1
Input
7
1 1
2 1
3 1
4 1
5 1
6 1
7 1
Output
3
Note
For the first sample case, the minimum number of beacons destroyed is 1. One way to achieve this is to place a beacon at position 9 with power level 2.
For the second sample case, the minimum number of beacons destroyed is 3. One way to achieve this is to place a beacon at position 1337 with power level 42.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const int MOD = int(1e9) + 7;
const long long N = 1000010;
const long long INFll = 1ll * INF * INF;
const long double INFld = 1e+018;
const long double EPS = 0.000000001;
const int sdx[4] = {-1, 0, 1, 0};
const int sdy[4] = {0, 1, 0, -1};
const long double PI = 3.1415926535897932384;
template <typename T>
ostream& operator<<(ostream& out, pair<T, T>& a) {
out << a.first << " " << a.second;
return out;
}
template <typename T>
istream& operator>>(istream& in, pair<T, T>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> a) {
for (int i = 0; i < a.size(); ++i)
if (i == a.size() - 1)
out << a[i];
else
out << a[i] << " ";
return out;
}
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a.begin(), a.end());
vector<int> dp(n, 0);
for (int i = 1; i < n; i++) {
int d = lower_bound(a.begin(), a.end(),
make_pair(a[i].first - a[i].second, 0)) -
a.begin();
dp[i] = i - d;
if (d) dp[i] += dp[d - 1];
}
int ans = n;
for (int i = 0; i < n; i++) ans = min(ans, dp[i] + n - i - 1);
cout << ans << endl;
if (0)
cerr << fixed << setprecision(0)
<< "TIME = " << clock() / (long double)CLOCKS_PER_SEC * 1000 << "\n";
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You have an array a_1, a_2, ..., a_n.
Let's call some subarray a_l, a_{l + 1}, ... , a_r of this array a subpermutation if it contains all integers from 1 to r-l+1 exactly once. For example, array a = [2, 2, 1, 3, 2, 3, 1] contains 6 subarrays which are subpermutations: [a_2 ... a_3], [a_2 ... a_4], [a_3 ... a_3], [a_3 ... a_5], [a_5 ... a_7], [a_7 ... a_7].
You are asked to calculate the number of subpermutations.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ n).
This array can contain the same integers.
Output
Print the number of subpermutations of the array a.
Examples
Input
8
2 4 1 3 4 2 1 2
Output
7
Input
5
1 1 2 1 2
Output
6
Note
There are 7 subpermutations in the first test case. Their segments of indices are [1, 4], [3, 3], [3, 6], [4, 7], [6, 7], [7, 7] and [7, 8].
In the second test case 6 subpermutations exist: [1, 1], [2, 2], [2, 3], [3, 4], [4, 4] and [4, 5].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 7;
struct nd {
int mn, cnt;
};
nd tr[4 * MAXN];
int lazy[4 * MAXN];
nd combine(const nd &a, const nd &b) {
if (a.mn < b.mn)
return a;
else if (a.mn > b.mn)
return b;
nd rt;
rt.mn = a.mn;
rt.cnt = a.cnt + b.cnt;
return rt;
}
void propagate(int u, int l, int r) {
if (lazy[u]) {
tr[u].mn += lazy[u];
if (l != r) {
lazy[u * 2] += lazy[u];
lazy[u * 2 + 1] += lazy[u];
}
lazy[u] = 0;
}
}
int a[MAXN];
void build(int u, int l, int r) {
lazy[u] = 0;
if (l == r) {
tr[u].mn = a[l];
tr[u].cnt = 1;
return;
}
int mid = (l + r) / 2;
build(u * 2, l, mid);
build(u * 2 + 1, mid + 1, r);
tr[u] = combine(tr[u * 2], tr[u * 2 + 1]);
}
void update(int u, int l, int r, int x, int y, int v) {
assert(x <= y);
propagate(u, l, r);
if (r < x || y < l) return;
if (x <= l && r <= y) {
lazy[u] += v;
propagate(u, l, r);
return;
}
int mid = (l + r) / 2;
update(u * 2, l, mid, x, y, v);
update(u * 2 + 1, mid + 1, r, x, y, v);
tr[u] = combine(tr[u * 2], tr[u * 2 + 1]);
}
nd query(int u, int l, int r, int x, int y) {
assert(x <= y);
propagate(u, l, r);
if (x <= l && r <= y) return tr[u];
int mid = (l + r) / 2;
if (y <= mid) return query(u * 2, l, mid, x, y);
if (mid < x) return query(u * 2 + 1, mid + 1, r, x, y);
return combine(query(u * 2, l, mid, x, y),
query(u * 2 + 1, mid + 1, r, x, y));
}
int p[MAXN];
long long ans;
int n;
void solve(int l, int mid, int r) {
if (l == r) {
ans += p[l] == 1;
return;
}
set<int> st;
int dan;
for (dan = mid; dan + 1 <= r && st.count(p[dan + 1]) == 0; dan++) {
st.insert(p[dan + 1]);
}
stack<int> minStack, maxStack;
for (int i = dan; i > mid; i--) {
while (!minStack.empty() && p[i] <= p[minStack.top()]) minStack.pop();
minStack.push(i);
while (!maxStack.empty() && p[i] >= p[maxStack.top()]) maxStack.pop();
maxStack.push(i);
}
int mx = p[mid + 1], mn = p[mid + 1];
for (int R = mid + 1; R <= dan; R++) {
mx = max(mx, p[R]);
mn = min(mn, p[R]);
a[R - mid] = mx - mn - R;
}
int m = dan - mid;
build(1, 1, m);
{
nd qr = query(1, 1, m, 1, m);
assert(qr.mn >= -(mid + 1));
if (qr.mn == -(mid + 1)) {
ans += qr.cnt;
}
}
for (int L = mid; L >= l; L--) {
while (st.count(p[L]) == 1 && mid < dan) {
st.erase(p[dan]);
dan--;
}
if (dan <= mid) break;
st.insert(p[L]);
while (!minStack.empty() && minStack.top() <= dan &&
p[L] <= p[minStack.top()]) {
int x = minStack.top();
minStack.pop();
int y = minStack.empty() ? dan : minStack.top() - 1;
int del = p[L] - p[x];
update(1, 1, m, x - mid, min(y, dan) - mid, -del);
}
minStack.push(L);
while (!maxStack.empty() && maxStack.top() <= dan &&
p[L] >= p[maxStack.top()]) {
int x = maxStack.top();
maxStack.pop();
int y = maxStack.empty() ? dan : maxStack.top() - 1;
int del = p[L] - p[x];
update(1, 1, m, x - mid, min(y, dan) - mid, del);
}
maxStack.push(L);
nd q = query(1, 1, m, 1, dan - mid);
assert(q.mn >= -L);
if (q.mn == -L) {
ans += q.cnt;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<int> ones;
ones.push_back(0);
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] == 1) ones.push_back(i);
}
ones.push_back(n + 1);
for (int i = 1; i + 1 < ones.size(); i++) {
solve(ones[i - 1] + 1, ones[i] - 1, ones[i + 1] - 1);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given a connected undirected graph without cycles (that is, a tree) of n vertices, moreover, there is a non-negative integer written on every edge.
Consider all pairs of vertices (v, u) (that is, there are exactly n^2 such pairs) and for each pair calculate the bitwise exclusive or (xor) of all integers on edges of the simple path between v and u. If the path consists of one vertex only, then xor of all integers on edges of this path is equal to 0.
Suppose we sorted the resulting n^2 values in non-decreasing order. You need to find the k-th of them.
The definition of xor is as follows.
Given two integers x and y, consider their binary representations (possibly with leading zeros): x_k ... x_2 x_1 x_0 and y_k ... y_2 y_1 y_0 (where k is any number so that all bits of x and y can be represented). Here, x_i is the i-th bit of the number x and y_i is the i-th bit of the number y. Let r = x ⊕ y be the result of the xor operation of x and y. Then r is defined as r_k ... r_2 r_1 r_0 where:
$$$ r_i = \left\{ \begin{aligned} 1, ~ if ~ x_i ≠ y_i \\\ 0, ~ if ~ x_i = y_i \end{aligned} \right. $$$
Input
The first line contains two integers n and k (2 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the number of vertices in the tree and the number of path in the list with non-decreasing order.
Each of the following n - 1 lines contains two integers p_i and w_i (1 ≤ p_i ≤ i, 0 ≤ w_i < 2^{62}) — the ancestor of vertex i + 1 and the weight of the corresponding edge.
Output
Print one integer: k-th smallest xor of a path in the tree.
Examples
Input
2 1
1 3
Output
0
Input
3 6
1 2
1 3
Output
2
Note
The tree in the second sample test looks like this:
<image>
For such a tree in total 9 paths exist:
1. 1 → 1 of value 0
2. 2 → 2 of value 0
3. 3 → 3 of value 0
4. 2 → 3 (goes through 1) of value 1 = 2 ⊕ 3
5. 3 → 2 (goes through 1) of value 1 = 2 ⊕ 3
6. 1 → 2 of value 2
7. 2 → 1 of value 2
8. 1 → 3 of value 3
9. 3 → 1 of value 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n;
long long k;
long long d[N];
int v1[N], v2[N];
int go[N][3];
long long t[N];
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int p;
scanf("%d%lld", &p, &d[i]);
d[i] ^= d[p];
}
for (int i = 1; i <= n; i++) {
v1[i] = v2[i] = 1;
}
long long answ = 0;
for (int i = 61; i >= 0; i--) {
int timer = 1;
for (int j = 1; j <= n; j++) {
t[j] = 0;
go[j][0] = go[j][1] = 0;
}
for (int j = 1; j <= n; j++) {
int bit = ((d[j] >> i) & 1);
if (go[v1[j]][bit] == 0) {
go[v1[j]][bit] = ++timer;
}
t[go[v1[j]][bit]]++;
v1[j] = go[v1[j]][bit];
}
long long s0 = 0;
for (int j = 1; j <= n; j++) {
int bit = ((d[j] >> i) & 1);
s0 += t[go[v2[j]][bit]];
}
int flag = 0;
if (s0 < k) {
k -= s0;
answ += (1ll << i);
flag = 1;
}
for (int j = 1; j <= n; j++) {
int bit = ((d[j] >> i) & 1);
v2[j] = go[v2[j]][bit ^ flag];
}
}
cout << answ << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Alice is a big fan of volleyball and especially of the very strong "Team A".
Volleyball match consists of up to five sets. During each set teams score one point for winning a ball. The first four sets are played until one of the teams scores at least 25 points and the fifth set is played until one of the teams scores at least 15 points. Moreover, if one of the teams scores 25 (or 15 in the fifth set) points while the other team scores 24 (or 14 in the fifth set), the set is played until the absolute difference between teams' points becomes two. The match ends when one of the teams wins three sets. The match score is the number of sets won by each team.
Alice found a book containing all the results of all matches played by "Team A". The book is old, and some parts of the book became unreadable. Alice can not read the information on how many sets each of the teams won, she can not read the information on how many points each of the teams scored in each set, she even does not know the number of sets played in a match. The only information she has is the total number of points scored by each of the teams in all the sets during a single match.
Alice wonders what is the best match score "Team A" could achieve in each of the matches. The bigger is the difference between the number of sets won by "Team A" and their opponent, the better is the match score. Find the best match score or conclude that no match could end like that. If there is a solution, then find any possible score for each set that results in the best match score.
Input
The first line contains a single integer m (1 ≤ m ≤ 50 000) — the number of matches found by Alice in the book.
Each of the next m lines contains two integers a and b (0 ≤ a, b ≤ 200) — the number of points scored by "Team A" and the number of points scored by their opponents respectively.
Output
Output the solution for every match in the same order as they are given in the input. If the teams could not score a and b points respectively, output "Impossible".
Otherwise, output the match score formatted as "x:y", where x is the number of sets won by "Team A" and y is the number of sets won by their opponent.
The next line should contain the set scores in the order they were played. Each set score should be printed in the same format as the match score, with x being the number of points scored by "Team A" in this set, and y being the number of points scored by their opponent.
Example
Input
6
75 0
90 90
20 0
0 75
78 50
80 100
Output
3:0
25:0 25:0 25:0
3:1
25:22 25:22 15:25 25:21
Impossible
0:3
0:25 0:25 0:25
3:0
25:11 28:26 25:13
3:2
25:17 0:25 25:22 15:25 15:11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const bool ready = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
return true;
}();
const double PI = acos(-1);
using ll = long long;
using pii = pair<ll, ll>;
using pdd = pair<double, double>;
using vd = vector<double>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using vvvvb = vector<vvvb>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vs = vector<string>;
const ll N = 201;
pair<bool, tuple<ll, ll, ll, ll>> dp[4][4][N][N];
void precalc() {
for (ll i = 0; i < 4; i++) {
for (ll j = 0; j < 4; j++) {
for (ll x = 0; x < N; x++) {
for (ll y = 0; y < N; y++) {
dp[i][j][x][y] = {false, {-1, -1, -1, -1}};
}
}
}
}
dp[0][0][0][0].first = true;
vector<pii> pp = {{0, 0}, {1, 0}, {0, 1}, {1, 1},
{2, 0}, {0, 2}, {2, 1}, {1, 2}};
for (auto [i, j] : pp) {
const ll ma = 25;
for (ll x = 0; x < N; x++) {
for (ll y = 0; y < N; y++) {
if (dp[i][j][x][y].first) {
if (y + ma < N) {
for (ll xx = 0; x + xx < N && xx <= ma - 2; xx++)
dp[i][j + 1][x + xx][y + ma] = {true, {i, j, x, y}};
for (ll xx = ma - 1, yy = ma + 1; x + xx < N && y + yy < N;
xx++, yy++)
dp[i][j + 1][x + xx][y + yy] = {true, {i, j, x, y}};
}
if (x + ma < N) {
for (ll yy = 0; y + yy < N && yy <= ma - 2; yy++)
dp[i + 1][j][x + ma][y + yy] = {true, {i, j, x, y}};
for (ll yy = ma - 1, xx = ma + 1; y + yy < N && xx + x < N;
yy++, xx++)
dp[i + 1][j][x + xx][y + yy] = {true, {i, j, x, y}};
}
}
}
}
}
const ll ma = 15;
for (ll x = 0; x < N; x++) {
for (ll y = 0; y < N; y++) {
if (dp[2][2][x][y].first) {
if (y + ma < N) {
for (ll xx = 0; x + xx < N && xx <= ma - 2; xx++)
dp[2][3][x + xx][y + ma] = {true, {2, 2, x, y}};
for (ll xx = ma - 1, yy = ma + 1; xx + x < N && yy + y < N;
xx++, yy++)
dp[2][3][x + xx][y + yy] = {true, {2, 2, x, y}};
}
if (x + ma < N) {
for (ll yy = 0; y + yy < N && yy <= ma - 2; yy++)
dp[3][2][x + ma][y + yy] = {true, {2, 2, x, y}};
for (ll yy = ma - 1, xx = ma + 1; yy + y < N && xx + x < N;
yy++, xx++)
dp[3][2][x + xx][y + yy] = {true, {2, 2, x, y}};
}
}
}
}
}
void solve() {
ll aa;
cin >> aa;
;
ll bb;
cin >> bb;
;
const vector<pii> res = {{3, 0}, {3, 1}, {3, 2}, {2, 3}, {1, 3}, {0, 3}};
for (size_t idx = 0; idx < res.size(); idx++) {
ll i = res[idx].first;
ll j = res[idx].second;
ll x = aa;
ll y = bb;
if (dp[i][j][x][y].first) {
cout << i << ":" << j << endl;
vector<pii> ans;
do {
auto [ii, jj, xx, yy] = dp[i][j][x][y].second;
ans.push_back({x - xx, y - yy});
i = ii;
j = jj;
x = xx;
y = yy;
} while (get<0>(dp[i][j][x][y].second) >= 0);
reverse((ans).begin(), (ans).end());
for (size_t k = 0; k < ans.size(); k++) {
cout << ans[k].first << ":" << ans[k].second << " ";
}
cout << endl;
return;
}
}
cout << "Impossible" << endl;
}
signed main() {
precalc();
ll t;
cin >> t;
;
while (t--) solve();
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n / 2) — the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 ≤ ui ≤ n) — indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 ≤ xj, yj ≤ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 29;
vector<long long> adj[maxn];
long long u[maxn];
long long a[maxn];
long long m, ans = 0;
long long dfs(long long x, long long y) {
long long v = u[x];
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] == y) {
continue;
} else {
v += dfs(adj[x][i], x);
}
}
while (v * 2 > m) {
v -= 2;
m -= 2;
}
ans += v;
return v;
}
int main() {
long long n, k;
cin >> n >> k;
int x, y;
m = k * 2;
for (int i = 0; i < m; i++) {
cin >> a[i];
u[a[i]] = 1;
}
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
ans += dfs(1, 1);
cout << ans;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Little X used to play a card game called "24 Game", but recently he has found it too easy. So he invented a new game.
Initially you have a sequence of n integers: 1, 2, ..., n. In a single step, you can pick two of them, let's denote them a and b, erase them from the sequence, and append to the sequence either a + b, or a - b, or a × b.
After n - 1 steps there is only one number left. Can you make this number equal to 24?
Input
The first line contains a single integer n (1 ≤ n ≤ 105).
Output
If it's possible, print "YES" in the first line. Otherwise, print "NO" (without the quotes).
If there is a way to obtain 24 as the result number, in the following n - 1 lines print the required operations an operation per line. Each operation should be in form: "a op b = c". Where a and b are the numbers you've picked at this operation; op is either "+", or "-", or "*"; c is the result of corresponding operation. Note, that the absolute value of c mustn't be greater than 1018. The result of the last operation must be equal to 24. Separate operator sign and equality sign from numbers with spaces.
If there are multiple valid answers, you may print any of them.
Examples
Input
1
Output
NO
Input
8
Output
YES
8 * 7 = 56
6 * 5 = 30
3 - 4 = -1
1 - 2 = -1
30 - -1 = 31
56 - 31 = 25
25 + -1 = 24
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 4) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
if (n % 2 == 0) {
cout << "1 * 2 = 2\n"
<< "3 * 4 = 12\n"
<< "12 * 2 = 24\n";
for (int i = 5; i < n; i += 2) {
cout << i + 1 << " - " << i << " = " << 1 << '\n';
}
for (int i = 0; i < (n - 4) / 2; i++) {
cout << "24 * 1 = 24" << endl;
}
return 0;
} else {
cout << "5 - 2 = 3\n"
<< "3 - 1 = 2\n"
<< "2 * 4 = 8\n"
<< "8 * 3 = 24\n";
for (int i = 6; i < n; i += 2) {
cout << i + 1 << " - " << i << " = " << 1 << '\n';
}
for (int i = 0; i < (n - 4) / 2; i++) {
cout << "24 * 1 = 24" << endl;
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 23, inf = 0x3f3f3f3f;
long long a[N];
inline long long inp() {
long long c = getchar(), x = 0;
bool neg = 0;
for (; ((c < 48 or c > 57) and c != '-' and c != '?'); c = getchar())
;
if (c == '?') return inf;
if (c == '-') neg = 1, c = getchar();
for (; c > 47 and c < 58; c = getchar()) x = (x << 1) + (x << 3) + c - 48;
return neg ? -x : x;
}
bool fix(long long st, long long en, long long n, long long k) {
long long lo = (st < 0 ? -inf : a[st]) + 1;
long long hi = (en >= n ? inf : a[en]) - 1;
long long num = (en - st) / k - 1;
if (hi - lo + 1 < num) return false;
if (lo >= 0) {
for (long long i = st + k; i < en; i += k) a[i] = lo++;
return true;
}
if (hi <= 0) {
for (long long i = en - k; i > st; i -= k) a[i] = hi--;
return true;
}
long long fst = (num - 1) / 2;
long long snd = num / 2;
if (fst > abs(lo)) {
snd += fst - abs(lo);
fst = abs(lo);
} else if (snd > hi) {
fst += snd - hi;
snd = hi;
}
long long cur = -fst;
for (long long i = st + k; i < en; i += k) a[i] = cur++;
return true;
}
bool go(long long r, long long n, long long k) {
long long prev = r - k;
for (long long i = r; i < n; i += k) {
if (a[i] < inf) {
if (prev >= 0 and a[prev] >= a[i]) return false;
prev = i;
continue;
}
while (i < n and a[i] == inf) i += k;
bool can = fix(prev, i, n, k);
if (!can) return false;
prev = i;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n = inp(), k = inp();
for (long long i = 0; i < n; i++) a[i] = inp();
for (long long i = 0; i < k; i++)
if (!go(i, n, k)) {
cout << "Incorrect sequence\n";
return 0;
}
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Claire is a man-eater. She's a real man-eater. She's going around with dozens of guys. She's dating all the time. And one day she found some conflicts in her date schedule. D'oh!
So she needs to pick some dates and give the others up. The dates are set by hours like 13:00 to 15:00. She may have more than one date with a guy. For example, she can have dates with Adam from 10:00 to 12:00 and from 14:00 to 16:00 and with Bob from 12:00 to 13:00 and from 18:00 to 20:00. She can have these dates as long as there is no overlap of time. Time of traveling, time of make-up, trouble from love triangles, and the likes are not of her concern. Thus she can keep all the dates with Adam and Bob in the previous example. All dates are set between 6:00 and 22:00 on the same day.
She wants to get the maximum amount of satisfaction in total. Each guy gives her some satisfaction if he has all scheduled dates. Let's say, for example, Adam's satisfaction is 100 and Bob's satisfaction is 200. Then, since she can make it with both guys, she can get 300 in total. Your task is to write a program to satisfy her demand. Then she could spend a few hours with you... if you really want.
Input
The input consists of a sequence of datasets. Each dataset has the following format:
N
Guy1
...
GuyN
The first line of the input contains an integer N (1 ≤ N ≤ 100), the number of guys. Then there come the descriptions of guys. Each description is given in this format:
M L
S1 E1
...
SM EM
The first line contains two integers Mi (1 ≤ Mi ≤ 16) and Li (1 ≤ Li ≤ 100,000,000), the number of dates set for the guy and the satisfaction she would get from him respectively. Then M lines follow. The i-th line contains two integers Si and Ei (6 ≤ Si < Ei ≤ 22), the starting and ending time of the i-th date.
The end of input is indicated by N = 0.
Output
For each dataset, output in a line the maximum amount of satisfaction she can get.
Example
Input
2
2 100
10 12
14 16
2 200
12 13
18 20
4
1 100
6 22
1 1000
6 22
1 10000
6 22
1 100000
6 22
16
1 100000000
6 7
1 100000000
7 8
1 100000000
8 9
1 100000000
9 10
1 100000000
10 11
1 100000000
11 12
1 100000000
12 13
1 100000000
13 14
1 100000000
14 15
1 100000000
15 16
1 100000000
16 17
1 100000000
17 18
1 100000000
18 19
1 100000000
19 20
1 100000000
20 21
1 100000000
21 22
0
Output
300
100000
1600000000
### Response
```cpp
#include <bits/stdc++.h>
//typedef
//-------------------------#include <bits/stdc++.h>
const double pi = 3.141592653589793238462643383279;
using namespace std;
//conversion
//------------------------------------------
inline int toInt(string s)
{
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x)
{
ostringstream sout;
sout << x;
return sout.str();
}
inline int readInt()
{
int x;
scanf("%d", &x);
return x;
}
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a) * (a))
#define EACH(i, c) for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
//repetition
//------------------------------------------
#define FOR(i, s, n) for (int i = s; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define MOD 1000000007
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double EPS = 1E-8;
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
class UnionFind
{
public:
vector<int> par;
vector<int> siz;
UnionFind(int sz_) : par(sz_), siz(sz_, 1)
{
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(int sz_)
{
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
int root(int x)
{
while (par[x] != x)
{
x = par[x] = par[par[x]];
}
return x;
}
bool merge(int x, int y)
{
x = root(x);
y = root(y);
if (x == y)
return false;
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(int x, int y)
{
return root(x) == root(y);
}
int size(int x)
{
return siz[root(x)];
}
};
ll modPow(ll x, ll n, ll mod = MOD)
{
ll res = 1;
while (n)
{
if (n & 1)
res = (res * x) % mod;
res %= mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
#define SIEVE_SIZE 5000000 + 10
bool sieve[SIEVE_SIZE];
void makeSieve()
{
for (int i = 0; i < SIEVE_SIZE; ++i)
sieve[i] = true;
sieve[0] = sieve[1] = false;
for (int i = 2; i * i < SIEVE_SIZE; ++i)
if (sieve[i])
for (int j = 2; i * j < SIEVE_SIZE; ++j)
sieve[i * j] = false;
}
bool isprime(ll n)
{
if (n == 0 || n == 1)
return false;
for (ll i = 2; i * i <= n; ++i)
if (n % i == 0)
return false;
return true;
}
const int MAX = 2000010;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long extGCD(long long a, long long b, long long &x, long long &y)
{
if (b == 0)
{
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
// 負の数にも対応した mod (a = -11 とかでも OK)
inline long long mod(long long a, long long m)
{
return (a % m + m) % m;
}
// 逆元計算 (ここでは a と m が互いに素であることが必要)
long long modinv(long long a, long long m)
{
long long x, y;
extGCD(a, m, x, y);
return mod(x, m); // 気持ち的には x % m だが、x が負かもしれないので
}
ll GCD(ll a, ll b)
{
if (b == 0)
return a;
return GCD(b, a % b);
}
typedef vector<ll> vec;
typedef vector<vec> mat;
mat mul(mat &A, mat &B)
{
mat C(A.size(), vec((int)B[0].size()));
for (int i = 0; i < A.size(); ++i)
{
for (int k = 0; k < B.size(); ++k)
{
for (int j = 0; j < B[0].size(); ++j)
{
C[i][j] = (C[i][j] + A[i][k] % MOD * B[k][j] % MOD) % MOD;
}
}
}
return C;
}
mat matPow(mat A, ll n)
{
mat B(A.size(), vec((int)A.size()));
for (int i = 0; i < A.size(); ++i)
{
B[i][i] = 1;
}
while (n > 0)
{
if (n & 1)
B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
int N;
vector<ll> M(110), L(110);
ll dp[110][(1 << 17)];
vector<int> vp;
ll rec(int idx, int mask)
{
if (mask == (1 << 17) - 1)
{
return 0;
}
if (idx == N)
{
return 0;
}
if (dp[idx][mask] != -1)
return dp[idx][mask];
//cout << idx << " " << mask << " " << vp[idx] << endl;
ll mx = rec(idx + 1, mask);
if ((vp[idx] & mask) == 0)
{
mx = max(mx, rec(idx + 1, (mask | vp[idx])) + L[idx]);
}
return dp[idx][mask] = mx;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(5);
while (cin >> N)
{
if (N == 0)
break;
vp = vector<int>(N);
REP(i, N + 1)
{
REP(j, (1 << 17))
{
dp[i][j] = -1;
}
}
REP(i, N)
{
cin >> M[i] >> L[i];
int mask = 0;
REP(j, M[i])
{
int s, e;
cin >> s >> e;
for (int k = s - 6; k < e - 6; k++)
mask |= (1 << k);
}
vp[i] = mask;
}
cout << rec(0, 0) << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.
But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.
Input
First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.
Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.
Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.
Output
Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.
Examples
Input
5
7 3 5 3 4
2 1 3 2 3
Output
4 7 3 5 3
Input
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Output
2 6 4 5 8 8 6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int b[n], k;
multimap<long long int, long long int> m;
multiset<long long int> m1;
multiset<long long int, greater<long long int>> m2;
for (long long int i = 0; i < n; i++) {
cin >> k;
m2.insert(k);
}
for (long long int i = 0; i < n; i++) {
cin >> b[i];
m1.insert(b[i]);
}
auto j = m2.begin();
for (auto i = m1.begin(); i != m1.end(); i++) {
m.insert({*i, *j});
j++;
}
for (long long int i = 0; i < n; i++) {
auto s = m.find(b[i]);
cout << s->second << " ";
m.erase(s);
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> myMap;
string word;
int k;
cin >> k;
cin >> word;
for (int i = 0; i < word.size(); i++) {
myMap[word[i]]++;
}
bool ok = true;
map<char, int>::iterator iter;
for (iter = myMap.begin(); iter != myMap.end(); iter++) {
if (iter->second % k != 0) {
ok = false;
break;
}
}
string temp = "";
if (ok) {
for (iter = myMap.begin(); iter != myMap.end(); iter++) {
int x = iter->second / k;
for (int i = 0; i < x; i++) temp += iter->first;
}
for (int i = 0; i < k; i++) cout << temp;
} else {
cout << "-1";
}
cout << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
After a probationary period in the game development company of IT City Petya was included in a group of the programmers that develops a new turn-based strategy game resembling the well known "Heroes of Might & Magic". A part of the game is turn-based fights of big squadrons of enemies on infinite fields where every cell is in form of a hexagon.
Some of magic effects are able to affect several field cells at once, cells that are situated not farther than n cells away from the cell in which the effect was applied. The distance between cells is the minimum number of cell border crosses on a path from one cell to another.
It is easy to see that the number of cells affected by a magic effect grows rapidly when n increases, so it can adversely affect the game performance. That's why Petya decided to write a program that can, given n, determine the number of cells that should be repainted after effect application, so that game designers can balance scale of the effects and the game performance. Help him to do it. Find the number of hexagons situated not farther than n cells away from a given cell.
<image>
Input
The only line of the input contains one integer n (0 ≤ n ≤ 109).
Output
Output one integer — the number of hexagons situated not farther than n cells away from a given cell.
Examples
Input
2
Output
19
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << ((n * (n + 1)) * 3) + 1;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Ivan had string s consisting of small English letters. However, his friend Julia decided to make fun of him and hid the string s. Ivan preferred making a new string to finding the old one.
Ivan knows some information about the string s. Namely, he remembers, that string ti occurs in string s at least ki times or more, he also remembers exactly ki positions where the string ti occurs in string s: these positions are xi, 1, xi, 2, ..., xi, ki. He remembers n such strings ti.
You are to reconstruct lexicographically minimal string s such that it fits all the information Ivan remembers. Strings ti and string s consist of small English letters only.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of strings Ivan remembers.
The next n lines contain information about the strings. The i-th of these lines contains non-empty string ti, then positive integer ki, which equal to the number of times the string ti occurs in string s, and then ki distinct positive integers xi, 1, xi, 2, ..., xi, ki in increasing order — positions, in which occurrences of the string ti in the string s start. It is guaranteed that the sum of lengths of strings ti doesn't exceed 106, 1 ≤ xi, j ≤ 106, 1 ≤ ki ≤ 106, and the sum of all ki doesn't exceed 106. The strings ti can coincide.
It is guaranteed that the input data is not self-contradictory, and thus at least one answer always exists.
Output
Print lexicographically minimal string that fits all the information Ivan remembers.
Examples
Input
3
a 4 1 3 5 7
ab 2 1 5
ca 1 4
Output
abacaba
Input
1
a 1 3
Output
aaa
Input
3
ab 1 1
aba 1 3
ab 2 3 5
Output
ababab
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m_end, num, pos, Len;
char s[2000005];
char p[2000005];
int main() {
while (~scanf("%d", &n)) {
Len = 0;
memset(s, '#', sizeof(s));
for (int cnt = 1; cnt <= n; cnt++) {
scanf("%s%d", &p, &num);
int len = strlen(p);
int now = -1;
for (int i = 1; i <= num; i++) {
scanf("%d", &pos);
Len = max(pos + len - 1, Len);
for (int j = max(now, pos); j <= pos + len - 1; j++) s[j] = p[j - pos];
now = pos + len;
}
}
for (int i = 1; i <= Len; i++)
if (s[i] == '#')
putchar('a');
else
putchar(s[i]);
putchar('\n');
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Does \sqrt{a} + \sqrt{b} < \sqrt{c} hold?
Constraints
* 1 \leq a, b, c \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a \ b \ c
Output
If \sqrt{a} + \sqrt{b} < \sqrt{c}, print `Yes`; otherwise, print `No`.
Examples
Input
2 3 9
Output
No
Input
2 3 10
Output
Yes
### Response
```cpp
#include<stdio.h>
int main(void){
long int a,b,c;
scanf("%ld %ld %ld",&a,&b,&c);
if(c>a+b&&4*a*b<(c-a-b)*(c-a-b)){
printf("Yes");
}else{
printf("No");
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Let's define the following recurrence: $$$a_{n+1} = a_{n} + minDigit(a_{n}) ⋅ maxDigit(a_{n}).$$$
Here minDigit(x) and maxDigit(x) are the minimal and maximal digits in the decimal representation of x without leading zeroes. For examples refer to notes.
Your task is calculate a_{K} for given a_{1} and K.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of independent test cases.
Each test case consists of a single line containing two integers a_{1} and K (1 ≤ a_{1} ≤ 10^{18}, 1 ≤ K ≤ 10^{16}) separated by a space.
Output
For each test case print one integer a_{K} on a separate line.
Example
Input
8
1 4
487 1
487 2
487 3
487 4
487 5
487 6
487 7
Output
42
487
519
528
544
564
588
628
Note
a_{1} = 487
a_{2} = a_{1} + minDigit(a_{1}) ⋅ maxDigit(a_{1}) = 487 + min (4, 8, 7) ⋅ max (4, 8, 7) = 487 + 4 ⋅ 8 = 519
a_{3} = a_{2} + minDigit(a_{2}) ⋅ maxDigit(a_{2}) = 519 + min (5, 1, 9) ⋅ max (5, 1, 9) = 519 + 1 ⋅ 9 = 528
a_{4} = a_{3} + minDigit(a_{3}) ⋅ maxDigit(a_{3}) = 528 + min (5, 2, 8) ⋅ max (5, 2, 8) = 528 + 2 ⋅ 8 = 544
a_{5} = a_{4} + minDigit(a_{4}) ⋅ maxDigit(a_{4}) = 544 + min (5, 4, 4) ⋅ max (5, 4, 4) = 544 + 4 ⋅ 5 = 564
a_{6} = a_{5} + minDigit(a_{5}) ⋅ maxDigit(a_{5}) = 564 + min (5, 6, 4) ⋅ max (5, 6, 4) = 564 + 4 ⋅ 6 = 588
a_{7} = a_{6} + minDigit(a_{6}) ⋅ maxDigit(a_{6}) = 588 + min (5, 8, 8) ⋅ max (5, 8, 8) = 588 + 5 ⋅ 8 = 628
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, k, b, m = 10, m1 = 0;
cin >> a >> k;
b = a;
while (k > 1) {
m = 10, m1 = 0;
while (b > 0) {
long long int i = b % 10;
m = min(m, i);
m1 = max(m1, i);
b /= 10;
}
if (m == 0) break;
a += m * m1;
b = a;
k--;
}
cout << a << endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Polygon is not only the best platform for developing problems but also a square matrix with side n, initially filled with the character 0.
On the polygon, military training was held. The soldiers placed a cannon above each cell in the first row and a cannon to the left of each cell in the first column. Thus, exactly 2n cannons were placed.
<image> Initial polygon for n=4.
Cannons shoot character 1. At any moment of time, no more than one cannon is shooting. When a 1 flies out of a cannon, it flies forward (in the direction of the shot) until it collides with a polygon border or another 1. After that, it takes the cell in which it was before the collision and remains there. Take a look at the examples for better understanding.
More formally:
* if a cannon stands in the row i, to the left of the first column, and shoots with a 1, then the 1 starts its flight from the cell (i, 1) and ends in some cell (i, j);
* if a cannon stands in the column j, above the first row, and shoots with a 1, then the 1 starts its flight from the cell (1, j) and ends in some cell (i, j).
For example, consider the following sequence of shots:
<image>
1. Shoot the cannon in the row 2. 2. Shoot the cannon in the row 2. 3. Shoot the cannon in column 3.
You have a report from the military training on your desk. This report is a square matrix with side length n consisting of 0 and 1. You wonder if the training actually happened. In other words, is there a sequence of shots such that, after the training, you get the given matrix?
Each cannon can make an arbitrary number of shots. Before the training, each cell of the polygon contains 0.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
Each test case starts with a line containing an integer n (1 ≤ n ≤ 50) — the size of the polygon.
This is followed by n lines of length n, consisting of 0 and 1 — the polygon matrix after the training.
The total area of the matrices in all test cases in one test does not exceed 10^5.
Output
For each test case print:
* YES if there is a sequence of shots leading to a given matrix;
* NO if such a sequence does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
5
4
0010
0011
0000
0000
2
10
01
2
00
00
4
0101
1111
0101
0111
4
0100
1110
0101
0111
Output
YES
NO
YES
YES
NO
Note
The first test case was explained in the statement.
The answer to the second test case is NO, since a 1 in a cell (1, 1) flying out of any cannon would continue its flight further.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
;
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<string> arr(n);
for (int(i) = 0; (i) < (n); ++(i)) cin >> arr[i];
bool flag = true;
for (int(i) = 0; (i) < (n - 1); ++(i)) {
for (int(j) = 0; (j) < (n - 1); ++(j)) {
if (arr[i][j] == '1') {
if (arr[i + 1][j] == '0' && arr[i][j + 1] == '0') {
flag = false;
}
}
}
}
cout << (flag ? "YES" : "NO") << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Adilbek was assigned to a special project. For Adilbek it means that he has n days to run a special program and provide its results. But there is a problem: the program needs to run for d days to calculate the results.
Fortunately, Adilbek can optimize the program. If he spends x (x is a non-negative integer) days optimizing the program, he will make the program run in \left⌈ (d)/(x + 1) \right⌉ days (\left⌈ a \right⌉ is the ceiling function: \left⌈ 2.4 \right⌉ = 3, \left⌈ 2 \right⌉ = 2). The program cannot be run and optimized simultaneously, so the total number of days he will spend is equal to x + \left⌈ (d)/(x + 1) \right⌉.
Will Adilbek be able to provide the generated results in no more than n days?
Input
The first line contains a single integer T (1 ≤ T ≤ 50) — the number of test cases.
The next T lines contain test cases – one per line. Each line contains two integers n and d (1 ≤ n ≤ 10^9, 1 ≤ d ≤ 10^9) — the number of days before the deadline and the number of days the program runs.
Output
Print T answers — one per test case. For each test case print YES (case insensitive) if Adilbek can fit in n days or NO (case insensitive) otherwise.
Example
Input
3
1 1
4 5
5 11
Output
YES
YES
NO
Note
In the first test case, Adilbek decides not to optimize the program at all, since d ≤ n.
In the second test case, Adilbek can spend 1 day optimizing the program and it will run \left⌈ 5/2 \right⌉ = 3 days. In total, he will spend 4 days and will fit in the limit.
In the third test case, it's impossible to fit in the limit. For example, if Adilbek will optimize the program 2 days, it'll still work \left⌈ (11)/(2+1) \right⌉ = 4 days.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t) {
long long n, d;
cin >> n >> d;
if (d <= n) {
cout << "YES" << endl;
} else {
long long dif = n - d;
long long b = 1 - n;
long long delta = b * b;
long long mini = -1 * (delta) / 4;
if (mini <= dif) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
t--;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
We have a board with a 2 \times N grid. Snuke covered the board with N dominoes without overlaps. Here, a domino can cover a 1 \times 2 or 2 \times 1 square.
Then, Snuke decided to paint these dominoes using three colors: red, cyan and green. Two dominoes that are adjacent by side should be painted by different colors. Here, it is not always necessary to use all three colors.
Find the number of such ways to paint the dominoes, modulo 1000000007.
The arrangement of the dominoes is given to you as two strings S_1 and S_2 in the following manner:
* Each domino is represented by a different English letter (lowercase or uppercase).
* The j-th character in S_i represents the domino that occupies the square at the i-th row from the top and j-th column from the left.
Constraints
* 1 \leq N \leq 52
* |S_1| = |S_2| = N
* S_1 and S_2 consist of lowercase and uppercase English letters.
* S_1 and S_2 represent a valid arrangement of dominoes.
Input
Input is given from Standard Input in the following format:
N
S_1
S_2
Output
Print the number of such ways to paint the dominoes, modulo 1000000007.
Examples
Input
3
aab
ccb
Output
6
Input
1
Z
Z
Output
3
Input
52
RvvttdWIyyPPQFFZZssffEEkkaSSDKqcibbeYrhAljCCGGJppHHn
RLLwwdWIxxNNQUUXXVVMMooBBaggDKqcimmeYrhAljOOTTJuuzzn
Output
958681902
### Response
```cpp
#include<bits/stdc++.h>
#define MOD 1000000007
using namespace std;
int i,n,a[52];
long long x;
string s,t;
int main(){
cin>>n>>s>>t;
if(s[0]==s[1])i=2,x=6;
else i=1,x=3;
for(;i<s.size();){
if(s[i]==s[i+1]){
if(s[i-2]==s[i-1])x=x*3%MOD;
else x=x*2%MOD;
i+=2;
}
else if(s[i-1]==t[i-1])x=x*2%MOD,++i;
else ++i;
}
cout<<x<<endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 ≤ n ≤ 3000, <image>) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n).
Output
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> V[5005];
int d[5005][5005];
int main() {
memset(d, -1, sizeof(d));
int n, m;
scanf("%d %d", &n, &m);
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
u--, v--;
V[u].push_back(v);
V[v].push_back(u);
}
for (int i = 0; i < n; i++) {
queue<int> Q;
Q.push(i);
d[i][i] = 0;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int j = 0; j < V[u].size(); j++) {
v = V[u][j];
if (d[i][v] == -1) {
d[i][v] = d[i][u] + 1;
Q.push(v);
}
}
}
}
int s[2], t[2], l[2];
scanf("%d %d %d", &s[0], &t[0], &l[0]);
scanf("%d %d %d", &s[1], &t[1], &l[1]);
s[0]--, s[1]--, t[0]--, t[1]--;
int ans = m + 1;
for (int itr = 1; itr <= 2; itr++) {
swap(s[0], t[0]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int p[2];
p[0] = d[s[0]][i] + d[i][j] + d[j][t[0]];
p[1] = d[s[1]][i] + d[i][j] + d[j][t[1]];
if (p[0] <= l[0] && p[1] <= l[1]) {
ans = min(ans, p[0] + p[1] - d[i][j]);
}
}
}
}
if (d[s[0]][t[0]] <= l[0] && d[s[1]][t[1]] <= l[1])
ans = min(ans, d[s[0]][t[0]] + d[s[1]][t[1]]);
if (ans > m)
printf("-1\n");
else
printf("%d\n", m - ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Uh oh! Applications to tech companies are due soon, and you've been procrastinating by doing contests instead! (Let's pretend for now that it is actually possible to get a job in these uncertain times.)
You have completed many programming projects. In fact, there are exactly n types of programming projects, and you have completed a_i projects of type i. Your résumé has limited space, but you want to carefully choose them in such a way that maximizes your chances of getting hired.
You want to include several projects of the same type to emphasize your expertise, but you also don't want to include so many that the low-quality projects start slipping in. Specifically, you determine the following quantity to be a good indicator of your chances of getting hired:
$$$ f(b_1,…,b_n)=∑_{i=1}^n b_i(a_i-b_i^2). $$$
Here, b_i denotes the number of projects of type i you include in your résumé. Of course, you cannot include more projects than you have completed, so you require 0≤ b_i ≤ a_i for all i.
Your résumé only has enough room for k projects, and you will absolutely not be hired if your résumé has empty space, so you require ∑_{i=1}^n b_i=k.
Find values for b_1,…, b_n that maximize the value of f(b_1,…,b_n) while satisfying the above two constraints.
Input
The first line contains two integers n and k (1≤ n≤ 10^5, 1≤ k≤ ∑_{i=1}^n a_i) — the number of types of programming projects and the résumé size, respectively.
The next line contains n integers a_1,…,a_n (1≤ a_i≤ 10^9) — a_i is equal to the number of completed projects of type i.
Output
In a single line, output n integers b_1,…, b_n that achieve the maximum value of f(b_1,…,b_n), while satisfying the requirements 0≤ b_i≤ a_i and ∑_{i=1}^n b_i=k. If there are multiple solutions, output any.
Note that you do not have to output the value f(b_1,…,b_n).
Examples
Input
10 32
1 2 3 4 5 5 5 5 5 5
Output
1 2 3 3 3 4 4 4 4 4
Input
5 8
4 4 8 2 1
Output
2 2 2 1 1
Note
For the first test, the optimal answer is f=-269. Note that a larger f value is possible if we ignored the constraint ∑_{i=1}^n b_i=k.
For the second test, the optimal answer is f=9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
long long f(long long a, long long x) { return (a - 3ll * x * x + 3 * x - 1); }
bool checkcalc(long long x, long long a, long long val) {
return (f(a, x) > val);
}
long long calc(long long a, long long val) {
long long hi = a + 10, lo = 0;
long long m;
while (hi - lo > 1) {
m = (lo + hi) / 2;
if (checkcalc(m, a, val))
lo = m;
else
hi = m;
}
if (checkcalc(hi, a, val)) return hi;
return lo;
}
long long n, k;
long long a[N];
long long b[N];
bool check(long long val) {
long long tot = 0;
for (long long i = 0; i < n; ++i) {
b[i] = min(a[i], calc(a[i], val));
tot += b[i];
}
return (tot >= k);
}
void solve() {
cin >> n >> k;
for (long long i = 0; i < n; ++i) cin >> a[i];
long long hi = 2e9, lo = -4e18;
long long m;
while (hi - lo > 1) {
m = (hi + lo) / 2;
if (check(m))
lo = m;
else
hi = m;
}
check(hi);
for (long long i = 0; i < n; ++i) k -= b[i];
vector<pair<long long, long long>> av;
for (long long i = 0; i < n; ++i) {
if (b[i] == a[i]) continue;
long long x = f(a[i], b[i]);
if (x < hi) continue;
av.push_back({f(a[i], b[i] + 1), i});
}
sort(av.begin(), av.end());
reverse(av.begin(), av.end());
for (long long i = 0; i < (long long)av.size() && k > 0; ++i) {
k--;
b[av[i].second]++;
}
assert(k == 0);
for (long long i = 0; i < n; ++i) cout << b[i] << ' ';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows.
There are two armies on the playing field each of which consists of n men (n is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore.
The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends.
You are asked to calculate the maximum total number of soldiers that may be killed during the game.
Input
The input data consist of a single integer n (2 ≤ n ≤ 108, n is even). Please note that before the game starts there are 2n soldiers on the fields.
Output
Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns.
Examples
Input
2
Output
3
Input
4
Output
6
Note
The first sample test:
1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1.
2) Arcady's soldier 2 shoots at Valera's soldier 1.
3) Valera's soldier 1 shoots at Arcady's soldier 2.
There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
printf("%d", n + n / 2);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Patrick has just finished writing a message to his sweetheart Stacey when he noticed that the message didn't look fancy. Patrick was nervous while writing the message, so some of the letters there were lowercase and some of them were uppercase.
Patrick believes that a message is fancy if any uppercase letter stands to the left of any lowercase one. In other words, this rule describes the strings where first go zero or more uppercase letters, and then — zero or more lowercase letters.
To make the message fancy, Patrick can erase some letter and add the same letter in the same place in the opposite case (that is, he can replace an uppercase letter with the lowercase one and vice versa). Patrick got interested in the following question: what minimum number of actions do we need to make a message fancy? Changing a letter's case in the message counts as one action. Patrick cannot perform any other actions.
Input
The only line of the input contains a non-empty string consisting of uppercase and lowercase letters. The string's length does not exceed 105.
Output
Print a single number — the least number of actions needed to make the message fancy.
Examples
Input
PRuvetSTAaYA
Output
5
Input
OYPROSTIYAOPECHATALSYAPRIVETSTASYA
Output
0
Input
helloworld
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int e = 100005;
const long long INF = 1e18 + 5;
template <typename T>
void show2(T &dp) {
for (auto row : dp) {
for (auto col : row) cout << col << " ";
cout << "\n";
}
}
template <typename T>
void show1(T &a) {
for (auto x : a) cout << x << " ";
cout << "\n";
}
void convert(vector<int> &a, string &s) {
int n = s.size();
a[0] = 0;
for (int i = 1; i < n + 1; i++) {
if (s[i - 1] >= 'a')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1];
}
}
void solve() {
string s;
cin >> s;
int n = s.size();
vector<int> a(n + 1);
convert(a, s);
int tlo = a[n];
int tup = n - a[n];
int ans = 1e6 + 1;
for (int i = 0; i < n + 1; i++) {
int lo_left = a[i];
int up_left = i - a[i];
int up_right = tup - up_left;
if (i == 0) {
up_right = tup;
}
ans = min(ans, lo_left + up_right);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
A sequence a_1, a_2, ..., a_n is called good if, for each element a_i, there exists an element a_j (i ≠ j) such that a_i+a_j is a power of two (that is, 2^d for some non-negative integer d).
For example, the following sequences are good:
* [5, 3, 11] (for example, for a_1=5 we can choose a_2=3. Note that their sum is a power of two. Similarly, such an element can be found for a_2 and a_3),
* [1, 1, 1, 1023],
* [7, 39, 89, 25, 89],
* [].
Note that, by definition, an empty sequence (with a length of 0) is good.
For example, the following sequences are not good:
* [16] (for a_1=16, it is impossible to find another element a_j such that their sum is a power of two),
* [4, 16] (for a_1=4, it is impossible to find another element a_j such that their sum is a power of two),
* [1, 3, 2, 8, 8, 8] (for a_3=2, it is impossible to find another element a_j such that their sum is a power of two).
You are given a sequence a_1, a_2, ..., a_n. What is the minimum number of elements you need to remove to make it good? You can delete an arbitrary set of elements.
Input
The first line contains the integer n (1 ≤ n ≤ 120000) — the length of the given sequence.
The second line contains the sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
Output
Print the minimum number of elements needed to be removed from the given sequence in order to make it good. It is possible that you need to delete all n elements, make it empty, and thus get a good sequence.
Examples
Input
6
4 7 1 5 4 9
Output
1
Input
5
1 2 3 4 5
Output
2
Input
1
16
Output
1
Input
4
1 1 1 1023
Output
0
Note
In the first example, it is enough to delete one element a_4=5. The remaining elements form the sequence [4, 7, 1, 4, 9], which is good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
map<int, int> mp;
set<int> s;
int cnt, t, n, arr[120000 + 5], m, store[50];
inline long long fast_pow(int index) {
if (store[index]) return store[index];
long long base = 2, ans = 1, t = index;
while (index) {
if (index & 1) ans *= base;
base *= base;
index /= 2;
}
return store[t] = ans;
}
int main(void) {
n = read();
for (int i = 1; i <= n; i++) {
arr[i] = t = read();
mp[t]++;
}
sort(arr + 1, arr + 1 + n);
m = unique(arr + 1, arr + 1 + n) - arr - 1;
for (int i = 1; i <= m; i++) {
if (s.find(arr[i]) != s.end()) continue;
bool flag = true;
for (int index = 0, k = 0; k <= arr[m]; index++) {
k = fast_pow(index) - arr[i];
if (mp.find(k) != mp.end() && (k != arr[i] || mp[k] >= 2)) {
flag = false;
s.insert(arr[i]);
s.insert(k);
break;
}
}
if (flag) {
cnt += mp[arr[i]];
mp.erase(arr[i]);
}
}
cout << cnt << endl;
return 0;
}
``` |
Subsets and Splits