text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a Cpp code solution to the problem outlined:
As Gerald, Alexander, Sergey and Gennady are already busy with the usual New Year chores, Edward hastily decorates the New Year Tree. And any decent New Year Tree must be decorated with a good garland. Edward has lamps of m colors and he wants to make a garland from them. That garland should represent a sequence whose length equals L. Edward's tree is n layers high and Edward plans to hang the garland so as to decorate the first layer with the first l1 lamps, the second layer — with the next l2 lamps and so on. The last n-th layer should be decorated with the last ln lamps, <image>
Edward adores all sorts of math puzzles, so he suddenly wondered: how many different ways to assemble the garland are there given that the both following two conditions are met:
1. Any two lamps that follow consecutively in the same layer should have different colors.
2. The sets of used colors in every two neighbouring layers must be different. We consider unordered sets (not multisets), where every color occurs no more than once. So the number of lamps of particular color does not matter.
Help Edward find the answer to this nagging problem or else he won't manage to decorate the Tree by New Year. You may consider that Edward has an unlimited number of lamps of each of m colors and it is not obligatory to use all m colors. The garlands are considered different if they differ in at least one position when represented as sequences. Calculate the answer modulo p.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 106, 2 ≤ p ≤ 109) which are the number of the tree's layers, the number of the lamps' colors and module correspondingly. The next line contains n integers li (1 ≤ li ≤ 5000, <image>).
Output
Print the only integer — the number of garlands modulo p.
Examples
Input
3 2 1000
3 1 2
Output
8
Input
2 3 1000
2 2
Output
24
Input
1 1 1000
5
Output
0
Note
In the first sample the following variants are possible: 121|1|12, 121|1|21, 121|2|12, 121|2|21, 212|1|12, 212|1|21, 212|2|12, 212|2|21. In the second sample the following variants are possible: 12|13, 12|23, 12|31, 12|32 and so on.
Figure for the first sample: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T read_value(string s) {
T result;
istringstream sin(s);
sin >> result;
return result;
}
string read_line() {
string ret_val;
getline(std::cin, ret_val);
return ret_val;
}
template <class T>
void init_array(T *arr, int size, T value) {
for (int i = 0; i < size; i++) arr[i] = value;
}
template <class T>
inline T gcd(T a, T b) {
return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
a %= p;
return (a < 0) ? a + p : a;
}
template <class T>
inline int numbits(T n) {
return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
a = mod<T>(a, m);
return (a == 1) ? 1 : mod((1 - m * inverse(m % a, a)) / a, m);
}
template <class T>
inline bool is_prime(T a) {
T lim = (T)sqrt((double)a);
for (T i = 2; i <= T(lim + 1E-9); i++)
if (a % i == 0) return false;
return true;
}
template <class T>
inline T power(T a, T p, T mod) {
if (!p) return 1;
T temp = power(a, p >> 1, mod);
temp = (temp * temp) % mod;
if (p & 1) temp = (temp * a) % mod;
return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
bool *p = new bool[end + 1];
init_array<bool>(p, end + 1, 0);
p[1] = 1;
for (int i = 2; i <= end; i++) {
if (!p[i]) {
if (i >= start) vi.push_back(i);
for (int j = 2 * i; j <= end; j += i) p[j] = 1;
}
}
delete[] p;
}
bool dfs(int current, int final, int total, vector<int> &visited,
vector<vector<bool> > &edges, bool flow) {
if (current == final) return true;
if (visited[current]) return false;
visited[current] = true;
for (int i = 0; i < total; i++)
if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
if (flow) {
edges[current][i] = false;
edges[i][current] = true;
}
return true;
}
return false;
}
int flow(int in, int out, int total, vector<vector<bool> > &edges) {
int result = 0;
for (vector<int> visited(total, 0); dfs(in, out, total, visited, edges, true);
++result)
visited = vector<int>(total, 0);
return result;
}
void create_set(int x, int *P, int *rank) {
P[x] = x;
rank[x] = 0;
}
int find_set(int x, int *P) {
if (x != P[x]) P[x] = find_set(P[x], P);
return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
int Px = find_set(x, P);
int Py = find_set(y, P);
if (Px == Py) return false;
if (rank[Px] > rank[Py])
P[Py] = Px;
else
P[Px] = Py;
if (rank[Px] == rank[Py]) rank[Py]++;
return true;
}
template <typename T>
int read_cum_freq(int index, T *tree) {
int sum = 0;
while (index) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
template <typename T>
void upd_freq(int index, int mxIndex, int value, T *tree) {
while (index <= mxIndex) {
tree[index] += value;
index += (index & -index);
}
}
template <typename T>
int read_freq(int index, T *tree) {
return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
temp_arr[0] = temp_arr[1] = 0;
for (int i = 2; i <= ((int)(str).size()); i++) {
temp_arr[i] = -1;
for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
if (str[ind] == str[i - 1]) {
temp_arr[i] = ind + 1;
} else if (ind == 0) {
temp_arr[i] = 0;
}
}
}
}
void KMP(const string &text, const string &pattern, int *res) {
int *temp_arr = new int[((int)(pattern).size()) + 1];
build_failure_function(pattern, temp_arr);
int i = 0;
int ind = 0;
while (i < ((int)(text).size())) {
if (text[i] == pattern[ind]) {
res[i] = ++ind;
if (res[i] == ((int)(pattern).size())) {
ind = temp_arr[ind];
}
i++;
} else if (ind == 0) {
res[i++] = 0;
} else {
ind = temp_arr[ind];
}
}
delete[] temp_arr;
}
template <typename T, int N>
struct matrix {
T m[N][N];
T md;
matrix(T md, bool unary = false) {
this->md = md;
memset(m, 0, sizeof(m));
if (unary) {
for (int i = 0; i < N; i++) {
m[i][i] = 1;
}
}
}
matrix operator*(const matrix &that) const {
matrix ret_val(md, false);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
ret_val.m[i][j] += this->m[i][k] * that.m[k][j];
ret_val.m[i][j] %= md;
}
}
}
return ret_val;
}
vector<T> operator*(const vector<T> &vec) const {
vector<T> ret_val(vec.size(), 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
ret_val[i] += m[i][j] * vec[j];
ret_val[i] %= md;
}
}
return ret_val;
}
matrix power(int pw) const {
if (!pw) return matrix(md, true);
if (pw == 1) return *this;
matrix ret_val = power(pw >> 1);
ret_val = ret_val * ret_val;
if (pw & 1) ret_val = ret_val * (*this);
return ret_val;
}
};
void setup(int value, string name) {
string name_in = name + ".in";
string name_out = name + ".out";
freopen(name_in.c_str(), "r", stdin);
if (value) freopen(name_out.c_str(), "w", stdout);
}
int C[5001];
int dp[5001][5001];
void eval_c(long long m, long long p) {
vector<long long> vi;
memset(C, 0, sizeof(C));
C[0] = 1;
for (int i = 1; i <= min(5000, (int)m); ++i) {
vi.push_back(m - i + 1);
long long val = i;
for (int j = 0; val != 1; ++j) {
long long g = gcd(vi[j], val);
vi[j] /= g;
val /= g;
}
long long res = 1;
for (int j = 0; j < vi.size(); ++j) {
res *= vi[j];
res %= p;
}
C[i] = (int)res;
}
}
void eval_dp(long long p) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= 5000; ++i) {
for (int j = 1; j <= i; ++j) {
dp[j][i] = (int)(((long long)dp[j - 1][i - 1] * (long long)j +
(long long)dp[j][i - 1] * (long long)(j - 1)) %
p);
}
}
}
void run() {
int n, m, p;
std::cin >> n >> m >> p;
eval_c(m, p);
eval_dp(p);
vector<long long> vi1, vi2;
vi1.push_back(1);
for (int i = 0; i < n; ++i) {
int len;
scanf("%d", &len);
long long total = accumulate(vi1.begin(), vi1.end(), 0LL) % p;
for (int j = 0; j <= len; ++j) {
long long cc1 = C[j];
long long cc2 = dp[j][len];
long long prev = (j < vi1.size()) ? vi1[j] : 0;
vi2.push_back((((cc1 * cc2) % p) * total) % p);
vi2[j] = (p - ((cc2 * prev) % p) + vi2[j]) % p;
}
vi1.swap(vi2);
vi2.resize(0);
}
std::cout << (accumulate(vi1.begin(), vi1.end(), 0LL) % p) << std::endl;
}
int main() {
run();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The height of the student was measured at the medical examination. Create a program that takes height data as input, creates a frequency distribution, and outputs it. The frequency distribution is divided into 6 classes in 5 cm increments, and the number of people is indicated by * (half-width asterisk). However, if the frequency (number of people) of that class is 0, output only the class heading.
Input
The input is given in the following format:
n
h1
h2
::
hn
The number of students n (1 ≤ n ≤ 40) is given to the first line, and the real number hi (150.0 ≤ hi ≤ 190.0, up to the first decimal place) representing the height of the i-th person is given to each line after the second line. ..
Output
Display the frequency distribution in the following format.
Line 1 Heading "1:" followed by * for people less than 165.0 cm *
2nd line Heading "2:" followed by people 165.0 cm or more and less than 170.0 cm *
3rd line Heading "3:" followed by the number of people from 170.0 cm or more to less than 175.0 cm *
4th line Heading "4:" followed by the number of people from 175.0 cm to less than 180.0 cm *
Line 5 Heading "5:" followed by the number of people between 180.0 cm and 185.0 cm *
Line 6 Heading "6:" followed by * for people over 185.0 cm *
Examples
Input
4
180.3
168.2
165.5
175.3
Output
1:
2:**
3:
4:*
5:*
6:
Input
21
179.4
171.5
156.6
173.0
169.4
181.2
172.4
170.0
163.6
165.9
173.5
168.2
162.5
172.0
175.1
172.3
167.5
175.9
186.2
168.0
178.6
Output
1:***
2:*****
3:*******
4:****
5:*
6:*
### Response
```cpp
#include<iostream>
#include<cstring>
using namespace std;
int main()
{
int n;
cin>>n;
int c[6];
memset(c,0,sizeof(c));
for(;n--;)
{
double t;
cin>>t;
int i=0;
for(double l=185.0;l>164.9;l-=5.0,i++)
{
if(l<=t)
{
c[i]++;
i=-1;
break;
}
}
if(i!=-1)
c[5]++;
}
for(int i=5;i>=0;i--)
{
cout<<6-i<<":";
for(;c[i]--;)
cout<<"*";
cout<<endl;
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
It is the middle of 2018 and Maria Stepanovna, who lives outside Krasnokamensk (a town in Zabaikalsky region), wants to rent three displays to highlight an important problem.
There are n displays placed along a road, and the i-th of them can display a text with font size s_i only. Maria Stepanovna wants to rent such three displays with indices i < j < k that the font size increases if you move along the road in a particular direction. Namely, the condition s_i < s_j < s_k should be held.
The rent cost is for the i-th display is c_i. Please determine the smallest cost Maria Stepanovna should pay.
Input
The first line contains a single integer n (3 ≤ n ≤ 3 000) — the number of displays.
The second line contains n integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^9) — the font sizes on the displays in the order they stand along the road.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^8) — the rent costs for each display.
Output
If there are no three displays that satisfy the criteria, print -1. Otherwise print a single integer — the minimum total rent cost of three displays with indices i < j < k such that s_i < s_j < s_k.
Examples
Input
5
2 4 5 4 10
40 30 20 10 40
Output
90
Input
3
100 101 100
2 4 5
Output
-1
Input
10
1 2 3 4 5 6 7 8 9 10
10 13 11 14 15 12 13 13 18 13
Output
33
Note
In the first example you can, for example, choose displays 1, 4 and 5, because s_1 < s_4 < s_5 (2 < 4 < 10), and the rent cost is 40 + 10 + 40 = 90.
In the second example you can't select a valid triple of indices, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int compare(string S, string y) {
if (S.size() != y.size())
return 0;
else {
int i;
for (i = 0; i < S.size(); i++) {
if (S[i] != y[i]) return 0;
}
}
return 1;
}
int main() {
long int temp = INT_MAX;
long int min = INT_MAX;
long int n;
cin >> n;
long int A[n];
long int B[n];
int i, j, k;
for (i = 0; i < n; i++) cin >> A[i];
for (i = 0; i < n; i++) cin >> B[i];
long long int ans[n];
int flag = 0;
for (i = 1; i < n; i++) {
ans[i] = B[i];
temp = INT_MAX;
for (j = 0; j < i; j++) {
if (B[j] < temp && A[j] < A[i]) {
temp = B[j];
flag = 1;
}
}
ans[i] = ans[i] + temp;
}
if (flag == 0) {
cout << "-1\n";
return 0;
}
flag = 0;
for (i = 1; i < n - 1; i++) {
temp = INT_MAX;
for (j = i + 1; j < n; j++) {
if (B[j] < temp && A[j] > A[i]) {
flag = 1;
temp = B[j];
}
}
ans[i] = ans[i] + temp;
if (ans[i] < min) min = ans[i];
}
if (flag == 0) {
cout << "-1\n";
return 0;
}
cout << min << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Gosha is hunting. His goal is to catch as many Pokemons as possible. Gosha has a Poke Balls and b Ultra Balls. There are n Pokemons. They are numbered 1 through n. Gosha knows that if he throws a Poke Ball at the i-th Pokemon he catches it with probability pi. If he throws an Ultra Ball at the i-th Pokemon he catches it with probability ui. He can throw at most one Ball of each type at any Pokemon.
The hunting proceeds as follows: at first, Gosha chooses no more than a Pokemons at which he will throw Poke Balls and no more than b Pokemons at which he will throw Ultra Balls. After that, he throws the chosen Balls at the chosen Pokemons. If he throws both Ultra Ball and Poke Ball at some Pokemon, he is caught if and only if he is caught by any of these Balls. The outcome of a throw doesn't depend on the other throws.
Gosha would like to know what is the expected number of the Pokemons he catches if he acts in an optimal way. In other words, he would like to know the maximum possible expected number of Pokemons can catch.
Input
The first line contains three integers n, a and b (2 ≤ n ≤ 2000, 0 ≤ a, b ≤ n) — the number of Pokemons, the number of Poke Balls and the number of Ultra Balls.
The second line contains n real values p1, p2, ..., pn (0 ≤ pi ≤ 1), where pi is the probability of catching the i-th Pokemon if Gosha throws a Poke Ball to it.
The third line contains n real values u1, u2, ..., un (0 ≤ ui ≤ 1), where ui is the probability of catching the i-th Pokemon if Gosha throws an Ultra Ball to it.
All the probabilities are given with exactly three digits after the decimal separator.
Output
Print the maximum possible expected number of Pokemons Gosha can catch. The answer is considered correct if it's absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 2 2
1.000 0.000 0.500
0.000 1.000 0.500
Output
2.75
Input
4 1 3
0.100 0.500 0.500 0.600
0.100 0.500 0.900 0.400
Output
2.16
Input
3 2 0
0.412 0.198 0.599
0.612 0.987 0.443
Output
1.011
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2048;
float d[N][N];
double A[N];
double B[N];
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; (i) < (n); ++i) scanf("%lf", &A[i]);
for (int i = 0; (i) < (n); ++i) scanf("%lf", &B[i]);
for (int i = 0; (i) < (n); ++i) {
float aa = A[i];
float bb = B[i];
float cc = A[i] + B[i] - A[i] * B[i];
int mxa = min(a, i);
int mxb = min(b, i);
int mna = max(0, a - n + i);
int mnb = max(0, b - n + i);
for (int j = mxa; j >= mna; --j)
for (int k = mxb; k >= mnb; --k) {
d[j + 1][k] = max(d[j + 1][k], d[j][k] + aa);
d[j][k + 1] = max(d[j][k + 1], d[j][k] + bb);
d[j + 1][k + 1] = max(d[j + 1][k + 1], d[j][k] + cc);
}
}
printf("%.10f\n", (double)d[a][b]);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Polycarp often uses his smartphone. He has already installed n applications on it. Application with number i takes up a_i units of memory.
Polycarp wants to free at least m units of memory (by removing some applications).
Of course, some applications are more important to Polycarp than others. He came up with the following scoring system — he assigned an integer b_i to each application:
* b_i = 1 — regular application;
* b_i = 2 — important application.
According to this rating system, his phone has b_1 + b_2 + … + b_n convenience points.
Polycarp believes that if he removes applications with numbers i_1, i_2, …, i_k, then he will free a_{i_1} + a_{i_2} + … + a_{i_k} units of memory and lose b_{i_1} + b_{i_2} + … + b_{i_k} convenience points.
For example, if n=5, m=7, a=[5, 3, 2, 1, 4], b=[2, 1, 1, 2, 1], then Polycarp can uninstall the following application sets (not all options are listed below):
* applications with numbers 1, 4 and 5. In this case, it will free a_1+a_4+a_5=10 units of memory and lose b_1+b_4+b_5=5 convenience points;
* applications with numbers 1 and 3. In this case, it will free a_1+a_3=7 units of memory and lose b_1+b_3=3 convenience points.
* applications with numbers 2 and 5. In this case, it will free a_2+a_5=7 memory units and lose b_2+b_5=2 convenience points.
Help Polycarp, choose a set of applications, such that if removing them will free at least m units of memory and lose the minimum number of convenience points, or indicate that such a set does not exist.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 10^9) — the number of applications on Polycarp's phone and the number of memory units to be freed.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of memory units used by applications.
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 2) — the convenience points of each application.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line:
* -1, if there is no set of applications, removing which will free at least m units of memory;
* the minimum number of convenience points that Polycarp will lose if such a set exists.
Example
Input
5
5 7
5 3 2 1 4
2 1 1 2 1
1 3
2
1
5 10
2 3 2 3 2
1 2 1 2 1
4 10
5 1 3 4
1 2 1 2
4 5
3 2 1 2
2 1 2 1
Output
2
-1
6
4
3
Note
In the first test case, it is optimal to remove applications with numbers 2 and 5, freeing 7 units of memory. b_2+b_5=2.
In the second test case, by removing the only application, Polycarp will be able to clear only 2 of memory units out of the 3 needed.
In the third test case, it is optimal to remove applications with numbers 1, 2, 3 and 4, freeing 10 units of memory. b_1+b_2+b_3+b_4=6.
In the fourth test case, it is optimal to remove applications with numbers 1, 3 and 4, freeing 12 units of memory. b_1+b_3+b_4=4.
In the fifth test case, it is optimal to remove applications with numbers 1 and 2, freeing 5 units of memory. b_1+b_2=3.
### Response
```cpp
//
// main.cpp
//
//
// Created by ji luyang on 2020/12/22.
//
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <time.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
int t;
int n, m;
int a[200010], b[200010];
int main() {
cin >> t;
while (t--) {
cin >> n >> m;
vector<int> v1, v2;
long long s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
if (b[i] == 1) v1.push_back(a[i]), s1 += a[i];
else v2.push_back(a[i]), s2 += a[i];
}
sort(v1.begin(), v1.end(), greater<int>());
sort(v2.begin(), v2.end(), greater<int>());
int p2 = v2.size() - 1, p1 = -1, res = INT_MAX;
if (s1 + s2 < m) {
printf("-1\n");
continue;
}
long long tmp = s2;
while (p2 >= -1) {
while (tmp < m) {
p1++;
if (p1 == v1.size()) break;
tmp += v1[p1];
}
if (p1 == v1.size()) break;
res = min(res, p1 + 1 + 2 * (p2 + 1));
if (p2 == -1) break;
tmp -= v2[p2];
p2--;
}
printf("%d\n", res);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are n cities in Cyberland, numbered from 1 to n, connected by m bidirectional roads. The j-th road connects city aj and bj.
For tourists, souvenirs are sold in every city of Cyberland. In particular, city i sell it at a price of wi.
Now there are q queries for you to handle. There are two types of queries:
* "C a w": The price in city a is changed to w.
* "A a b": Now a tourist will travel from city a to b. He will choose a route, he also doesn't want to visit a city twice. He will buy souvenirs at the city where the souvenirs are the cheapest (possibly exactly at city a or b). You should output the minimum possible price that he can buy the souvenirs during his travel.
More formally, we can define routes as follow:
* A route is a sequence of cities [x1, x2, ..., xk], where k is a certain positive integer.
* For any 1 ≤ i < j ≤ k, xi ≠ xj.
* For any 1 ≤ i < k, there is a road connecting xi and xi + 1.
* The minimum price of the route is min(wx1, wx2, ..., wxk).
* The required answer is the minimum value of the minimum prices of all valid routes from a to b.
Input
The first line of input contains three integers n, m, q (1 ≤ n, m, q ≤ 105), separated by a single space.
Next n lines contain integers wi (1 ≤ wi ≤ 109).
Next m lines contain pairs of space-separated integers aj and bj (1 ≤ aj, bj ≤ n, aj ≠ bj).
It is guaranteed that there is at most one road connecting the same pair of cities. There is always at least one valid route between any two cities.
Next q lines each describe a query. The format is "C a w" or "A a b" (1 ≤ a, b ≤ n, 1 ≤ w ≤ 109).
Output
For each query of type "A", output the corresponding answer.
Examples
Input
3 3 3
1
2
3
1 2
2 3
1 3
A 2 3
C 1 5
A 2 3
Output
1
2
Input
7 9 4
1
2
3
4
5
6
7
1 2
2 5
1 5
2 3
3 4
2 4
5 6
6 7
5 7
A 2 3
A 6 4
A 6 7
A 3 3
Output
2
1
5
3
Note
For the second sample, an optimal routes are:
From 2 to 3 it is [2, 3].
From 6 to 4 it is [6, 5, 1, 2, 4].
From 6 to 7 it is [6, 5, 7].
From 3 to 3 it is [3].
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200005;
inline int read() {
char c;
int rec = 0;
while ((c = getchar()) < '0' || c > '9')
;
while (c >= '0' && c <= '9') rec = rec * 10 + c - '0', c = getchar();
return rec;
}
int n, m, Q, val[Maxn];
struct Graph {
struct Branch {
int next, to;
} branch[Maxn << 1];
int h[Maxn], cnt;
inline void add(int x, int y) {
branch[++cnt].to = y;
branch[cnt].next = h[x];
h[x] = cnt;
return;
}
} G, T;
int Bcc, dfn[Maxn], low[Maxn], idx, S[Maxn], Top;
void Tarjan(int v) {
dfn[v] = low[v] = ++idx;
S[++Top] = v;
for (int i = G.h[v]; i; i = G.branch[i].next) {
if (!dfn[G.branch[i].to]) {
Tarjan(G.branch[i].to);
low[v] = min(low[v], low[G.branch[i].to]);
if (low[G.branch[i].to] >= dfn[v]) {
int p = 0;
++Bcc;
T.add(Bcc, v);
T.add(v, Bcc);
while (p != G.branch[i].to) {
p = S[Top--];
T.add(Bcc, p);
T.add(p, Bcc);
}
}
} else
low[v] = min(low[v], dfn[G.branch[i].to]);
}
return;
}
multiset<int> U[Maxn];
int D, Minn[Maxn << 3];
int size[Maxn << 1], deep[Maxn << 1];
int top[Maxn << 1], fa[Maxn << 1], son[Maxn << 1];
int id[Maxn << 1], ind;
void Dfs1(int v) {
size[v] = 1;
deep[v] = deep[fa[v]] + 1;
if (v <= n && fa[v]) U[fa[v] - n].insert(val[v]);
for (int i = T.h[v]; i; i = T.branch[i].next) {
if (T.branch[i].to == fa[v]) continue;
fa[T.branch[i].to] = v;
Dfs1(T.branch[i].to);
size[v] += size[T.branch[i].to];
if (size[son[v]] < size[T.branch[i].to]) son[v] = T.branch[i].to;
}
return;
}
void Dfs2(int v, int TOP) {
top[v] = TOP;
id[v] = ++ind;
if (son[v]) Dfs2(son[v], TOP);
for (int i = T.h[v]; i; i = T.branch[i].next)
if (T.branch[i].to != fa[v] && T.branch[i].to != son[v])
Dfs2(T.branch[i].to, T.branch[i].to);
return;
}
inline int Ask(int L, int R) {
int rec = 0x3f3f3f3f;
for (int s = L + D - 1, t = R + D + 1; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1) rec = min(rec, Minn[s ^ 1]);
if (t & 1) rec = min(rec, Minn[t ^ 1]);
}
return rec;
}
int main() {
n = read();
m = read();
Q = read();
for (int i = 1; i <= n; ++i) val[i] = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
G.add(x, y);
G.add(y, x);
}
char ch;
Bcc = n;
Tarjan(1);
Dfs1(1);
Dfs2(1, 1);
D = 1;
while (D <= Bcc) D <<= 1;
memset(Minn, 0x3f, sizeof(Minn));
for (int i = 1; i <= n; ++i) Minn[D + id[i]] = val[i];
for (int i = n + 1; i <= Bcc; ++i) Minn[D + id[i]] = *U[i - n].begin();
for (int i = D; i; --i) Minn[i] = min(Minn[i << 1], Minn[i << 1 | 1]);
for (int i = 1; i <= Q; ++i) {
while ((ch = getchar()) != 'A' && ch != 'C')
;
int x = read(), y = read();
if (ch == 'A') {
int Ans = 0x3f3f3f3f;
while (top[x] != top[y]) {
if (deep[top[x]] < deep[top[y]]) swap(x, y);
Ans = min(Ans, Ask(id[top[x]], id[x]));
x = fa[top[x]];
}
if (deep[x] < deep[y]) swap(x, y);
Ans = min(Ans, Ask(id[y], id[x]));
if (y > n) Ans = min(Ans, val[fa[y]]);
cout << Ans << '\n';
} else {
int p = fa[x];
if (p) {
U[p - n].erase(U[p - n].find(val[x]));
U[p - n].insert(y);
int v = id[p] + D;
Minn[v] = *U[p - n].begin();
v >>= 1;
while (v) Minn[v] = min(Minn[v << 1], Minn[v << 1 | 1]), v >>= 1;
}
val[x] = y;
int v = id[x] + D;
Minn[v] = y;
v >>= 1;
while (v) Minn[v] = min(Minn[v << 1], Minn[v << 1 | 1]), v >>= 1;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Alfred wants to buy a toy moose that costs c dollars. The store doesn’t give change, so he must give the store exactly c dollars, no more and no less. He has n coins. To make c dollars from his coins, he follows the following algorithm: let S be the set of coins being used. S is initially empty. Alfred repeatedly adds to S the highest-valued coin he has such that the total value of the coins in S after adding the coin doesn’t exceed c. If there is no such coin, and the value of the coins in S is still less than c, he gives up and goes home. Note that Alfred never removes a coin from S after adding it.
As a programmer, you might be aware that Alfred’s algorithm can fail even when there is a set of coins with value exactly c. For example, if Alfred has one coin worth $3, one coin worth $4, and two coins worth $5, and the moose costs $12, then Alfred will add both of the $5 coins to S and then give up, since adding any other coin would cause the value of the coins in S to exceed $12. Of course, Alfred could instead combine one $3 coin, one $4 coin, and one $5 coin to reach the total.
Bob tried to convince Alfred that his algorithm was flawed, but Alfred didn’t believe him. Now Bob wants to give Alfred some coins (in addition to those that Alfred already has) such that Alfred’s algorithm fails. Bob can give Alfred any number of coins of any denomination (subject to the constraint that each coin must be worth a positive integer number of dollars). There can be multiple coins of a single denomination. He would like to minimize the total value of the coins he gives Alfred. Please find this minimum value. If there is no solution, print "Greed is good". You can assume that the answer, if it exists, is positive. In other words, Alfred's algorithm will work if Bob doesn't give him any coins.
Input
The first line contains c (1 ≤ c ≤ 200 000) — the price Alfred wants to pay. The second line contains n (1 ≤ n ≤ 200 000) — the number of coins Alfred initially has. Then n lines follow, each containing a single integer x (1 ≤ x ≤ c) representing the value of one of Alfred's coins.
Output
If there is a solution, print the minimum possible total value of the coins in a solution. Otherwise, print "Greed is good" (without quotes).
Examples
Input
12
3
5
3
4
Output
5
Input
50
8
1
2
4
8
16
37
37
37
Output
Greed is good
Note
In the first sample, Bob should give Alfred a single coin worth $5. This creates the situation described in the problem statement.
In the second sample, there is no set of coins that will cause Alfred's algorithm to fail.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, arr[300100], c, big[300100];
int cnt[300100];
vector<pair<int, int> > vec;
bool check(int nw) {
vector<pair<int, int> > used;
int x = c, ind = (int)vec.size() - 1;
while (x > 0) {
ind = min(ind, big[x]);
while (ind >= 0 && (vec[ind].first > x || vec[ind].second == 0)) {
ind--;
}
if (nw > x) {
if (ind < 0) return 1;
int tmp = min(vec[ind].second, x / vec[ind].first);
x -= tmp * vec[ind].first;
used.push_back(make_pair(ind, tmp));
vec[ind].second -= tmp;
} else {
if (ind == -1 || (nw >= vec[ind].first)) {
x -= nw;
nw = c + 1;
} else {
if (ind < 0) return 1;
int tmp = min(vec[ind].second, x / vec[ind].first);
x -= tmp * vec[ind].first;
used.push_back(make_pair(ind, tmp));
vec[ind].second -= tmp;
}
}
}
for (int i = 0; i < used.size(); i++) {
vec[used[i].first].second += used[i].second;
}
return 0;
}
int main() {
scanf("%d\n%d", &c, &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
cnt[arr[i]]++;
}
for (int i = 0; i < c + 1; i++) {
if (cnt[i]) vec.push_back(make_pair(i, cnt[i]));
big[i] = (int)vec.size() - 1;
}
for (int i = 1; i < c; i++) {
if (check(i)) {
cout << i << endl;
return 0;
}
}
cout << "Greed is good\n";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Takahashi received otoshidama (New Year's money gifts) from N of his relatives.
You are given N values x_1, x_2, ..., x_N and N strings u_1, u_2, ..., u_N as input. Each string u_i is either `JPY` or `BTC`, and x_i and u_i represent the content of the otoshidama from the i-th relative.
For example, if x_1 = `10000` and u_1 = `JPY`, the otoshidama from the first relative is 10000 Japanese yen; if x_2 = `0.10000000` and u_2 = `BTC`, the otoshidama from the second relative is 0.1 bitcoins.
If we convert the bitcoins into yen at the rate of 380000.0 JPY per 1.0 BTC, how much are the gifts worth in total?
Constraints
* 2 \leq N \leq 10
* u_i = `JPY` or `BTC`.
* If u_i = `JPY`, x_i is an integer such that 1 \leq x_i \leq 10^8.
* If u_i = `BTC`, x_i is a decimal with 8 decimal digits, such that 0.00000001 \leq x_i \leq 100.00000000.
Input
Input is given from Standard Input in the following format:
N
x_1 u_1
x_2 u_2
:
x_N u_N
Output
If the gifts are worth Y yen in total, print the value Y (not necessarily an integer).
Output will be judged correct when the absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
10000 JPY
0.10000000 BTC
Output
48000.0
Input
3
100000000 JPY
100.00000000 BTC
0.00000001 BTC
Output
138000000.0038
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;cin>>n;double ans=0;
for(int i=0;i<n;i++){
double x;string y;cin>>x>>y;
if(y=="JPY") ans+=x;
else ans+=x*380000.0;
}
cout<<ans<<endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Input
The input contains two integers N, M (1 ≤ N ≤ 1024, 2 ≤ M ≤ 16), separated by a single space.
Output
Output "YES" or "NO".
Examples
Input
2 3
Output
YES
Input
3 2
Output
NO
Input
33 16
Output
YES
Input
26 5
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[25];
void f (int n, int k) {
int p;
if (n == 0) return;
f(n / k, k);
p = n % k;
a[p]++;
// cout << p << ' ';
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
f(n, k);
for (int i = 0; i <= 16; i++) {
if (a[i] >= 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
One day Om Nom found a thread with n beads of different colors. He decided to cut the first several beads from this thread to make a bead necklace and present it to his girlfriend Om Nelly.
<image>
Om Nom knows that his girlfriend loves beautiful patterns. That's why he wants the beads on the necklace to form a regular pattern. A sequence of beads S is regular if it can be represented as S = A + B + A + B + A + ... + A + B + A, where A and B are some bead sequences, " + " is the concatenation of sequences, there are exactly 2k + 1 summands in this sum, among which there are k + 1 "A" summands and k "B" summands that follow in alternating order. Om Nelly knows that her friend is an eager mathematician, so she doesn't mind if A or B is an empty sequence.
Help Om Nom determine in which ways he can cut off the first several beads from the found thread (at least one; probably, all) so that they form a regular pattern. When Om Nom cuts off the beads, he doesn't change their order.
Input
The first line contains two integers n, k (1 ≤ n, k ≤ 1 000 000) — the number of beads on the thread that Om Nom found and number k from the definition of the regular sequence above.
The second line contains the sequence of n lowercase Latin letters that represent the colors of the beads. Each color corresponds to a single letter.
Output
Print a string consisting of n zeroes and ones. Position i (1 ≤ i ≤ n) must contain either number one if the first i beads on the thread form a regular sequence, or a zero otherwise.
Examples
Input
7 2
bcabcab
Output
0000011
Input
21 2
ababaababaababaababaa
Output
000110000111111000011
Note
In the first sample test a regular sequence is both a sequence of the first 6 beads (we can take A = "", B = "bca"), and a sequence of the first 7 beads (we can take A = "b", B = "ca").
In the second sample test, for example, a sequence of the first 13 beads is regular, if we take A = "aba", B = "ba".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int n, k;
char s[1000005];
int z[1000005];
char ans[1000005];
int qzh[1000005];
void calcz() {
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
if (i <= r) {
z[i] = min(r - i, z[i - l]);
}
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
z[i]++;
}
if (i + z[i] > r) {
l = i;
r = i + z[i];
}
}
}
int main() {
fio >> n >> k >> s;
calcz();
ans[n] = 0;
if (k == 1) {
memset((void*)ans, '1', sizeof(ans));
ans[n] = 0;
fio << ans << '\n';
return 0;
}
for (int i = 1; i * k <= n; i++) {
if (z[i] < i * (k - 1)) {
continue;
}
qzh[i * k]++;
qzh[min(i + z[i], i * (k + 1)) + 1]--;
}
int he = 0;
for (int i = 1; i <= n; i++) {
he += qzh[i];
ans[i - 1] = '0' + (he > 0);
}
fio << ans << '\n';
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Takahashi, who lives on the number line, is now at coordinate X. He will make exactly K moves of distance D in the positive or negative direction.
More specifically, in one move, he can go from coordinate x to x + D or x - D.
He wants to make K moves so that the absolute value of the coordinate of the destination will be the smallest possible.
Find the minimum possible absolute value of the coordinate of the destination.
Constraints
* -10^{15} \leq X \leq 10^{15}
* 1 \leq K \leq 10^{15}
* 1 \leq D \leq 10^{15}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X K D
Output
Print the minimum possible absolute value of the coordinate of the destination.
Examples
Input
6 2 4
Output
2
Input
7 4 3
Output
1
Input
10 1 2
Output
8
Input
1000000000000000 1000000000000000 1000000000000000
Output
1000000000000000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ll x,k,d;
cin >> x >> k >> d;
x = abs(x);
ll t= 0;
t = min(x/d,k);
x -= t*d;
k -= t;
if(k==0)
{
cout<<x<<endl;
return 0;
}
k%=2;
if(k)cout<<abs(x-d)<<endl;
else cout<<x<<endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n psychos standing in a line. Each psycho is assigned a unique integer from 1 to n. At each step every psycho who has an id greater than the psycho to his right (if exists) kills his right neighbor in the line. Note that a psycho might kill and get killed at the same step.
You're given the initial arrangement of the psychos in the line. Calculate how many steps are needed to the moment of time such, that nobody kills his neighbor after that moment. Look notes to understand the statement more precise.
Input
The first line of input contains integer n denoting the number of psychos, (1 ≤ n ≤ 105). In the second line there will be a list of n space separated distinct integers each in range 1 to n, inclusive — ids of the psychos in the line from left to right.
Output
Print the number of steps, so that the line remains the same afterward.
Examples
Input
10
10 9 7 8 6 5 3 4 2 1
Output
2
Input
6
1 2 3 4 5 6
Output
0
Note
In the first sample line of the psychos transforms as follows: [10 9 7 8 6 5 3 4 2 1] → [10 8 4] → [10]. So, there are two steps.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int inf = 0x3f3f3f3f;
int arr[maxn];
int ans[maxn];
stack<int> s;
int main() {
int n;
scanf("%d", &n);
memset(ans, 0, sizeof ans);
for (int i = 1; i <= n; ++i) scanf("%d", &arr[i]);
for (int i = n; i >= 1; --i) {
if (s.empty()) {
s.push(i);
ans[i] = 0;
continue;
}
if (arr[s.top()] > arr[i]) {
ans[i] = 0;
s.push(i);
} else {
ans[i] = max(1, ans[s.top()]);
s.pop();
while (s.size() && arr[i] > arr[s.top()]) {
ans[i] = max(ans[i] + 1, ans[s.top()]);
s.pop();
}
s.push(i);
}
}
int val = 0;
for (int i = 1; i <= n; ++i) {
val = max(val, ans[i]);
}
printf("%d\n", val);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Friday is Polycarpus' favourite day of the week. Not because it is followed by the weekend, but because the lessons on Friday are 2 IT lessons, 2 math lessons and 2 literature lessons. Of course, Polycarpus has prepared to all of them, unlike his buddy Innocentius. Innocentius spent all evening playing his favourite game Fur2 and didn't have enough time to do the literature task. As Innocentius didn't want to get an F, he decided to do the task and read the book called "Storm and Calm" during the IT and Math lessons (he never used to have problems with these subjects). When the IT teacher Mr. Watkins saw this, he decided to give Innocentius another task so that the boy concentrated more on the lesson and less — on the staff that has nothing to do with IT.
Mr. Watkins said that a palindrome is a string that can be read the same way in either direction, from the left to the right and from the right to the left. A concatenation of strings a, b is a string ab that results from consecutive adding of string b to string a. Of course, Innocentius knew it all but the task was much harder than he could have imagined. Mr. Watkins asked change in the "Storm and Calm" the minimum number of characters so that the text of the book would also be a concatenation of no more than k palindromes. Innocentius can't complete the task and therefore asks you to help him.
Input
The first input line contains a non-empty string s which is the text of "Storm and Calm" (without spaces). The length of the string s does not exceed 500 characters. String s consists of uppercase and lowercase Latin letters. The second line contains a single number k (1 ≤ k ≤ |s|, where |s| represents the length of the string s).
Output
Print on the first line the minimum number of changes that Innocentius will have to make. Print on the second line the string consisting of no more than k palindromes. Each palindrome should be non-empty and consist of uppercase and lowercase Latin letters. Use the character "+" (ASCII-code 43) to separate consecutive palindromes. If there exist several solutions, print any of them.
The letters' case does matter, that is an uppercase letter is not considered equivalent to the corresponding lowercase letter.
Examples
Input
abacaba
1
Output
0
abacaba
Input
abdcaba
2
Output
1
abdcdba
Input
abdcaba
5
Output
0
a+b+d+c+aba
Input
abacababababbcbabcd
3
Output
1
abacaba+babab+bcbabcb
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char str[505];
int cnt, len;
int Pmat[505][505];
void relax(int l, int r) {
int tmp = 0;
while (l >= 0 && r < len) {
if (str[l] != str[r]) {
tmp++;
}
Pmat[l][r] = tmp;
l--, r++;
}
}
const int inf = 505;
int memo[inf][inf];
int solve(int st, int ed, int rem) {
if (ed >= len - 1) return 0;
if (rem <= 0) return inf;
int &ret = memo[ed][rem];
if (ret != -1) return ret;
ret = inf;
for (int i = ed + 1; i < len; i++) {
ret = min(ret, solve(ed + 1, i, rem - 1) + Pmat[ed + 1][i]);
}
return ret;
}
string res = "";
void Build(int st, int ed, int rem) {
string s = "";
for (int k = st; k <= ed; k++) {
s += str[k];
}
for (int i = 0; i < s.size(); i++)
if (s[i] != s[s.size() - i - 1]) s[i] = s[s.size() - 1 - i];
res += s + "+";
for (int i = ed + 1; i < len; i++) {
if (solve(ed + 1, i, rem - 1) + Pmat[ed + 1][i] == solve(st, ed, rem)) {
Build(ed + 1, i, rem - 1);
return;
}
}
}
int main() {
scanf("%s", str);
scanf("%d", &cnt);
len = strlen(str);
for (int pos = 0; pos < len; pos++) {
relax(pos, pos);
relax(pos - 1, pos);
relax(pos, pos + 1);
}
memset(memo, -1, sizeof memo);
int ans = inf;
cnt--;
for (int i = 0; i < len; i++) {
ans = min(ans, solve(0, i, cnt) + Pmat[0][i]);
}
for (int i = 0; i < len; i++) {
if (ans == solve(0, i, cnt) + Pmat[0][i]) {
Build(0, i, cnt);
break;
}
}
cout << ans << endl;
res.erase(res.begin() + res.size() - 1);
cout << res << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = (2 * n) % 7, y = (n - 4 * x) / 7;
if (y < 0) {
cout << "-1";
return 0;
}
while (1) {
if (x > 0) {
cout << "4";
x--;
} else if (y > 0) {
cout << "7";
y--;
} else
break;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The HR manager was disappointed again. The last applicant failed the interview the same way as 24 previous ones. "Do I give such a hard task?" — the HR manager thought. "Just raise number 5 to the power of n and get last two digits of the number. Yes, of course, n can be rather big, and one cannot find the power using a calculator, but we need people who are able to think, not just follow the instructions."
Could you pass the interview in the machine vision company in IT City?
Input
The only line of the input contains a single integer n (2 ≤ n ≤ 2·1018) — the power in which you need to raise number 5.
Output
Output the last two digits of 5n without spaces between them.
Examples
Input
2
Output
25
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << 25;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Let s(x) be sum of digits in decimal representation of positive integer x. Given two integers n and m, find some positive integers a and b such that
* s(a) ≥ n,
* s(b) ≥ n,
* s(a + b) ≤ m.
Input
The only line of input contain two integers n and m (1 ≤ n, m ≤ 1129).
Output
Print two lines, one for decimal representation of a and one for decimal representation of b. Both numbers must not contain leading zeros and must have length no more than 2230.
Examples
Input
6 5
Output
6
7
Input
8 16
Output
35
53
Note
In the first sample, we have n = 6 and m = 5. One valid solution is a = 6, b = 7. Indeed, we have s(a) = 6 ≥ n and s(b) = 7 ≥ n, and also s(a + b) = s(13) = 4 ≤ m.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, n, m;
cin >> n >> m;
for (i = 1; i <= 200; i++) {
cout << "8";
}
for (i = 1; i <= 200; i++) {
cout << "0";
}
cout << "9"
<< "\n";
for (i = 1; i <= 200; i++) {
cout << "1";
}
for (i = 1; i <= 200; i++) {
cout << "9";
}
cout << "1"
<< "\n";
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
This problem's actual name, "Lexicographically Largest Palindromic Subsequence" is too long to fit into the page headline.
You are given string s consisting of lowercase English letters only. Find its lexicographically largest palindromic subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk (1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|, where |s| is the length of string s. For example, strings "abcb", "b" and "abacaba" are subsequences of string "abacaba".
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y| if either |x| > |y| and x1 = y1, x2 = y2, ..., x|y| = y|y|, or there exists such number r (r < |x|, r < |y|) that x1 = y1, x2 = y2, ..., xr = yr and xr + 1 > yr + 1. Characters in the strings are compared according to their ASCII codes. For example, string "ranger" is lexicographically larger than string "racecar" and string "poster" is lexicographically larger than string "post".
String s = s1s2... s|s| is a palindrome if it matches string rev(s) = s|s|s|s| - 1... s1. In other words, a string is a palindrome if it reads the same way from left to right and from right to left. For example, palindromic strings are "racecar", "refer" and "z".
Input
The only input line contains a non-empty string s consisting of lowercase English letters only. Its length does not exceed 10.
Output
Print the lexicographically largest palindromic subsequence of string s.
Examples
Input
radar
Output
rr
Input
bowwowwow
Output
wwwww
Input
codeforces
Output
s
Input
mississipp
Output
ssss
Note
Among all distinct subsequences of string "radar" the following ones are palindromes: "a", "d", "r", "aa", "rr", "ada", "rar", "rdr", "raar" and "radar". The lexicographically largest of them is "rr".
### Response
```cpp
#include <bits/stdc++.h>
std::string str, ans, cur;
int len;
std::string mask(std::string str, int m) {
std::string ret;
for (int i = 0; i < str.length(); ++i) {
if (m & (1 << i)) {
ret += str[i];
}
}
return ret;
}
bool poli(std::string cur) {
int l = cur.length();
for (int i = 0; i < l / 2; ++i) {
if (cur[i] != cur[l - i - 1]) return false;
}
return true;
}
bool more(std::string first, std::string second) {
std::string::iterator f_it = first.begin(), s_it = second.begin();
for (; f_it != first.end() && s_it != second.end(); ++f_it, ++s_it) {
if (*f_it != *s_it) return *f_it > *s_it;
}
return (f_it != first.end());
}
int main() {
std::cin >> str;
for (int m = 1; m < (1 << str.length()); ++m) {
cur = mask(str, m);
if (poli(cur) && more(cur, ans)) {
ans = cur;
}
}
std::cout << ans << std::endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int bitx[32], bity[32], bitk[32];
long long dp[32][2][2][2], dp1[32][2][2][2], f[32];
pair<long long, long long> dfs(int pos, int limit1, int limit2, int limit3) {
if (pos == 0) return make_pair(1, 0);
if (dp[pos][limit1][limit2][limit3] != -1)
return make_pair(dp[pos][limit1][limit2][limit3],
dp1[pos][limit1][limit2][limit3]);
int x = limit1 ? bitx[pos] : 1;
int y = limit2 ? bity[pos] : 1;
long long ret = 0;
long long ret1 = 0;
for (int i = 0; i <= x; ++i) {
for (int j = 0; j <= y; ++j) {
if (limit3 && (i ^ j) > bitk[pos]) continue;
pair<long long, long long> t =
dfs(pos - 1, limit1 && (i == x), limit2 && (j == y),
limit3 && ((i ^ j) == bitk[pos]));
(ret += t.first) %= mod;
(ret1 += t.second + ((i ^ j) ? f[pos - 1] : 0) * t.first % mod) %= mod;
}
}
dp[pos][limit1][limit2][limit3] = ret,
dp1[pos][limit1][limit2][limit3] = ret1;
return make_pair(ret, ret1);
}
long long solve(long long x, long long y, long long k) {
memset(dp, -1, sizeof(dp));
if (x < 0 || y < 0) return 0;
memset(bitx, 0, sizeof(bitx));
memset(bity, 0, sizeof(bity));
memset(bitk, 0, sizeof(bitk));
int lenx = 0;
while (x) {
bitx[++lenx] = x & 1;
x >>= 1;
}
int leny = 0;
while (y) {
bity[++leny] = y & 1;
y >>= 1;
}
int lenk = 0;
while (k) {
bitk[++lenk] = k & 1;
k >>= 1;
}
pair<long long, long long> t = dfs(31, 1, 1, 1);
return (t.first + t.second) % mod;
}
int main() {
f[0] = 1;
for (int i = 1; i < 31; ++i) f[i] = f[i - 1] * 2 % mod;
int T, x1, y1, x2, y2, k;
scanf("%d", &T);
memset(dp, -1, sizeof(dp));
while (T--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--;
y1--;
x2--;
y2--;
k--;
printf("%I64d\n", ((solve(x2, y2, k) - solve(x1 - 1, y2, k) -
solve(x2, y1 - 1, k) + solve(x1 - 1, y1 - 1, k)) %
mod +
mod) %
mod);
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
To make it difficult to withdraw money, a certain bank allows its customers to withdraw only one of the following amounts in one operation:
* 1 yen (the currency of Japan)
* 6 yen, 6^2(=36) yen, 6^3(=216) yen, ...
* 9 yen, 9^2(=81) yen, 9^3(=729) yen, ...
At least how many operations are required to withdraw exactly N yen in total?
It is not allowed to re-deposit the money you withdrew.
Constraints
* 1 \leq N \leq 100000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
If at least x operations are required to withdraw exactly N yen in total, print x.
Examples
Input
127
Output
4
Input
3
Output
3
Input
44852
Output
16
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int bank (int n) {
if (n<6)
return n;
else if (n<9)
return bank(n-6) + 1;
else {
int n6=1, n9=1;
while (n>=n6*6) {
n6 *= 6;
}
while (n>=n9*9) {
n9 *= 9;
}
return min(bank(n-n6),bank(n-n9))+1;
}
}
int main() {
int n;
cin >> n;
cout << bank(n) << endl;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
A string is called a KEYENCE string when it can be changed to `keyence` by removing its contiguous substring (possibly empty) only once.
Given a string S consisting of lowercase English letters, determine if S is a KEYENCE string.
Constraints
* The length of S is between 7 and 100 (inclusive).
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If S is a KEYENCE string, print `YES`; otherwise, print `NO`.
Examples
Input
keyofscience
Output
YES
Input
mpyszsbznf
Output
NO
Input
ashlfyha
Output
NO
Input
keyence
Output
YES
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s,t="keyence";
cin>>s;
for(int i=0;i<=7;i++){
string a=t.substr(0,i),b=t.substr(i,7-i);
if(a==s.substr(0,i)&&b==s.substr(s.size()-(7-i),7-i)){
cout<<"YES";
return 0;
}
}
cout<<"NO";
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Many students live in a dormitory. A dormitory is a whole new world of funny amusements and possibilities but it does have its drawbacks.
There is only one shower and there are multiple students who wish to have a shower in the morning. That's why every morning there is a line of five people in front of the dormitory shower door. As soon as the shower opens, the first person from the line enters the shower. After a while the first person leaves the shower and the next person enters the shower. The process continues until everybody in the line has a shower.
Having a shower takes some time, so the students in the line talk as they wait. At each moment of time the students talk in pairs: the (2i - 1)-th man in the line (for the current moment) talks with the (2i)-th one.
Let's look at this process in more detail. Let's number the people from 1 to 5. Let's assume that the line initially looks as 23154 (person number 2 stands at the beginning of the line). Then, before the shower opens, 2 talks with 3, 1 talks with 5, 4 doesn't talk with anyone. Then 2 enters the shower. While 2 has a shower, 3 and 1 talk, 5 and 4 talk too. Then, 3 enters the shower. While 3 has a shower, 1 and 5 talk, 4 doesn't talk to anyone. Then 1 enters the shower and while he is there, 5 and 4 talk. Then 5 enters the shower, and then 4 enters the shower.
We know that if students i and j talk, then the i-th student's happiness increases by gij and the j-th student's happiness increases by gji. Your task is to find such initial order of students in the line that the total happiness of all students will be maximum in the end. Please note that some pair of students may have a talk several times. In the example above students 1 and 5 talk while they wait for the shower to open and while 3 has a shower.
Input
The input consists of five lines, each line contains five space-separated integers: the j-th number in the i-th line shows gij (0 ≤ gij ≤ 105). It is guaranteed that gii = 0 for all i.
Assume that the students are numbered from 1 to 5.
Output
Print a single integer — the maximum possible total happiness of the students.
Examples
Input
0 0 0 0 9
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
7 0 0 0 0
Output
32
Input
0 43 21 18 2
3 0 21 11 65
5 2 0 1 4
54 62 12 0 99
87 64 81 33 0
Output
620
Note
In the first sample, the optimal arrangement of the line is 23154. In this case, the total happiness equals:
(g23 + g32 + g15 + g51) + (g13 + g31 + g54 + g45) + (g15 + g51) + (g54 + g45) = 32.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 1;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
void solve() {
int a[5][5];
int ans = 0;
int arr[5];
for (int i = 0; i < 5; i++) arr[i] = i;
int val = -1;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) cin >> a[i][j];
do {
ans = 0;
ans += a[arr[0]][arr[1]] + a[arr[1]][arr[0]] + a[arr[1]][arr[2]] +
a[arr[2]][arr[1]] +
2 * (a[arr[2]][arr[3]] + a[arr[3]][arr[2]] + a[arr[3]][arr[4]] +
a[arr[4]][arr[3]]);
if (ans > val) val = ans;
} while (next_permutation(arr, arr + 5));
cout << val << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc = 1;
solve();
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The full exploration sister is a very talented woman. Your sister can easily count the number of routes in a grid pattern if it is in the thousands. You and your exploration sister are now in a room lined with hexagonal tiles. The older sister seems to be very excited about the hexagon she sees for the first time. The older sister, who is unfamiliar with expressing the arrangement of hexagons in coordinates, represented the room in the coordinate system shown in Fig. 1.
<image> Figure 1
You want to move from one point on this coordinate system to another. But every minute your sister tells you the direction you want to move. Your usual sister will instruct you to move so that you don't go through locations with the same coordinates. However, an older sister who is unfamiliar with this coordinate system corresponds to the remainder of | x × y × t | (x: x coordinate, y: y coordinate, t: elapsed time [minutes] from the first instruction) divided by 6. Simply indicate the direction (corresponding to the number shown in the figure) and it will guide you in a completely random direction.
<image> Figure 2
If you don't want to hurt your sister, you want to reach your destination while observing your sister's instructions as much as possible. You are allowed to do the following seven actions.
* Move 1 tile to direction 0
* Move 1 tile to direction 1
* Move 1 tile in direction 2
* Move 1 tile in direction 3
* Move 1 tile in direction 4
* Move 1 tile in direction 5
* Stay on the spot
You always do one of these actions immediately after your sister gives instructions. The room is furnished and cannot be moved into the tiles where the furniture is placed. Also, movements where the absolute value of the y coordinate exceeds ly or the absolute value of the x coordinate exceeds lx are not allowed. However, the older sister may instruct such a move. Ignoring instructions means moving in a different direction than your sister indicated, or staying there. Output the minimum number of times you should ignore the instructions to get to your destination. Output -1 if it is not possible to reach your destination.
Constraints
* All inputs are integers
* -lx ≤ sx, gx ≤ lx
* -ly ≤ sy, gy ≤ ly
* (sx, sy) ≠ (gx, gy)
* (xi, yi) ≠ (sx, sy) (1 ≤ i ≤ n)
* (xi, yi) ≠ (gx, gy) (1 ≤ i ≤ n)
* (xi, yi) ≠ (xj, yj) (i ≠ j)
* 0 ≤ n ≤ 1000
* -lx ≤ xi ≤ lx (1 ≤ i ≤ n)
* -ly ≤ yi ≤ ly (1 ≤ i ≤ n)
* 0 <lx, ly ≤ 100
Input
The input is given in the following format.
> sx sy gx gy
> n
> x1 y1
> ...
> xi yi
> ...
> xn yn
> lx ly
>
here,
* sx, sy are the coordinates of the starting point
* gx, gy are the coordinates of the destination
* n is the number of furniture placed in the room
* xi, yi are the coordinates of the tile with furniture
* lx, ly are the upper limits of the absolute values of the movable X and Y coordinates.
Output
Output in one line containing one integer. If you can reach your destination, print the number of times you ignore the minimum instructions. Output -1 if it is not possible to reach your destination.
Examples
Input
0 0 0 2
0
2 2
Output
0
Input
0 0 0 2
6
0 1
1 0
1 -1
0 -1
-1 -1
-1 0
2 2
Output
-1
Input
0 0 0 2
1
0 1
2 2
Output
1
### Response
```cpp
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAX_H 5000
#define MAX_N 300
#define MAX_M 150
short dx1[7] = { 0,1,1,0,-1,-1,0 };
short dy1[7] = { 1,0,-1,-1,-1,0,0 };
short dx2[7] = { 0,1,1,0,-1,-1,0 };
short dy2[7] = { 1,1,0,-1,0,1,0 };
short dp[2][MAX_N + 1][MAX_N + 1], n, sx, sy, gx, gy, x, y, lx, ly;
short X[MAX_N + 1][MAX_N + 1], minx = (1 << 14);
int main() {
cin >> sx >> sy >> gx >> gy;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
X[x + MAX_M][y + MAX_M] = 1;
}
cin >> lx >> ly;
for (int i = 0; i <= MAX_N; i++) {
for (int j = 0; j <= MAX_N; j++) {
if (abs(i - MAX_M) > lx || abs(j - MAX_M)>ly) {
X[i][j] = 1;
}
}
}
memset(dp, 127, sizeof(dp));
dp[0][sx + MAX_M][sy + MAX_M] = 0;
for (int i = 0; i < MAX_H; i++) {
for (int j = 0; j < MAX_N; j++) {
for (int k = 0; k < MAX_N; k++) {
dp[(i + 1) % 2][j][k] = (1 << 14);
}
}
for (int j = 0; j <= MAX_N; j++) {
for (int k = 0; k <= MAX_N; k++) {
if (dp[i % 2][j][k] < (1 << 14)) {
int t = abs(i*(j - MAX_M)*(k - MAX_M)) % 6;
if (abs(j - MAX_M) % 2 == 0) {
for (int l = 0; l < 7; l++) {
if (l == t) {
if (X[j + dx1[l]][k + dy1[l]] == 0) {
dp[(i + 1) % 2][j + dx1[l]][k + dy1[l]] = min(dp[(i + 1) % 2][j + dx1[l]][k + dy1[l]], dp[i % 2][j][k]);
}
}
else {
if (X[j + dx1[l]][k + dy1[l]] == 0) {
dp[(i + 1) % 2][j + dx1[l]][k + dy1[l]] = min(dp[(i + 1) % 2][j + dx1[l]][k + dy1[l]], (short)(dp[i % 2][j][k] + 1));
}
}
}
}
if (abs(j - MAX_M) % 2 == 1) {
for (int l = 0; l < 7; l++) {
if (l == t) {
if (X[j + dx2[l]][k + dy2[l]] == 0) {
dp[(i + 1) % 2][j + dx2[l]][k + dy2[l]] = min(dp[(i + 1) % 2][j + dx2[l]][k + dy2[l]], dp[i % 2][j][k]);
}
}
else {
if (X[j + dx2[l]][k + dy2[l]] == 0) {
dp[(i + 1) % 2][j + dx2[l]][k + dy2[l]] = min(dp[(i + 1) % 2][j + dx2[l]][k + dy2[l]], (short)(dp[i % 2][j][k] + 1));
}
}
}
}
}
}
}
minx = min(minx, min(dp[0][gx + MAX_M][gy + MAX_M], dp[1][gx + MAX_M][gy + MAX_M]));
}
if (minx == (1 << 14)) { cout << "-1" << endl; }
else { cout << minx << endl; }
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Today, the memorable AtCoder Beginner Contest 100 takes place. On this occasion, Takahashi would like to give an integer to Ringo.
As the name of the contest is AtCoder Beginner Contest 100, Ringo would be happy if he is given a positive integer that can be divided by 100 exactly D times.
Find the N-th smallest integer that would make Ringo happy.
Constraints
* D is 0, 1 or 2.
* N is an integer between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
D N
Output
Print the N-th smallest integer that can be divided by 100 exactly D times.
Examples
Input
0 5
Output
5
Input
1 11
Output
1100
Input
2 85
Output
850000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std ;
int main () {
int D , N ;
cin >> D >> N ;
cout<<N+(N==100)<<string(D*2,'0');
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given two squares, one with sides parallel to the coordinate axes, and another one with sides at 45 degrees to the coordinate axes. Find whether the two squares intersect.
The interior of the square is considered to be part of the square, i.e. if one square is completely inside another, they intersect. If the two squares only share one common point, they are also considered to intersect.
Input
The input data consists of two lines, one for each square, both containing 4 pairs of integers. Each pair represents coordinates of one vertex of the square. Coordinates within each line are either in clockwise or counterclockwise order.
The first line contains the coordinates of the square with sides parallel to the coordinate axes, the second line contains the coordinates of the square at 45 degrees.
All the values are integer and between -100 and 100.
Output
Print "Yes" if squares intersect, otherwise print "No".
You can print each letter in any case (upper or lower).
Examples
Input
0 0 6 0 6 6 0 6
1 3 3 5 5 3 3 1
Output
YES
Input
0 0 6 0 6 6 0 6
7 3 9 5 11 3 9 1
Output
NO
Input
6 0 6 6 0 6 0 0
7 4 4 7 7 10 10 7
Output
YES
Note
In the first example the second square lies entirely within the first square, so they do intersect.
In the second sample squares do not have any points in common.
Here are images corresponding to the samples:
<image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
set<long long int> s1, s2;
vector<long long int> v1, v2;
bool ans = false;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int x[5], y[5], a[4], b[4], c[4], d[4];
x[4] = 0;
y[4] = 0;
for (int i = 0; i < 4; i++) {
cin >> x[i] >> y[i];
s1.insert(x[i]);
s2.insert(y[i]);
x[4] += x[i];
y[4] += y[i];
}
x[4] /= 4;
y[4] /= 4;
for (auto it1 : s1) {
v1.push_back(it1);
}
for (auto it1 : s2) {
v2.push_back(it1);
}
for (int i = 0; i < 4; i++) {
cin >> a[i] >> b[i];
if (a[i] >= v1[0] && a[i] <= v1[1]) {
if (b[i] >= v2[0] && b[i] <= v2[1]) {
ans = true;
}
}
}
if (!ans) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 4; j++) {
c[j] = (a[(j + 1) % 4] - a[j]) * (y[i] - b[j]) -
(b[(j + 1) % 4] - b[j]) * (x[i] - a[j]);
}
bool ch = true;
for (int j = 0; j < 4; j++) {
x[i] = a[(j + 2) % 4];
y[i] = b[(j + 2) % 4];
d[j] = (a[(j + 1) % 4] - a[j]) * (y[i] - b[j]) -
(b[(j + 1) % 4] - b[j]) * (x[i] - a[j]);
c[j] *= d[j];
if (c[j] < 0) ch = false;
}
if (ch) ans = true;
}
}
if (ans)
cout << "YES";
else
cout << "NO";
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room n × m meters. Each square meter of the room is either occupied by some furniture, or free. A bargaining table is rectangular, and should be placed so, that its sides are parallel to the office walls. Bob doesn't want to change or rearrange anything, that's why all the squares that will be occupied by the table should be initially free. Bob wants the new table to sit as many people as possible, thus its perimeter should be maximal. Help Bob find out the maximum possible perimeter of a bargaining table for his office.
Input
The first line contains 2 space-separated numbers n and m (1 ≤ n, m ≤ 25) — the office room dimensions. Then there follow n lines with m characters 0 or 1 each. 0 stands for a free square meter of the office room. 1 stands for an occupied square meter. It's guaranteed that at least one square meter in the room is free.
Output
Output one number — the maximum possible perimeter of a bargaining table for Bob's office room.
Examples
Input
3 3
000
010
000
Output
8
Input
5 4
1100
0000
0000
0000
0000
Output
16
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int n, m, a[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
a[i][j] = (c == '1') ? 1 : 0;
}
int res = 0;
for (int hi = 0; hi < n; ++hi) {
for (int hj = n - 1; hj >= hi; --hj) {
for (int wi = 0; wi <= m; ++wi) {
for (int wj = m - 1; wj >= wi; --wj) {
int ok = 1;
for (int i = hi; i <= hj; ++i) {
for (int j = wi; j <= wj; ++j) {
if (a[i][j]) {
ok = 0;
break;
}
}
if (!ok) break;
}
if (ok) {
res = max(res, (hj - hi + 1) * 2 + (wj - wi + 1) * 2);
}
}
}
}
}
cout << res << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
In this problem you have to build tournament graph, consisting of n vertices, such, that for any oriented pair of vertices (v, u) (v ≠ u) there exists a path from vertex v to vertex u consisting of no more then two edges.
A directed graph without self-loops is a tournament, if there is exactly one edge between any two distinct vertices (in one out of two possible directions).
Input
The first line contains an integer n (3 ≤ n ≤ 1000), the number of the graph's vertices.
Output
Print -1 if there is no graph, satisfying the described conditions.
Otherwise, print n lines with n integers in each. The numbers should be separated with spaces. That is adjacency matrix a of the found tournament. Consider the graph vertices to be numbered with integers from 1 to n. Then av, u = 0, if there is no edge from v to u, and av, u = 1 if there is one.
As the output graph has to be a tournament, following equalities must be satisfied:
* av, u + au, v = 1 for each v, u (1 ≤ v, u ≤ n; v ≠ u);
* av, v = 0 for each v (1 ≤ v ≤ n).
Examples
Input
3
Output
0 1 0
0 0 1
1 0 0
Input
4
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int e[1000][1000];
int main() {
cin >> n;
if (n == 4) {
puts("-1");
return 0;
}
int m = n - (n & 1 ^ 1);
for (int i = 0; i < m; ++i)
for (int j = 1; j * 2 < m; ++j) e[i][(i + j) % m] = 1;
if (m < n) {
for (int i = 0; i < m; ++i) (i % 2 ? e[i][n - 1] : e[n - 1][i]) = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%d ", e[i][j]);
puts("");
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 ≤ n ≤ 200 000, 0 ≤ s_x, s_y ≤ 10^{9}) — the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^{9}) — the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c — the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y — the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
char num[maxn];
char num2[maxn];
vector<int> vec;
queue<int> que;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
int n = read(), sx = read(), sy = read();
int s1 = 0, s2 = 0, s3 = 0, s4 = 0;
int u = 0, d = 0, l = 0, r = 0;
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x < sx) {
if (y < sy) {
s2++;
s4++;
} else if (y > sy) {
s2++;
s3++;
} else if (y == sy) {
d++;
}
} else if (x > sx) {
if (y < sy) {
s1++;
s4++;
} else if (y > sy) {
s1++;
s3++;
} else {
u++;
}
} else if (x == sx) {
if (y < sy) {
l++;
} else if (y > sy) {
r++;
} else {
continue;
}
}
}
int num1 = s1 + u;
int num2 = s3 + r;
int num3 = s2 + d;
int num4 = s4 + l;
if (num1 >= num2 && num1 > num3 && num1 >= num4) {
printf("%d\n", num1);
printf("%d %d\n", sx + 1, sy);
} else if (num2 >= num1 && num2 > num3 && num2 >= num4) {
cout << num2 << endl;
printf("%d %d\n", sx, sy + 1);
} else if (num3 >= num2 && num3 > num1 && num3 >= num4) {
cout << num3 << endl;
printf("%d %d\n", sx - 1, sy);
} else if (num4 >= num2 && num4 > num3 && num4 >= num1) {
cout << num4 << endl;
printf("%d %d\n", sx, sy - 1);
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
problem
Given the sequence $ A $ of length $ N $. The $ i $ item in $ A $ is $ A_i $. You can do the following for this sequence:
* $ 1 \ leq i \ leq N --Choose the integer i that is 1 $. Swap the value of $ A_i $ with the value of $ A_ {i + 1} $.
Find the minimum number of operations required to make $ A $ a sequence of bumps.
A sequence of length $ N $ that satisfies the following conditions is defined as a sequence of irregularities.
* For any $ i $ that satisfies $ 1 <i <N $, $ A_ {i + 1}, A_ {i --1}> A_i $ or $ A_ {i + 1}, A_ {i --1} <A_i Satisfy $.
Intuitively, increase, decrease, increase ... (decrease, like $ 1, \ 10, \ 2, \ 30, \ \ dots (10, \ 1, \ 30, \ 2, \ \ dots) $ It is a sequence that repeats increase, decrease ...).
output
Output the minimum number of operations required to make a sequence of bumps. Also, output a line break at the end.
Example
Input
5
1 2 3 4 5
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
int n;
int a[125252];
int main(){
scanf("%d",&n);
int ans = 0;
REP(i,n)scanf("%d",a+i);
REP(i,n-2){
int x = a[i];
int y = a[i+1];
int z = a[i+2];
if((x<y&&y>z) || (x>y&&y<z))continue;
if(i+2==n-1){
swap(a[i+1], a[i+2]);
ans++;
continue;
}
int w = a[i+3];
if(x>y && y>z){
x *= -1;
y *= -1;
z *= -1;
w *= -1;
}
// x < y < z ? w
// x < y < z < w -> x < y > z < w
// x < y < z > w -> x < y > w < z or x < z > y < w
if(z<w){
swap(a[i+1], a[i+2]);
ans++;
}else if(w<y){
swap(a[i+2], a[i+3]);
ans++;
}else if(w>y){
swap(a[i+1], a[i+2]);
ans++;
}
}
printf("%d\n",ans);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
### Response
```cpp
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
struct gds{
string name;
int a;
int b;
};
int main(){
int n,i,P,A,B,C,D,E,F,S,M;
int a,b;
string L;
while(1){
cin>>n;
if(!n){break;}
vector<gds> items(n);
for(i=0;i<n;i++){
cin>>L>>P>>A>>B>>C>>D>>E>>F>>S>>M;
a=F*S*M-P;
b=A+B+C+D+E+(D+E)*(M-1);
struct gds buf={L,a,b};
items[i]=buf;
}
sort(items.begin(),items.end(),[](const gds& a, const gds& b){return a.a*b.b==b.a*a.b ? a.name<b.name : a.a*b.b>b.a*a.b;});
for(auto it=items.begin();it!=items.end();it++){
cout<<it->name<<endl;
}
cout<<"#"<<endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Levko has an array that consists of integers: a1, a2, ... , an. But he doesn’t like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
It’s time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 ≤ ai ≤ 109).
Output
A single number — the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
int dp[maxn], n, k;
int a[maxn];
bool check(int d) {
int x, y, z;
for (int i = 1; i <= n; ++i) {
dp[i] = i - 1;
for (int j = 1; j < i; ++j) {
if ((i - j - 1) >= dp[i]) break;
x = a[j];
y = a[i];
if (x > y) {
z = x;
x = y;
y = z;
}
if (x + (long long)(i - j) * d < y) continue;
if (dp[j] + (i - j - 1) < dp[i]) dp[i] = dp[j] + (i - j - 1);
}
}
for (int i = n; i >= 1; --i) {
if (dp[i] + (n - i) <= k) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
long long L = 0, R = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (i > 1) R = max(R, (long long)abs(a[i] - a[i - 1]));
}
while (L < R) {
int m = (L + R) >> 1;
if (check(m))
R = m;
else
L = m + 1;
}
printf("%I64d\n", L);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are quite a lot of ways to have fun with inflatable balloons. For example, you can fill them with water and see what happens.
Grigory and Andrew have the same opinion. So, once upon a time, they went to the shop and bought n packets with inflatable balloons, where i-th of them has exactly a_i balloons inside.
They want to divide the balloons among themselves. In addition, there are several conditions to hold:
* Do not rip the packets (both Grigory and Andrew should get unbroken packets);
* Distribute all packets (every packet should be given to someone);
* Give both Grigory and Andrew at least one packet;
* To provide more fun, the total number of balloons in Grigory's packets should not be equal to the total number of balloons in Andrew's packets.
Help them to divide the balloons or determine that it's impossible under these conditions.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10) — the number of packets with balloons.
The second line contains n integers: a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000) — the number of balloons inside the corresponding packet.
Output
If it's impossible to divide the balloons satisfying the conditions above, print -1.
Otherwise, print an integer k — the number of packets to give to Grigory followed by k distinct integers from 1 to n — the indices of those. The order of packets doesn't matter.
If there are multiple ways to divide balloons, output any of them.
Examples
Input
3
1 2 1
Output
2
1 2
Input
2
5 5
Output
-1
Input
1
10
Output
-1
Note
In the first test Grigory gets 3 balloons in total while Andrey gets 1.
In the second test there's only one way to divide the packets which leads to equal numbers of balloons.
In the third test one of the boys won't get a packet at all.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int z, n, s, p;
s = 0;
p = 0;
vector<int> b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> z;
b.push_back(z);
}
if (n == 1)
cout << "-1" << endl;
else {
for (int i = 0; i < n - 1; i++) s = s + b[i];
if (s == b[n - 1]) {
if (b[n - 2] == b[n - 1])
cout << "-1" << endl;
else {
cout << n - 1 << endl;
for (int i = 1; i < n - 1; i++) cout << i << " ";
cout << n << endl;
}
} else {
cout << n - 1 << endl;
for (int i = 1; i < n; i++) cout << i << " ";
cout << endl;
}
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Vasilisa the Wise from a far away kingdom got a present from her friend Helga the Wise from a farther away kingdom. The present is a surprise box, yet Vasilisa the Wise doesn't know yet what the surprise actually is because she cannot open the box. She hopes that you can help her in that.
The box's lock is constructed like that. The box itself is represented by an absolutely perfect black cube with the identical deepening on each face (those are some foreign nanotechnologies that the far away kingdom scientists haven't dreamt of). The box is accompanied by six gems whose form matches the deepenings in the box's faces. The box can only be opened after it is correctly decorated by the gems, that is, when each deepening contains exactly one gem. Two ways of decorating the box are considered the same if they can be obtained one from the other one by arbitrarily rotating the box (note that the box is represented by a perfect nanotechnological cube)
Now Vasilisa the Wise wants to know by the given set of colors the following: in how many ways would she decorate the box in the worst case to open it? To answer this question it is useful to know that two gems of one color are indistinguishable from each other. Help Vasilisa to solve this challenging problem.
Input
The first line contains exactly 6 characters without spaces from the set {R, O, Y, G, B, V} — they are the colors of gems with which the box should be decorated.
Output
Print the required number of different ways to decorate the box.
Examples
Input
YYYYYY
Output
1
Input
BOOOOB
Output
2
Input
ROYGBV
Output
30
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a[6] = {0}, b[7] = {0};
char s[7];
int i;
scanf("%s", s);
for (i = 0; i < 6; i++) {
switch (s[i]) {
case 'R':
a[0]++;
break;
case 'O':
a[1]++;
break;
case 'Y':
a[2]++;
break;
case 'G':
a[3]++;
break;
case 'B':
a[4]++;
break;
case 'V':
a[5]++;
break;
}
}
for (i = 0; i < 6; i++) b[a[i]]++;
if (b[6] == 1 || b[5] == 1) {
puts("1");
} else if (b[4] == 1 || b[3] == 2) {
puts("2");
} else if (b[3] == 1) {
if (b[2] == 1) {
puts("3");
} else {
puts("5");
}
} else if (b[2] == 3) {
puts("6");
} else if (b[2] == 2) {
puts("8");
} else if (b[2] == 1) {
puts("15");
} else {
puts("30");
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Consider the infinite sequence of integers: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5.... The sequence is built in the following way: at first the number 1 is written out, then the numbers from 1 to 2, then the numbers from 1 to 3, then the numbers from 1 to 4 and so on. Note that the sequence contains numbers, not digits. For example number 10 first appears in the sequence in position 55 (the elements are numerated from one).
Find the number on the n-th position of the sequence.
Input
The only line contains integer n (1 ≤ n ≤ 1014) — the position of the number to find.
Note that the given number is too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Output
Print the element in the n-th position of the sequence (the elements are numerated from one).
Examples
Input
3
Output
2
Input
5
Output
2
Input
10
Output
4
Input
55
Output
10
Input
56
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
n -= i;
}
cout << n << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Snuke found N strange creatures. Each creature has a fixed color and size. The color and size of the i-th creature are represented by i and A_i, respectively.
Every creature can absorb another creature whose size is at most twice the size of itself. When a creature of size A and color B absorbs another creature of size C and color D (C \leq 2 \times A), they will merge into one creature of size A+C and color B. Here, depending on the sizes of two creatures, it is possible that both of them can absorb the other.
Snuke has been watching these creatures merge over and over and ultimately become one creature. Find the number of the possible colors of this creature.
Constraints
* 2 \leq N \leq 100000
* 1 \leq A_i \leq 10^9
* A_i is an integer.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
Print the number of the possible colors of the last remaining creature after the N creatures repeatedly merge and ultimately become one creature.
Examples
Input
3
3 1 4
Output
2
Input
5
1 1 1 1 1
Output
5
Input
6
40 1 30 2 7 20
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define N 200000
#define LL long long
int n, ai[N], l;
LL s;
int main()
{
cin >> n;
for (int i = 1; i <= n; ++ i) cin >> ai[i];
sort(ai + 1, ai + n + 1);
for (int i = 1; i <= n; ++ i)
{
if (s * 2 < ai[i]) l = i;
s += ai[i];
}
cout << n - l + 1;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There is an infinite sequence consisting of all positive integers in the increasing order: p = {1, 2, 3, ...}. We performed n swap operations with this sequence. A swap(a, b) is an operation of swapping the elements of the sequence on positions a and b. Your task is to find the number of inversions in the resulting sequence, i.e. the number of such index pairs (i, j), that i < j and pi > pj.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of swap operations applied to the sequence.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109, ai ≠ bi) — the arguments of the swap operation.
Output
Print a single integer — the number of inversions in the resulting sequence.
Examples
Input
2
4 2
1 4
Output
4
Input
3
1 6
3 4
2 5
Output
15
Note
In the first sample the sequence is being modified as follows: <image>. It has 4 inversions formed by index pairs (1, 4), (2, 3), (2, 4) and (3, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a, b, tmp;
int T[4 * 300009];
long long ans;
map<int, int> M, N, pos, id;
pair<long long, long long> v[300009];
vector<int> q;
vector<pair<int, int> > qq;
void upd(int x, int l, int r, int node) {
T[node]++;
if (l == r) return;
if (x <= (l + r) / 2)
upd(x, l, (l + r) / 2, node * 2);
else
upd(x, (l + r) / 2 + 1, r, node * 2 + 1);
}
int tap(int x, int l, int r, int node) {
if (l == r) return T[node];
if (x <= (l + r) / 2)
return tap(x, l, (l + r) / 2, node * 2);
else
return tap(x, (l + r) / 2 + 1, r, node * 2 + 1) + T[node * 2];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (!M[a]) M[a] = a;
if (!M[b]) M[b] = b;
swap(M[a], M[b]);
id[a] = id[b] = 1;
}
for (typeof((M).begin()) i = (M).begin(); i != (M).end(); i++) {
pos[i->second] = i->first;
q.push_back(i->second);
qq.push_back(make_pair(i->first, i->second));
}
for (typeof((id).begin()) i = (id).begin(); i != (id).end(); i++)
i->second = ++tmp;
sort(q.begin(), q.end());
tmp = 0;
for (int i = 0; i < q.size(); i++) N[q[i]] = ++tmp;
for (int i = qq.size() - 1; i >= 0; i--) {
ans += tap(N[qq[i].second], 1, 300009, 1);
upd(N[qq[i].second], 1, 300009, 1);
}
for (typeof((pos).begin()) i = (pos).begin(); i != (pos).end(); i++) {
int l = min(i->first, i->second);
int r = max(i->first, i->second);
if (l < r) {
ans += r - l - 1;
ans -= id[r] - id[l] - 1;
}
}
cout << ans;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
After the big birthday party, Katie still wanted Shiro to have some more fun. Later, she came up with a game called treasure hunt. Of course, she invited her best friends Kuro and Shiro to play with her.
The three friends are very smart so they passed all the challenges very quickly and finally reached the destination. But the treasure can only belong to one cat so they started to think of something which can determine who is worthy of the treasure. Instantly, Kuro came up with some ribbons.
A random colorful ribbon is given to each of the cats. Each color of the ribbon can be represented as an uppercase or lowercase Latin letter. Let's call a consecutive subsequence of colors that appears in the ribbon a subribbon. The beauty of a ribbon is defined as the maximum number of times one of its subribbon appears in the ribbon. The more the subribbon appears, the more beautiful is the ribbon. For example, the ribbon aaaaaaa has the beauty of 7 because its subribbon a appears 7 times, and the ribbon abcdabc has the beauty of 2 because its subribbon abc appears twice.
The rules are simple. The game will have n turns. Every turn, each of the cats must change strictly one color (at one position) in his/her ribbon to an arbitrary color which is different from the unchanged one. For example, a ribbon aaab can be changed into acab in one turn. The one having the most beautiful ribbon after n turns wins the treasure.
Could you find out who is going to be the winner if they all play optimally?
Input
The first line contains an integer n (0 ≤ n ≤ 10^{9}) — the number of turns.
Next 3 lines contain 3 ribbons of Kuro, Shiro and Katie one per line, respectively. Each ribbon is a string which contains no more than 10^{5} uppercase and lowercase Latin letters and is not empty. It is guaranteed that the length of all ribbons are equal for the purpose of fairness. Note that uppercase and lowercase letters are considered different colors.
Output
Print the name of the winner ("Kuro", "Shiro" or "Katie"). If there are at least two cats that share the maximum beauty, print "Draw".
Examples
Input
3
Kuroo
Shiro
Katie
Output
Kuro
Input
7
treasurehunt
threefriends
hiCodeforces
Output
Shiro
Input
1
abcabc
cbabac
ababca
Output
Katie
Input
15
foPaErcvJ
mZaxowpbt
mkuOlaHRE
Output
Draw
Note
In the first example, after 3 turns, Kuro can change his ribbon into ooooo, which has the beauty of 5, while reaching such beauty for Shiro and Katie is impossible (both Shiro and Katie can reach the beauty of at most 4, for example by changing Shiro's ribbon into SSiSS and changing Katie's ribbon into Kaaaa). Therefore, the winner is Kuro.
In the fourth example, since the length of each of the string is 9 and the number of turn is 15, everyone can change their ribbons in some way to reach the maximal beauty of 9 by changing their strings into zzzzzzzzz after 9 turns, and repeatedly change their strings into azzzzzzzz and then into zzzzzzzzz thrice. Therefore, the game ends in a draw.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[3];
int n, i, j, k, maxn[3] = {0};
cin >> n;
getchar();
for (i = 0; i < 3; i++) getline(cin, s[i]);
int cnt = 0;
map<char, int> ys[3];
for (i = 0; i < 3; i++) {
cnt = 0;
for (auto a : s[i]) {
cnt = max(cnt, ++ys[i][a]);
}
int len = s[i].size();
maxn[i] = cnt;
if (len == cnt) {
if (n == 1) maxn[i]--;
} else {
if (len - cnt <= n)
maxn[i] = len;
else
maxn[i] = cnt + n;
}
}
if (maxn[0] > maxn[1] && maxn[0] > maxn[2]) {
puts("Kuro");
} else if (maxn[1] > maxn[0] && maxn[1] > maxn[2]) {
puts("Shiro");
} else if (maxn[2] > maxn[0] && maxn[2] > maxn[1]) {
puts("Katie");
} else {
puts("Draw");
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are planning to buy an apartment in a n-floor building. The floors are numbered from 1 to n from the bottom to the top. At first for each floor you want to know the minimum total time to reach it from the first (the bottom) floor.
Let:
* a_i for all i from 1 to n-1 be the time required to go from the i-th floor to the (i+1)-th one (and from the (i+1)-th to the i-th as well) using the stairs;
* b_i for all i from 1 to n-1 be the time required to go from the i-th floor to the (i+1)-th one (and from the (i+1)-th to the i-th as well) using the elevator, also there is a value c — time overhead for elevator usage (you need to wait for it, the elevator doors are too slow!).
In one move, you can go from the floor you are staying at x to any floor y (x ≠ y) in two different ways:
* If you are using the stairs, just sum up the corresponding values of a_i. Formally, it will take ∑_{i=min(x, y)}^{max(x, y) - 1} a_i time units.
* If you are using the elevator, just sum up c and the corresponding values of b_i. Formally, it will take c + ∑_{i=min(x, y)}^{max(x, y) - 1} b_i time units.
You can perform as many moves as you want (possibly zero).
So your task is for each i to determine the minimum total time it takes to reach the i-th floor from the 1-st (bottom) floor.
Input
The first line of the input contains two integers n and c (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ c ≤ 1000) — the number of floors in the building and the time overhead for the elevator rides.
The second line of the input contains n - 1 integers a_1, a_2, ..., a_{n-1} (1 ≤ a_i ≤ 1000), where a_i is the time required to go from the i-th floor to the (i+1)-th one (and from the (i+1)-th to the i-th as well) using the stairs.
The third line of the input contains n - 1 integers b_1, b_2, ..., b_{n-1} (1 ≤ b_i ≤ 1000), where b_i is the time required to go from the i-th floor to the (i+1)-th one (and from the (i+1)-th to the i-th as well) using the elevator.
Output
Print n integers t_1, t_2, ..., t_n, where t_i is the minimum total time to reach the i-th floor from the first floor if you can perform as many moves as you want.
Examples
Input
10 2
7 6 18 6 16 18 1 17 17
6 9 3 10 9 1 10 1 5
Output
0 7 13 18 24 35 36 37 40 45
Input
10 1
3 2 3 1 3 3 1 4 1
1 2 3 4 4 1 2 1 3
Output
0 2 4 7 8 11 13 14 16 17
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
vector<long long int> a, b;
for (long long int i = 0; i < n - 1; i++) {
long long int x;
cin >> x;
a.push_back(x);
}
for (long long int i = 0; i < n - 1; i++) {
long long int y;
cin >> y;
b.push_back(y);
}
vector<vector<long long int>> dp(n + 1, vector<long long int>(2, INT_MAX));
dp[0][1] = k;
dp[0][0] = 0;
for (long long int i = 0; i <= n - 2; i++) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + a[i]);
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1] + a[i]);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + b[i] + k);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + b[i]);
if (i == 0) {
}
}
for (long long int i = 0; i <= n - 1; i++) {
cout << min(dp[i][0], dp[i][1]) << " ";
}
cout << '\n';
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There is a given string S consisting of N symbols. Your task is to find the number of ordered pairs of integers i and j such that
1. 1 ≤ i, j ≤ N
2. S[i] = S[j], that is the i-th symbol of string S is equal to the j-th.
Input
The single input line contains S, consisting of lowercase Latin letters and digits. It is guaranteed that string S in not empty and its length does not exceed 105.
Output
Print a single number which represents the number of pairs i and j with the needed property. Pairs (x, y) and (y, x) should be considered different, i.e. the ordered pairs count.
Examples
Input
great10
Output
7
Input
aaaaaaaaaa
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int kei[0x100];
int de(char a) {
if (a <= 'z' && a >= 'a')
return (a - 'a');
else
return (a - '0') + 26;
}
int main() {
int i;
string s;
long long out = 0;
memset(kei, 0, sizeof(kei));
cin >> s;
for (i = 0; i < s.size(); i++) kei[s[i]]++;
for (i = 0; i < 0x100; i++) out += (long long)kei[i] * kei[i];
cout << out << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given a sequence a_1, a_2, ..., a_n, consisting of integers.
You can apply the following operation to this sequence: choose some integer x and move all elements equal to x either to the beginning, or to the end of a. Note that you have to move all these elements in one direction in one operation.
For example, if a = [2, 1, 3, 1, 1, 3, 2], you can get the following sequences in one operation (for convenience, denote elements equal to x as x-elements):
* [1, 1, 1, 2, 3, 3, 2] if you move all 1-elements to the beginning;
* [2, 3, 3, 2, 1, 1, 1] if you move all 1-elements to the end;
* [2, 2, 1, 3, 1, 1, 3] if you move all 2-elements to the beginning;
* [1, 3, 1, 1, 3, 2, 2] if you move all 2-elements to the end;
* [3, 3, 2, 1, 1, 1, 2] if you move all 3-elements to the beginning;
* [2, 1, 1, 1, 2, 3, 3] if you move all 3-elements to the end;
You have to determine the minimum number of such operations so that the sequence a becomes sorted in non-descending order. Non-descending order means that for all i from 2 to n, the condition a_{i-1} ≤ a_i is satisfied.
Note that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of the queries. Each query is represented by two consecutive lines.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements.
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ n) — the elements.
It is guaranteed that the sum of all n does not exceed 3 ⋅ 10^5.
Output
For each query print one integer — the minimum number of operation for sorting sequence a in non-descending order.
Example
Input
3
7
3 1 6 6 3 1 1
8
1 1 4 4 4 7 8 8
7
4 2 5 2 6 2 7
Output
2
0
1
Note
In the first query, you can move all 1-elements to the beginning (after that sequence turn into [1, 1, 1, 3, 6, 6, 3]) and then move all 6-elements to the end.
In the second query, the sequence is sorted initially, so the answer is zero.
In the third query, you have to move all 2-elements to the beginning.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
set<int> s;
vector<int> f(n + 1, 0), l(n + 1, 0);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (f[x] == 0) f[x] = i;
l[x] = i;
s.insert(x);
}
int ans = n;
int prev = -1;
int last = -1;
for (auto &it : s) {
if (prev == -1)
prev = 1;
else if (l[last] > f[it])
prev = 1;
else
prev++;
ans = min(ans, (int)s.size() - prev);
last = it;
}
cout << ans << "\n";
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Do you like summer? Residents of Berland do. They especially love eating ice cream in the hot summer. So this summer day a large queue of n Berland residents lined up in front of the ice cream stall. We know that each of them has a certain amount of berland dollars with them. The residents of Berland are nice people, so each person agrees to swap places with the person right behind him for just 1 dollar. More formally, if person a stands just behind person b, then person a can pay person b 1 dollar, then a and b get swapped. Of course, if person a has zero dollars, he can not swap places with person b.
Residents of Berland are strange people. In particular, they get upset when there is someone with a strictly smaller sum of money in the line in front of them.
Can you help the residents of Berland form such order in the line so that they were all happy? A happy resident is the one who stands first in the line or the one in front of who another resident stands with not less number of dollars. Note that the people of Berland are people of honor and they agree to swap places only in the manner described above.
Input
The first line contains integer n (1 ≤ n ≤ 200 000) — the number of residents who stand in the line.
The second line contains n space-separated integers ai (0 ≤ ai ≤ 109), where ai is the number of Berland dollars of a man standing on the i-th position in the line. The positions are numbered starting from the end of the line.
Output
If it is impossible to make all the residents happy, print ":(" without the quotes. Otherwise, print in the single line n space-separated integers, the i-th of them must be equal to the number of money of the person on position i in the new line. If there are multiple answers, print any of them.
Examples
Input
2
11 8
Output
9 10
Input
5
10 9 7 10 6
Output
:(
Input
3
12 3 3
Output
4 4 10
Note
In the first sample two residents should swap places, after that the first resident has 10 dollars and he is at the head of the line and the second resident will have 9 coins and he will be at the end of the line.
In the second sample it is impossible to achieve the desired result.
In the third sample the first person can swap with the second one, then they will have the following numbers of dollars: 4 11 3, then the second person (in the new line) swaps with the third one, and the resulting numbers of dollars will equal to: 4 4 10. In this line everybody will be happy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int val[500005], lazy[500005], data[500005], size[500005];
int lc[500005], rc[500005], fa[500005];
void Add(int t, int ret) {
val[t] += ret;
lazy[t] += ret;
data[t] += ret;
}
void down(int t) {
if (lazy[t]) {
if (lc[t]) Add(lc[t], lazy[t]);
if (rc[t]) Add(rc[t], lazy[t]);
lazy[t] = 0;
}
}
void update(int t) {
data[t] = val[t];
size[t] = 1;
if (lc[t]) data[t] = max(data[t], data[lc[t]]), size[t] += size[lc[t]];
if (rc[t]) data[t] = max(data[t], data[rc[t]]), size[t] += size[rc[t]];
}
void zig(int x) {
int y = fa[x], z = fa[y];
fa[x] = z;
fa[y] = x;
fa[rc[x]] = y;
lc[y] = rc[x];
rc[x] = y;
if (lc[z] == y) lc[z] = x;
if (rc[z] == y) rc[z] = x;
update(y);
}
void zag(int x) {
int y = fa[x], z = fa[y];
fa[x] = z;
fa[y] = x;
fa[lc[x]] = y;
rc[y] = lc[x];
lc[x] = y;
if (lc[z] == y) lc[z] = x;
if (rc[z] == y) rc[z] = x;
update(y);
}
int stk[500005], root, tot, ans[500005];
void splay(int x) {
int y, z = 0;
for (y = x; y; y = fa[y]) stk[++z] = y;
for (; z; z--) down(stk[z]);
while (fa[x]) {
y = fa[x];
z = fa[y];
if (fa[y]) {
if (lc[z] == y) {
if (lc[y] == x)
zig(y), zig(x);
else
zag(x), zig(x);
} else {
if (rc[y] == x)
zag(y), zag(x);
else
zig(x), zag(x);
}
} else if (lc[y] == x)
zig(x);
else
zag(x);
}
root = x;
update(x);
}
void solve(int t) {
if (!t) return;
down(t);
solve(lc[t]);
++tot;
ans[tot] = val[t] - tot;
solve(rc[t]);
}
int tmp = 0;
void writeln(int t) {
if (!t) return;
down(t);
writeln(lc[t]);
++tmp;
printf("%d ", val[t] - tmp);
writeln(rc[t]);
}
int find(int x, int key) {
if (!x) return 0;
if (data[lc[x]] <= key) {
if (val[x] > key) return find(lc[x], key);
int t = find(rc[x], key);
if (t == 0) t = x;
return t;
} else
return find(lc[x], key);
}
int a[500005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
val[i] = a[i] + i;
int t = find(root, val[i]);
if (t) {
splay(t);
if (!rc[t]) {
rc[t] = i;
fa[i] = t;
splay(i);
} else {
for (t = rc[t]; lc[t]; t = lc[t])
;
lc[t] = i;
fa[i] = t;
splay(i);
}
} else {
if (!root) {
root = i;
update(root);
continue;
}
for (t = root; lc[t]; t = lc[t])
;
lc[t] = i;
fa[i] = t;
splay(i);
}
}
tot = 0;
solve(root);
for (int i = 1; i <= n - 1; i++)
if (ans[i] > ans[i + 1]) {
printf(":(\n");
return 0;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
The Zoo in the Grid Kingdom is represented by an infinite grid. The Zoo has n observation binoculars located at the OX axis. For each i between 1 and n, inclusive, there exists a single binocular located at the point with coordinates (i, 0). There are m flamingos in the Zoo, located at points with positive coordinates. The flamingos are currently sleeping and you can assume that they don't move.
In order to get a good view over the flamingos, each of the binoculars can be independently rotated to face any angle (not necessarily integer). Then, the binocular can be used to observe all flamingos that is located at the straight line passing through the binocular at the angle it is set. In other words, you can assign each binocular a direction corresponding to any straight line passing through the binocular, and the binocular will be able to see all flamingos located on that line.
Today, some kids from the prestigious Codeforces kindergarten went on a Field Study to the Zoo. Their teacher would like to set each binocular an angle to maximize the number of flamingos that can be seen by the binocular. The teacher is very interested in the sum of these values over all binoculars. Please help him find this sum.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 106, 1 ≤ m ≤ 250), denoting the number of binoculars and the number of flamingos, respectively.
Then m lines follow, the i-th line will contain two space-separated integers xi and yi (1 ≤ xi, yi ≤ 109), which means that the i-th flamingo is located at point (xi, yi).
All flamingos will be located at distinct points.
Output
Print a single integer denoting the maximum total number of flamingos that can be seen by all the binoculars.
Examples
Input
5 5
2 1
4 1
3 2
4 3
4 4
Output
11
Note
This picture shows the answer to the example test case.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int maxans[1000005];
long long x[255];
long long y[255];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld%lld", &x[i], &y[i]);
}
for (int i = 1; i <= n; i++) {
maxans[i] = 1;
}
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
long long t = 0;
if (y[i] != y[j]) {
if ((((x[i] - x[j]) * y[i]) % (y[i] - y[j])) == 0) {
t = x[i] - (((x[i] - x[j]) * y[i]) / (y[i] - y[j]));
if (t >= 1 && t <= n) {
int cur = 2;
for (int k = j + 1; k < m; k++) {
if (((y[i] - y[j]) * (x[i] - x[k])) ==
((y[i] - y[k]) * (x[i] - x[j]))) {
cur++;
}
}
maxans[t] = max(maxans[t], cur);
}
}
} else {
t = x[i];
if (t >= 1 && t <= n) {
int cur = 1;
for (int k = i + 1; k < m; k++) {
if (x[k] == t) {
cur++;
}
}
maxans[t] = max(maxans[t], cur);
}
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
sum += maxans[i];
}
printf("%lld\n", sum);
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n;
vector<int> out[200010];
int in[200010];
int cycle[200010];
int grundy[200010];
int st = -1;
const int CYCLE = 42;
int dfs(int x) {
cycle[x] = 1;
for(int i : out[x]) {
if(cycle[i] == 1) {
st = i;
cycle[x] = CYCLE;
return CYCLE;
}
else if(cycle[i] == 0) {
if(dfs(i) == CYCLE) {
cycle[x] = CYCLE;
if(x == st) return 0;
else return CYCLE;
}
}
}
cycle[x] = 2;
return 0;
}
int getgrundy(int x) {
set<int> s;
for(int i : out[x])
if(cycle[i] != CYCLE)
s.insert(getgrundy(i));
int ans = 0;
auto it = s.begin();
while(it != s.end()) {
if(*it == ans) {
++ans;
++it;
}
else return grundy[x] = ans;
}
return grundy[x] = ans;
}
bool chk(int x, int val, int res) {
if(x == st) return res == val;
int nxt = -1;
for(int i : out[x]) {
if(cycle[i] == CYCLE) {
nxt = i;
}
}
return chk(nxt, grundy[nxt] + (grundy[nxt] == val), res);
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
memset(cycle, 0, sizeof cycle);
for(int i = 0; i < n; ++i){
int x;
cin >> x;
--x;
out[x].push_back(i);
in[i] = x;
if(x < i and in[x] == i) {
st = i;
cycle[x] = cycle[i] = CYCLE;
}
}
for(int i = 0; st == -1 and i < n; ++i) if(cycle[i] == 0) dfs(i);
for(int i = 0; i < n; ++i) if(cycle[i] == CYCLE) getgrundy(i);
int nxt;
for(int i : out[st]) {
if(cycle[i] == CYCLE) {
nxt = i;
}
}
if(st == nxt or chk(nxt, grundy[nxt] + (grundy[st] == grundy[nxt]), grundy[st])) cout << "POSSIBLE" << endl;
else if (chk(nxt, grundy[nxt] + ((grundy[st] + 1) == grundy[nxt]), grundy[st] + 1)) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Snuke has two boards, each divided into a grid with N rows and N columns. For both of these boards, the square at the i-th row from the top and the j-th column from the left is called Square (i,j).
There is a lowercase English letter written in each square on the first board. The letter written in Square (i,j) is S_{i,j}. On the second board, nothing is written yet.
Snuke will write letters on the second board, as follows:
* First, choose two integers A and B ( 0 \leq A, B < N ).
* Write one letter in each square on the second board. Specifically, write the letter written in Square ( i+A, j+B ) on the first board into Square (i,j) on the second board. Here, the k-th row is also represented as the (N+k)-th row, and the k-th column is also represented as the (N+k)-th column.
After this operation, the second board is called a good board when, for every i and j ( 1 \leq i, j \leq N ), the letter in Square (i,j) and the letter in Square (j,i) are equal.
Find the number of the ways to choose integers A and B ( 0 \leq A, B < N ) such that the second board is a good board.
Constraints
* 1 \leq N \leq 300
* S_{i,j} ( 1 \leq i, j \leq N ) is a lowercase English letter.
Input
Input is given from Standard Input in the following format:
N
S_{1,1}S_{1,2}..S_{1,N}
S_{2,1}S_{2,2}..S_{2,N}
:
S_{N,1}S_{N,2}..S_{N,N}
Output
Print the number of the ways to choose integers A and B ( 0 \leq A, B < N ) such that the second board is a good board.
Examples
Input
2
ab
ca
Output
2
Input
4
aaaa
aaaa
aaaa
aaaa
Output
16
Input
5
abcde
fghij
klmno
pqrst
uvwxy
Output
0
### Response
```cpp
// https://atcoder.jp/contests/agc023/tasks/agc023_b
#include <bits/stdc++.h>
int n, t;
char s[305][305];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
bool ok = true;
for (int j = 0; ok & j < n - 1; j++)
for (int k = j + 1; ok & k < n; k++)
if (s[(j + i) % n][k] != s[(k + i) % n][j])
ok = false;
t += ok;
}
printf("%d\n", t * n);
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Diameter of a Tree
Given a tree T with non-negative weight, find the diameter of the tree.
The diameter of a tree is the maximum distance between two nodes in a tree.
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ wi ≤ 1,000
Input
n
s1 t1 w1
s2 t2 w2
:
sn-1 tn-1 wn-1
The first line consists of an integer n which represents the number of nodes in the tree. Every node has a unique ID from 0 to n-1 respectively.
In the following n-1 lines, edges of the tree are given. si and ti represent end-points of the i-th edge (undirected) and wi represents the weight (distance) of the i-th edge.
Output
Print the diameter of the tree in a line.
Examples
Input
4
0 1 2
1 2 1
1 3 3
Output
5
Input
4
0 1 1
1 2 2
2 3 4
Output
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int n;
vector<int> dijkstra(int s, vector<vector<P>> &G){
vector<int> dist(n, 1e9);
priority_queue<P, vector<P>, greater<P>> que;
dist[s] = 0;
que.emplace(0, s);
while(!que.empty()){
int ccost, cv;
tie(ccost, cv) = que.top();
que.pop();
if(dist[cv] < ccost) continue;
for(auto x : G[cv]){
int nv, ncost;
tie(nv, ncost) = x;
if(dist[cv] + ncost < dist[nv]){
dist[nv] = dist[cv] + ncost;
que.emplace(dist[nv], nv);
}
}
}
return dist;
}
int main(){
cin>>n;
vector<vector<P>> G(n);
for(int i=0; i<n-1; i++){
int s, t, w; cin>>s>>t>>w;
G[s].emplace_back(t, w);
G[t].emplace_back(s, w);
}
vector<int> dist1 = dijkstra(0, G);
int v1 = max_element(dist1.begin(), dist1.end()) - dist1.begin();
vector<int> dist2 = dijkstra(v1, G);
cout << *max_element(dist2.begin(), dist2.end()) << endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
int k, n, ans, a[1001], i, t;
cin >> k;
while (k--) {
ans = 0;
cin >> n;
for (i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; ++i) {
t = min(n - i, a[i]);
ans = max(ans, t);
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
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;
int main()
{
int f;
cin >> f;
cout << (f-30)/2<< endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int f[4005][4005];
int a[4005];
int main() {
int i, j, k, n, m = 0;
memset(f, 0, sizeof(f));
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
k = 0;
for (j = 0; j < i; j++) {
f[i][j] = f[j][k] + 1;
if (a[j] == a[i]) {
k = j;
}
m = max(m, f[i][j]);
}
}
cout << m << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vasya plays the sleuth with his friends. The rules of the game are as follows: those who play for the first time, that is Vasya is the sleuth, he should investigate a "crime" and find out what is happening. He can ask any questions whatsoever that can be answered with "Yes" or "No". All the rest agree beforehand to answer the questions like that: if the question’s last letter is a vowel, they answer "Yes" and if the last letter is a consonant, they answer "No". Of course, the sleuth knows nothing about it and his task is to understand that.
Unfortunately, Vasya is not very smart. After 5 hours of endless stupid questions everybody except Vasya got bored. That’s why Vasya’s friends ask you to write a program that would give answers instead of them.
The English alphabet vowels are: A, E, I, O, U, Y
The English alphabet consonants are: B, C, D, F, G, H, J, K, L, M, N, P, Q, R, S, T, V, W, X, Z
Input
The single line contains a question represented by a non-empty line consisting of large and small Latin letters, spaces and a question mark. The line length does not exceed 100. It is guaranteed that the question mark occurs exactly once in the line — as the last symbol and that the line contains at least one letter.
Output
Print answer for the question in a single line: YES if the answer is "Yes", NO if the answer is "No".
Remember that in the reply to the question the last letter, not the last character counts. I. e. the spaces and the question mark do not count as letters.
Examples
Input
Is it a melon?
Output
NO
Input
Is it an apple?
Output
YES
Input
Is it a banana ?
Output
YES
Input
Is it an apple and a banana simultaneouSLY?
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
string s;
getline(cin, s);
for (int i = s.size() - 1; i >= 0; --i) {
char c = tolower(s[i]);
if (isalpha(c)) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
cout << "YES" << endl;
else
cout << "NO" << endl;
break;
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You got a box with a combination lock. The lock has a display showing n digits. There are two buttons on the box, each button changes digits on the display. You have quickly discovered that the first button adds 1 to all the digits (all digits 9 become digits 0), and the second button shifts all the digits on the display one position to the right (the last digit becomes the first one). For example, if the display is currently showing number 579, then if we push the first button, the display will show 680, and if after that we push the second button, the display will show 068.
You know that the lock will open if the display is showing the smallest possible number that can be obtained by pushing the buttons in some order. The leading zeros are ignored while comparing numbers. Now your task is to find the desired number.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of digits on the display.
The second line contains n digits — the initial state of the display.
Output
Print a single line containing n digits — the desired state of the display containing the smallest possible number.
Examples
Input
3
579
Output
024
Input
4
2014
Output
0142
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string s, mini;
cin >> n >> s;
mini = s;
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < n; ++j) {
char c = s[n - 1];
s = s.substr(0, n - 1);
string aux = "";
aux.push_back(c);
aux.append(s);
s = aux;
mini = min(mini, s);
}
for (int j = 0; j < n; ++j) s[j] = s[j] != '9' ? s[j] + 1 : '0';
}
cout << mini << "\n";
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
In this problem you have to solve a simple classification task: given an image, determine whether it depicts a Fourier doodle.
You are given a set of 50 images with ids 1 through 50. You are also given a text file labels.txt containing the labels for images with ids 1 through 20, which comprise the learning data set.
You have to output the classification results for images with ids 21 through 50 in the same format.
Input
[Download the images and the training labels](http://tc-alchemy.progopedia.com/fourier-doodles.zip)
Each line of the file labels.txt contains a single integer 0 or 1. Line i (1-based) contains the label of the image {i}.png. Label 1 means that the image depicts a Fourier doodle, label 0 - that it does not.
Output
Output 30 lines, one line per image 21 through 50. Line i (1-based) should contain the classification result for the image {i + 20}.png.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
bool p[364] = {};
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
ios::sync_with_stdio(false);
for (int id = 21; id <= 50; id++) {
if (((min(id, 25) + id) % (2 + id % 3)) > 0)
cout << 1;
else
cout << 0;
cout << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
A binary matrix is called good if every even length square sub-matrix has an odd number of ones.
Given a binary matrix a consisting of n rows and m columns, determine the minimum number of cells you need to change to make it good, or report that there is no way to make it good at all.
All the terms above have their usual meanings — refer to the Notes section for their formal definitions.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ m ≤ 10^6 and n⋅ m ≤ 10^6) — the number of rows and columns in a, respectively.
The following n lines each contain m characters, each of which is one of 0 and 1. If the j-th character on the i-th line is 1, then a_{i,j} = 1. Similarly, if the j-th character on the i-th line is 0, then a_{i,j} = 0.
Output
Output the minimum number of cells you need to change to make a good, or output -1 if it's not possible at all.
Examples
Input
3 3
101
001
110
Output
2
Input
7 15
000100001010010
100111010110001
101101111100100
010000111111010
111010010100001
000011001111101
111111011010011
Output
-1
Note
In the first case, changing a_{1,1} to 0 and a_{2,2} to 1 is enough.
You can verify that there is no way to make the matrix in the second case good.
Some definitions —
* A binary matrix is one in which every element is either 1 or 0.
* A sub-matrix is described by 4 parameters — r_1, r_2, c_1, and c_2; here, 1 ≤ r_1 ≤ r_2 ≤ n and 1 ≤ c_1 ≤ c_2 ≤ m.
* This sub-matrix contains all elements a_{i,j} that satisfy both r_1 ≤ i ≤ r_2 and c_1 ≤ j ≤ c_2.
* A sub-matrix is, further, called an even length square if r_2-r_1 = c_2-c_1 and r_2-r_1+1 is divisible by 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void fastio(void);
int find_val2(char a, char b) { return (a - '0') + 2 * (b - '0'); }
int find_val3(char a, char b, char c) {
return (a - '0') + 2 * (b - '0') + 4 * (c - '0');
}
int find_dif(int a, int b) {
int cnt = 0;
while (a > 0 || b > 0) {
if ((a & 1) != (b & 1)) cnt++;
a /= 2;
b /= 2;
}
return cnt;
}
bool poss(int a, int b, int n) {
if (n == 2) {
int c = (a ^ b);
if (c == 1 || c == 2) return true;
}
if (n == 3) {
int c = (a ^ b);
if (c == 2 || c == 5) return true;
}
return false;
}
void solve() {
int n, m, la, lb, lc;
cin >> n >> m;
vector<string> st(n);
for (la = 0; la < n; la++) cin >> st[la];
if (n <= 1) {
cout << 0 << endl;
return;
}
if (n > 3) {
cout << -1 << endl;
return;
}
vector<vector<int>> dp((1 << n), vector<int>(m, INT_MAX));
for (la = 0; la < m; la++) {
int val = 0;
if (n == 2) val = find_val2(st[0][la], st[1][la]);
if (n == 3) val = find_val3(st[0][la], st[1][la], st[2][la]);
if (la == 0) {
for (lb = 0; lb < (1 << n); lb++) dp[lb][la] = find_dif(val, lb);
continue;
}
for (lb = 0; lb < (1 << n); lb++) {
for (lc = 0; lc < (1 << n); lc++) {
if (poss(lb, lc, n))
dp[lc][la] = min(dp[lc][la], dp[lb][la - 1] + find_dif(val, lc));
}
}
}
int ans = INT_MAX;
for (la = 0; la < (1 << n); la++) ans = min(ans, dp[la][m - 1]);
cout << ans << endl;
}
int main() {
fastio();
solve();
return 0;
}
void fastio(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Sig has built his own keyboard. Designed for ultimate simplicity, this keyboard only has 3 keys on it: the `0` key, the `1` key and the backspace key.
To begin with, he is using a plain text editor with this keyboard. This editor always displays one string (possibly empty). Just after the editor is launched, this string is empty. When each key on the keyboard is pressed, the following changes occur to the string:
* The `0` key: a letter `0` will be inserted to the right of the string.
* The `1` key: a letter `1` will be inserted to the right of the string.
* The backspace key: if the string is empty, nothing happens. Otherwise, the rightmost letter of the string is deleted.
Sig has launched the editor, and pressed these keys several times. You are given a string s, which is a record of his keystrokes in order. In this string, the letter `0` stands for the `0` key, the letter `1` stands for the `1` key and the letter `B` stands for the backspace key. What string is displayed in the editor now?
Constraints
* 1 ≦ |s| ≦ 10 (|s| denotes the length of s)
* s consists of the letters `0`, `1` and `B`.
* The correct answer is not an empty string.
Input
The input is given from Standard Input in the following format:
s
Output
Print the string displayed in the editor in the end.
Examples
Input
01B0
Output
00
Input
0BB1
Output
1
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,an="";
cin>>s;
for(auto i: s)
if(i=='B'){if(an.size())an.pop_back();}
else an.push_back(i);
cout<<an<<endl;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
For a given sequence of distinct non-negative integers (b_1, b_2, ..., b_k) we determine if it is good in the following way:
* Consider a graph on k nodes, with numbers from b_1 to b_k written on them.
* For every i from 1 to k: find such j (1 ≤ j ≤ k, j≠ i), for which (b_i ⊕ b_j) is the smallest among all such j, where ⊕ denotes the operation of bitwise XOR (<https://en.wikipedia.org/wiki/Bitwise_operation#XOR>). Next, draw an undirected edge between vertices with numbers b_i and b_j in this graph.
* We say that the sequence is good if and only if the resulting graph forms a tree (is connected and doesn't have any simple cycles).
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
You can find an example below (the picture corresponding to the first test case).
Sequence (0, 1, 5, 2, 6) is not good as we cannot reach 1 from 5.
However, sequence (0, 1, 5, 2) is good.
<image>
You are given a sequence (a_1, a_2, ..., a_n) of distinct non-negative integers. You would like to remove some of the elements (possibly none) to make the remaining sequence good. What is the minimum possible number of removals required to achieve this goal?
It can be shown that for any sequence, we can remove some number of elements, leaving at least 2, so that the remaining sequence is good.
Input
The first line contains a single integer n (2 ≤ n ≤ 200,000) — length of the sequence.
The second line contains n distinct non-negative integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the elements of the sequence.
Output
You should output exactly one integer — the minimum possible number of elements to remove in order to make the remaining sequence good.
Examples
Input
5
0 1 5 2 6
Output
1
Input
7
6 9 8 7 3 5 2
Output
2
Note
Note that numbers which you remove don't impact the procedure of telling whether the resulting sequence is good.
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int D = 32;
int calc(int left, int right, vector<int> &vec) {
if (right - left <= 1) {
return 0;
}
int d = D;
while (d > 0) {
bool x = (vec[left] & (1LL << d));
bool y = (vec[right - 1] & (1LL << d));
if (x != y) {
break;
}
d--;
}
int mid = left;
while (mid < right) {
if (vec[mid] & (1LL << d)) {
break;
}
mid++;
}
return min(calc(left, mid, vec) + right - mid - 1,
calc(mid, right, vec) + mid - left - 1);
}
void solve() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
cout << calc(0, N, vec) << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
T = 1;
for (int i = 0; i < T; i++) {
solve();
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A process RAM is a sequence of bytes that are indexed from 1 to n. Polycarpus's program contains such instructions as "memset", that is, the operations of filling memory cells on a segment with some value. The details are: the code only contains m instructions that look like "set13 a_i l_i". Instruction i fills a continuous memory segment of length li, starting from cell number ai, (that it cells with numbers ai, ai + 1, ..., ai + li - 1) with values 13.
In Polycarpus's code, the optimizer's task is to remove the maximum number of instructions from his code in such a way that the remaining instructions set value 13 in all the memory bytes that got this value from the code before the optimization. Also, the value 13 should be set only in the memory bytes that got this value from the code before the optimization. Your task is to implement the optimizer for such program.
Input
The first line contains integers n and m (1 ≤ n ≤ 2·106, 1 ≤ m ≤ 2·105) — the number of bytes (memory cells) and the number of instructions in Polycarpus's code. Then m lines follow, each line contains a pair of integers ai, li (1 ≤ ai ≤ n, 1 ≤ li ≤ n - ai + 1).
Output
Print in the first line the sought maximum number of instructions that can be removed from the code. In the second line print the numbers of the instructions. The instructions are numbered from 1 to m in the order they appeared in the input. If there are multiple solutions, print any of them.
Examples
Input
10 4
3 3
3 1
4 1
9 2
Output
2
2 3
Input
1 1
1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167177216")
using namespace std;
struct otr {
int a, b, c;
};
bool cmp(otr &a, otr &b) {
if (a.a != b.a) return a.a < b.a;
if (a.b != b.b) return a.b > b.b;
return a.c < b.c;
}
int main() {
int n, m;
scanf("%d%d", &m, &n);
vector<otr> v(n);
for (int i = 0; i < int(n); ++i) {
scanf("%d%d", &v[i].a, &v[i].b);
v[i].b += v[i].a - 1;
v[i].c = i;
}
sort(v.begin(), v.end(), cmp);
vector<int> ans;
int maxr = -1, l = 0, r = 0;
int pos = 0, last = 0;
while (l < n) {
if (v[l].a > maxr) {
last = l;
maxr = v[l].b;
}
int nmaxr = maxr;
while (r < n && v[r].a <= maxr + 1) {
if (v[r].b > nmaxr) {
nmaxr = v[r].b;
pos = r;
}
r++;
}
while (l < r) {
if (pos != l && last != l) ans.push_back(v[l].c);
l++;
}
maxr = nmaxr;
}
cout << ans.size() << endl;
for (int i = 0; i < int(ans.size()); ++i) cout << ans[i] + 1 << ' ';
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Mike is the president of country What-The-Fatherland. There are n bears living in this country besides Mike. All of them are standing in a line and they are numbered from 1 to n from left to right. i-th bear is exactly ai feet high.
<image>
A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strength of a group is the minimum height of the bear in that group.
Mike is a curious to know for each x such that 1 ≤ x ≤ n the maximum strength among all groups of size x.
Input
The first line of input contains integer n (1 ≤ n ≤ 2 × 105), the number of bears.
The second line contains n integers separated by space, a1, a2, ..., an (1 ≤ ai ≤ 109), heights of bears.
Output
Print n integers in one line. For each x from 1 to n, print the maximum strength among all groups of size x.
Examples
Input
10
1 2 3 4 5 4 3 2 1 6
Output
6 4 4 3 3 2 2 1 1 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vp;
int vals[2000000];
int lefty[2000000];
int righty[2000000];
int taken[2000000];
int ans[2000000];
int main() {
int i, j, k, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &vals[i]);
vp.push_back(make_pair(vals[i], i));
}
sort(vp.begin(), vp.end());
reverse(vp.begin(), vp.end());
int past = 0;
for (i = 0; i < n; i++) {
taken[vp[i].second] = 1;
int l = vp[i].second, r = vp[i].second;
if (taken[vp[i].second - 1]) {
l = lefty[vp[i].second - 1];
}
if (taken[vp[i].second + 1]) {
r = righty[vp[i].second + 1];
}
righty[l] = r;
lefty[r] = l;
for (j = past + 1; j <= (r - l + 1); j++) {
ans[j] = vp[i].first;
}
past = max(past, (r - l + 1));
}
for (i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Zibi is a competitive programming coach. There are n competitors who want to be prepared well. The training contests are quite unusual – there are two people in a team, two problems, and each competitor will code exactly one of them. Of course, people in one team will code different problems.
Rules of scoring also aren't typical. The first problem is always an implementation problem: you have to implement some well-known algorithm very fast and the time of your typing is rated. The second one is an awful geometry task and you just have to get it accepted in reasonable time. Here the length and difficulty of your code are important. After that, Zibi will give some penalty points (possibly negative) for each solution and the final score of the team is the sum of them (the less the score is, the better).
We know that the i-th competitor will always have score x_i when he codes the first task and y_i when he codes the second task. We can assume, that all competitors know each other's skills and during the contest distribute the problems in the way that minimizes their final score. Remember that each person codes exactly one problem in a contest.
Zibi wants all competitors to write a contest with each other. However, there are m pairs of people who really don't like to cooperate and they definitely won't write a contest together. Still, the coach is going to conduct trainings for all possible pairs of people, such that the people in pair don't hate each other. The coach is interested for each participant, what will be his or her sum of scores of all teams he trained in?
Input
The first line contains two integers n and m (2 ≤ n ≤ 300 000, 0 ≤ m ≤ 300 000) — the number of participants and the number of pairs of people who will not write a contest together.
Each of the next n lines contains two integers x_i and y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the scores which will the i-th competitor get on the first problem and on the second problem. It is guaranteed that there are no two people having both x_i and y_i same.
Each of the next m lines contain two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) — indices of people who don't want to write a contest in one team. Each unordered pair of indices will appear at most once.
Output
Output n integers — the sum of scores for all participants in the same order as they appear in the input.
Examples
Input
3 2
1 2
2 3
1 3
1 2
2 3
Output
3 0 3
Input
3 3
1 2
2 3
1 3
1 2
2 3
1 3
Output
0 0 0
Input
5 3
-1 3
2 4
1 1
3 5
2 2
1 4
2 3
3 5
Output
4 14 4 16 10
Note
In the first example, there will be only one team consisting of persons 1 and 3. The optimal strategy for them is to assign the first task to the 3-rd person and the second task to the 1-st person, this will lead to score equal to 1 + 2 = 3.
In the second example, nobody likes anyone, so there won't be any trainings. It seems that Zibi won't be titled coach in that case...
### Response
```cpp
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = (long long)1e9 + 7;
using namespace std;
template <class T, class T2>
void smin(T& a, T2 val) {
if (a > val) a = val;
}
template <class T, class T2>
void smax(T& a, T2 val) {
if (a < val) a = val;
}
const long long N = 5 * (long long)1e5 + 10;
long long n, x[N], y[N], m;
vector<long long> v[N];
vector<long long> p;
long long pref_x[N], suff_y[N], ans[N];
vector<array<long long, 2>> edge;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
p.push_back(i);
}
for (long long i = 0; i < m; ++i) {
long long x, y;
cin >> x >> y;
edge.push_back({x, y});
}
sort(p.begin(), p.end(),
[&](long long i, long long j) { return x[i] - y[i] < x[j] - y[j]; });
for (long long i = 1; i <= n; ++i) {
pref_x[i] = pref_x[i - 1];
long long idx = p[i - 1];
pref_x[i] += x[idx];
}
for (long long i = n; i >= 1; --i) {
suff_y[i] = suff_y[i + 1];
long long idx = p[i - 1];
suff_y[i] += y[idx];
}
for (long long i = 1; i <= n; ++i) {
long long idx = p[i - 1];
ans[idx] = suff_y[i + 1] + x[idx] * (n - i);
ans[idx] += pref_x[i - 1] + y[idx] * (i - 1);
}
for (auto& it : edge) {
long long idx1 = it[0], idx2 = it[1];
long long minn = min(x[idx1] + y[idx2], x[idx2] + y[idx1]);
ans[idx1] -= minn;
ans[idx2] -= minn;
}
for (long long i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
This is the easy version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n × m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 × 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most 3nm operations. You don't need to minimize the number of operations.
It can be proved that it is always possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 5000) — the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 ≤ n, m ≤ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 ≤ k ≤ 3nm) — the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 ≤ x_1, x_2, x_3 ≤ n, 1 ≤ y_1, y_2, y_3 ≤ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong into some 2 × 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void start() {}
vector<pair<long long, long long>> v, v1;
void one(char x, char y, char z, char w, long long i, long long j) {
if (x == '1') {
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else if (y == '1') {
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else if (z == '1') {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
}
}
void two(char x, char y, char z, char w, long long i, long long j) {
if (x == '1' && y == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else if (x == '1' && z == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else if (x == '1' && w == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
} else if (y == '1' && z == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else if (y == '1' && w == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
} else if (z == '1' && w == '1') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
}
}
void three(char x, char y, char z, char w, long long i, long long j) {
if (x == '0') {
v.push_back({i + 2, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
} else if (y == '0') {
v.push_back({i + 2, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 1});
} else if (z == '0') {
v.push_back({i + 2, j + 2});
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
} else if (w == '0') {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
}
}
void four(char x, char y, char z, char w, long long i, long long j) {
v.push_back({i + 2, j + 2});
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
one('1', '0', '0', '0', i, j);
}
void fn(char x, char y, char z, char w, long long i, long long j) {
long long cal = (x - '0') + (y - '0') + (z - '0') + (w - '0');
if (cal == 0) return;
if (cal == 1) one(x, y, z, w, i, j);
if (cal == 2) two(x, y, z, w, i, j);
if (cal == 3) three(x, y, z, w, i, j);
if (cal == 4) four(x, y, z, w, i, j);
}
void fn1(char x, char y, long long i, long long j) {
if (x == '1' && y == '1') {
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else if (x == '0' && y == '1') {
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else if (x == '1' && y == '0') {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else
return;
}
void fn2(char x, char y, long long i, long long j) {
if (x == '1' && y == '1') {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j + 1});
v.push_back({i + 2, j + 2});
} else if (x == '0' && y == '1') {
v.push_back({i + 2, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else if (x == '1' && y == '0') {
v.push_back({i + 1, j + 1});
v.push_back({i + 1, j + 2});
v.push_back({i + 2, j + 2});
} else
return;
}
char up(char x) {
if (x == '0')
return '1';
else
return '0';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
v.clear();
v1.clear();
long long n, m;
cin >> n >> m;
string s[n], s1[n], s2[n];
long long c = 0;
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
for (long long i = 0; i < n - 2; i++) {
for (long long j = 0; j < m; j++) {
if (s[i][j] == '1') {
if (j == m - 1) {
v.push_back({i + 1, j + 1});
v.push_back({i + 2, j});
v.push_back({i + 2, j + 1});
s[i][j] = up(s[i][j]);
s[i + 1][j - 1] = up(s[i + 1][j - 1]);
s[i + 1][j] = up(s[i + 1][j]);
continue;
}
if (s[i][j] == '0' && s[i][j + 1] == '0') {
continue;
} else if (s[i][j] == '1' && s[i][j + 1] == '1') {
s[i + 1][j + 1] = up(s[i + 1][j + 1]);
} else {
s[i + 1][j] = up(s[i + 1][j]);
s[i + 1][j + 1] = up(s[i + 1][j + 1]);
}
fn1(s[i][j], s[i][j + 1], i, j);
s[i][j] = '0';
s[i][j + 1] = '0';
}
}
}
for (long long j = 0; j < m - 1; j++) {
if (s[n - 2][j] == '0' && s[n - 1][j] == '0') {
continue;
} else if (s[n - 2][j] == '1' && s[n - 1][j] == '1') {
s[n - 1][j + 1] = (((s[n - 1][j + 1] - '0') ^ 1) + '0');
} else {
s[n - 2][j + 1] = (((s[n - 2][j + 1] - '0') ^ 1) + '0');
s[n - 1][j + 1] = (((s[n - 1][j + 1] - '0') ^ 1) + '0');
}
fn2(s[n - 2][j], s[n - 1][j], n - 2, j);
s[n - 2][j] = '0';
s[n - 1][j] = '0';
}
fn(s[n - 2][m - 2], s[n - 2][m - 1], s[n - 1][m - 2], s[n - 1][m - 1],
n - 2, m - 2);
cout << v.size() / 3 << endl;
for (long long i = 0; i < v.size(); i += 3)
cout << v[i].first << ' ' << v[i].second << ' ' << v[i + 1].first << ' '
<< v[i + 1].second << ' ' << v[i + 2].first << ' ' << v[i + 2].second
<< endl;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given set of n points in 5-dimensional space. The points are labeled from 1 to n. No two points coincide.
We will call point a bad if there are different points b and c, not equal to a, from the given set such that angle between vectors <image> and <image> is acute (i.e. strictly less than <image>). Otherwise, the point is called good.
The angle between vectors <image> and <image> in 5-dimensional space is defined as <image>, where <image> is the scalar product and <image> is length of <image>.
Given the list of points, print the indices of the good points in ascending order.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 103) — the number of points.
The next n lines of input contain five integers ai, bi, ci, di, ei (|ai|, |bi|, |ci|, |di|, |ei| ≤ 103) — the coordinates of the i-th point. All points are distinct.
Output
First, print a single integer k — the number of good points.
Then, print k integers, each on their own line — the indices of the good points in ascending order.
Examples
Input
6
0 0 0 0 0
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
Output
1
1
Input
3
0 0 1 2 0
0 0 9 2 0
0 0 5 9 0
Output
0
Note
In the first sample, the first point forms exactly a <image> angle with all other pairs of points, so it is good.
In the second sample, along the cd plane, we can see the points look as follows:
<image>
We can see that all angles here are acute, so no points are good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[12][6], ans[12], cnt;
bool check(int x, int p, int q) {
int tot = 0;
for (int i = 1; i <= 5; i++)
tot = tot + (a[p][i] - a[x][i]) * (a[q][i] - a[x][i]);
if (tot <= 0)
return 1;
else
return 0;
}
int main() {
cin >> n;
if (n > 32) {
cout << 0;
return 0;
};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 5; j++) cin >> a[i][j];
for (int k = 1; k <= n; k++) {
bool flag = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (i == j || j == k || i == k || flag) continue;
if (!check(k, i, j)) flag = 1;
}
if (!flag) {
cnt++;
ans[cnt] = k;
}
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) cout << ans[i] << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Duff is addicted to meat! Malek wants to keep her happy for n days. In order to be happy in i-th day, she needs to eat exactly ai kilograms of meat.
<image>
There is a big shop uptown and Malek wants to buy meat for her from there. In i-th day, they sell meat for pi dollars per kilogram. Malek knows all numbers a1, ..., an and p1, ..., pn. In each day, he can buy arbitrary amount of meat, also he can keep some meat he has for the future.
Malek is a little tired from cooking meat, so he asked for your help. Help him to minimize the total money he spends to keep Duff happy for n days.
Input
The first line of input contains integer n (1 ≤ n ≤ 105), the number of days.
In the next n lines, i-th line contains two integers ai and pi (1 ≤ ai, pi ≤ 100), the amount of meat Duff needs and the cost of meat in that day.
Output
Print the minimum money needed to keep Duff happy for n days, in one line.
Examples
Input
3
1 3
2 2
3 1
Output
10
Input
3
1 3
2 1
3 2
Output
8
Note
In the first sample case: An optimal way would be to buy 1 kg on the first day, 2 kg on the second day and 3 kg on the third day.
In the second sample case: An optimal way would be to buy 1 kg on the first day and 5 kg (needed meat for the second and third day) on the second day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[100002], p[100002];
int main() {
ios_base::sync_with_stdio(false);
int n, mincost = 100000;
long long int cost = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
cin >> p[i];
}
for (int i = 0; i < n; i++) {
if (p[i] < mincost) {
mincost = p[i];
}
cost = cost + (a[i] * mincost);
}
cout << cost;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Snuke received a positive integer N from Takahashi. A positive integer m is called a favorite number when the following condition is satisfied:
* The quotient and remainder of N divided by m are equal, that is, \lfloor \frac{N}{m} \rfloor = N \bmod m holds.
Find all favorite numbers and print the sum of those.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
8
Output
10
Input
1000000000000
Output
2499686339916
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long N;
cin>>N;
long long ans=0;
for(long long i=2;i*i<=N;i++)
{
if(N%i==0)
{
if(N/(i-1)==N%(i-1))ans+=i-1;
if(N/((N/i)-1)==N%((N/i)-1))ans+=N/i-1;
}
}
if(N!=2)
ans+=N-1;
cout<<ans;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Nearly each project of the F company has a whole team of developers working on it. They often are in different rooms of the office in different cities and even countries. To keep in touch and track the results of the project, the F company conducts shared online meetings in a Spyke chat.
One day the director of the F company got hold of the records of a part of an online meeting of one successful team. The director watched the record and wanted to talk to the team leader. But how can he tell who the leader is? The director logically supposed that the leader is the person who is present at any conversation during a chat meeting. In other words, if at some moment of time at least one person is present on the meeting, then the leader is present on the meeting.
You are the assistant director. Given the 'user logged on'/'user logged off' messages of the meeting in the chronological order, help the director determine who can be the leader. Note that the director has the record of only a continuous part of the meeting (probably, it's not the whole meeting).
Input
The first line contains integers n and m (1 ≤ n, m ≤ 105) — the number of team participants and the number of messages. Each of the next m lines contains a message in the format:
* '+ id': the record means that the person with number id (1 ≤ id ≤ n) has logged on to the meeting.
* '- id': the record means that the person with number id (1 ≤ id ≤ n) has logged off from the meeting.
Assume that all the people of the team are numbered from 1 to n and the messages are given in the chronological order. It is guaranteed that the given sequence is the correct record of a continuous part of the meeting. It is guaranteed that no two log on/log off events occurred simultaneously.
Output
In the first line print integer k (0 ≤ k ≤ n) — how many people can be leaders. In the next line, print k integers in the increasing order — the numbers of the people who can be leaders.
If the data is such that no member of the team can be a leader, print a single number 0.
Examples
Input
5 4
+ 1
+ 2
- 2
- 1
Output
4
1 3 4 5
Input
3 2
+ 1
- 2
Output
1
3
Input
2 4
+ 1
- 1
+ 2
- 2
Output
0
Input
5 6
+ 1
- 1
- 3
+ 3
+ 4
- 4
Output
3
2 3 5
Input
2 4
+ 1
- 2
+ 2
- 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
set<int> tp;
vector<pair<char, int> > vec;
set<int> s;
int n, m;
int find(int index) {
for (vector<pair<char, int> >::iterator itr = vec.begin(); itr != vec.end();
itr++) {
if (itr->first == '-')
tp.erase(itr->second);
else
tp.insert(itr->second);
if (tp.size() > 0 && tp.find(index) == tp.end()) {
return 0;
}
}
return 1;
}
int main() {
cin >> n >> m;
int tmp;
char ch;
int vis[n + 1];
int new_i = -1;
for (int i = 0; i <= n; i++) vis[i] = 0;
for (int i = 0; i < m; i++) {
cin >> ch >> tmp;
if (ch == '-' && vis[tmp] == 0) {
new_i = i;
tp.insert(tmp);
}
vis[tmp] = 1;
vec.push_back(make_pair(ch, tmp));
}
for (int i = 1; i <= n; i++)
if (vis[i] == 0) s.insert(i);
if (new_i < 0) {
if (find(vec[0].second)) s.insert(vec[0].second);
} else {
if (find(vec[new_i].second)) s.insert(vec[new_i].second);
}
cout << s.size() << endl;
if (s.size()) {
for (set<int>::iterator itr = s.begin(); itr != s.end(); itr++)
cout << *itr << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Aka Beko, trying to escape from 40 bandits, got lost in the city of A. Aka Beko wants to go to City B, where the new hideout is, but the map has been stolen by a bandit.
Kobborg, one of the thieves, sympathized with Aka Beko and felt sorry for him. So I secretly told Aka Beko, "I want to help you go to City B, but I want to give you direct directions because I have to keep out of my friends, but I can't tell you. I can answer. "
When Kobborg receives the question "How about the route XX?" From Aka Beko, he answers Yes if it is the route from City A to City B, otherwise. Check the directions according to the map below.
<image>
Each city is connected by a one-way street, and each road has a number 0 or 1. Aka Beko specifies directions by a sequence of numbers. For example, 0100 is the route from City A to City B via City X, Z, and W. If you choose a route that is not on the map, you will get lost in the desert and never reach City B. Aka Beko doesn't know the name of the city in which she is, so she just needs to reach City B when she finishes following the directions.
Kobborg secretly hired you to create a program to answer questions from Aka Beko. If you enter a question from Aka Beko, write a program that outputs Yes if it is the route from City A to City B, otherwise it outputs No.
input
The input consists of multiple datasets. The end of the input is indicated by a single # (pound) line. Each dataset is given in the following format.
p
A sequence of numbers 0, 1 indicating directions is given on one line. p is a string that does not exceed 100 characters.
The number of datasets does not exceed 100.
output
Print Yes or No on one line for each dataset.
Example
Input
0100
0101
10100
01000
0101011
0011
011111
#
Output
Yes
No
Yes
No
Yes
No
Yes
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int serch(int go,int now)
{
int direction[6][2]={{1,2},{-1,3},{1,-1},{4,5},{5,2},{2,1}};
if(now==-1)return -1;
return direction[now][go];
}
int main()
{
string str;
while(cin>>str&&str!="#"){
int now=0;
for(int i=0;i<str.size();i++)now=serch(str[i]-'0',now);
if(now==5)cout<<"Yes\n";
else cout<<"No\n";
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
This is an interactive problem.
You are given a sorted in increasing order singly linked list. You should find the minimum integer in the list which is greater than or equal to x.
More formally, there is a singly liked list built on an array of n elements. Element with index i contains two integers: valuei is the integer value in this element, and nexti that is the index of the next element of the singly linked list (or -1, if the current element is the last). The list is sorted, i.e. if nexti ≠ - 1, then valuenexti > valuei.
You are given the number of elements in the list n, the index of the first element start, and the integer x.
You can make up to 2000 queries of the following two types:
* ? i (1 ≤ i ≤ n) — ask the values valuei and nexti,
* ! ans — give the answer for the problem: the minimum integer, greater than or equal to x, or ! -1, if there are no such integers. Your program should terminate after this query.
Write a program that solves this problem.
Input
The first line contains three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109) — the number of elements in the list, the index of the first element and the integer x.
Output
To print the answer for the problem, print ! ans, where ans is the minimum integer in the list greater than or equal to x, or -1, if there is no such integer.
Interaction
To make a query of the first type, print ? i (1 ≤ i ≤ n), where i is the index of element you want to know information about.
After each query of type ? read two integers valuei and nexti (0 ≤ valuei ≤ 109, - 1 ≤ nexti ≤ n, nexti ≠ 0).
It is guaranteed that if nexti ≠ - 1, then valuenexti > valuei, and that the array values give a valid singly linked list with start being the first element.
Note that you can't ask more than 1999 queries of the type ?.
If nexti = - 1 and valuei = - 1, then it means that you asked more queries than allowed, or asked an invalid query. Your program should immediately terminate (for example, by calling exit(0)). You will receive "Wrong Answer", it means that you asked more queries than allowed, or asked an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Your solution will get "Idleness Limit Exceeded", if you don't print anything or forget to flush the output, including the final answer.
To flush you can use (just after printing a query and line end):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* For other languages see documentation.
Hacks format
For hacks, use the following format:
In the first line print three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109).
In the next n lines print the description of the elements of the list: in the i-th line print two integers valuei and nexti (0 ≤ valuei ≤ 109, - 1 ≤ nexti ≤ n, nexti ≠ 0).
The printed structure should be a valid singly linked list. In particular, it should be possible to reach all elements from start by following links nexti, and the last element end should have -1 in the nextend.
Example
Input
5 3 80
97 -1
58 5
16 2
81 1
79 4
Output
? 1
? 2
? 3
? 4
? 5
! 81
Note
You can read more about singly linked list by the following link: <https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list>
The illustration for the first sample case. Start and finish elements are marked dark. <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int val[65536], nxt[65536];
bool vis[65536], in[65536];
int q = 1999;
void query(int i) {
assert(i > 0);
if (vis[i]) return;
cout << "? " << i << endl;
cin >> val[i] >> nxt[i];
if (nxt[i] == -1 && val[i] == -1) exit(0);
vis[i] = true;
--q;
if (nxt[i] > 0) in[nxt[i]] = true;
}
void answer(int y) {
cout << "! " << y << endl;
exit(0);
}
int main() {
canhazfast();
int n, start, x, i;
int ans = 1234567890;
mt19937_64 rng(time(nullptr));
vector<int> ids;
cin >> n >> start >> x;
i = start;
ids.resize(n);
iota((ids).begin(), (ids).end(), 1);
shuffle((ids).begin(), (ids).end(), rng);
while (i > 0 && q > 1000 && !ids.empty()) {
query(i);
if (val[i] >= x) break;
int j = ids.back();
ids.pop_back();
query(j);
if (val[j] >= x)
ans = min(ans, val[j]);
else if (val[i] < val[j])
i = j;
}
while (i > 0) {
query(i);
if (val[i] >= x) answer(val[i]);
i = nxt[i];
}
answer(-1);
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You have m = n·k wooden staves. The i-th stave has length ai. You have to assemble n barrels consisting of k staves each, you can use any k staves to construct a barrel. Each stave must belong to exactly one barrel.
Let volume vj of barrel j be equal to the length of the minimal stave in it.
<image>
You want to assemble exactly n barrels with the maximal total sum of volumes. But you have to make them equal enough, so a difference between volumes of any pair of the resulting barrels must not exceed l, i.e. |vx - vy| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n.
Print maximal total sum of volumes of equal enough barrels or 0 if it's impossible to satisfy the condition above.
Input
The first line contains three space-separated integers n, k and l (1 ≤ n, k ≤ 105, 1 ≤ n·k ≤ 105, 0 ≤ l ≤ 109).
The second line contains m = n·k space-separated integers a1, a2, ..., am (1 ≤ ai ≤ 109) — lengths of staves.
Output
Print single integer — maximal total sum of the volumes of barrels or 0 if it's impossible to construct exactly n barrels satisfying the condition |vx - vy| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n.
Examples
Input
4 2 1
2 2 1 2 3 2 2 3
Output
7
Input
2 1 0
10 10
Output
20
Input
1 2 1
5 2
Output
2
Input
3 2 1
1 2 3 4 5 6
Output
0
Note
In the first example you can form the following barrels: [1, 2], [2, 2], [2, 3], [2, 3].
In the second example you can form the following barrels: [10], [10].
In the third example you can form the following barrels: [2, 5].
In the fourth example difference between volumes of barrels in any partition is at least 2 so it is impossible to make barrels equal enough.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int n, k, l, a[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> l;
for (int i = 0; i < n * k; i++) cin >> a[i];
sort(a, a + n * k);
long long ans = 0;
for (int i = 0; i < n * k; i += k) {
if (a[i] - a[0] <= l) {
ans += a[i];
} else {
int r = n - i / k;
for (int j = i - 1; j >= 0 && r > 0; j--) {
if ((j % k) && a[j] - a[0] <= l) {
ans += a[j];
r--;
}
}
if (r > 0) ans = 0;
break;
}
}
cout << ans;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
One day as Petya and his friend Vasya were having one of their numerous trips, they decided to visit a museum castle. The museum has a specific shape: it consists of n rooms connected with m corridors so that one can access any room from any other one.
After the two friends had a little walk around the museum, they decided to split and watch the pieces of art each of them found interesting. They agreed to meet in one of the rooms at six p.m. However, they forgot one quite essential thing: they didn't specify the place to meet and when the time came, they started to rush about the museum looking for each other (they couldn't call each other as roaming made a call's cost skyrocket).
Yet, even despite the whole rush, they couldn't get enough of the pieces of art, that's why each of them has the following strategy: each minute he make a decision where to go — with probability pi he doesn't move to any other place during this minute (i.e. he stays in the room). With probability 1 - pi he equiprobably choose one of the adjacent rooms and went there along the corridor. Here i is the ordinal number of the current room. Building was expensive in ancient times, that's why each corridor connected two different rooms, and any two rooms had no more than one corridor between them.
The boys act simultaneously. As the corridors are dark, it is impossible to meet there; however, one can walk along the corridors in both directions (besides, the two boys can be going through the same corridor simultaneously without meeting). The boys act like that until they meet each other. More formally, the two friends meet when at some moment of time both of them decided to appear in the same room.
For each room find the probability that the boys will meet there considering that at 6 p.m. they are positioned in rooms a and b correspondingly.
Input
The first line contains four integers: n (1 ≤ n ≤ 22), representing the numbers of rooms; m <image>, representing the number of corridors; a, b (1 ≤ a, b ≤ n), representing the numbers of Petya's and Vasya's starting rooms correspondingly.
Next m lines contain pairs of numbers — the numbers of rooms connected by a corridor. Next n lines contain probabilities pi (0.01 ≤ pi ≤ 0.99) with the accuracy of up to four digits after the decimal point — the probability to stay in room i.
It is guaranteed that every room can be reached from every other room by corridors.
Output
In the only line print n space-separated numbers, the i-th number should represent the probability that the friends meet in the i-th room with absolute or relative error of no more than 10 - 6.
Examples
Input
2 1 1 2
1 2
0.5
0.5
Output
0.5000000000 0.5000000000
Input
4 4 1 2
1 2
2 3
3 4
4 1
0.5
0.5
0.5
0.5
Output
0.3333333333 0.3333333333 0.1666666667 0.1666666667
Note
In the first sample the museum is symmetric. That means the probabilities to meet in rooms 1 and 2 are equal. And their sum equals to one. So, each probability equals 0.5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, stateCnt;
vector<vector<int> > g;
vector<double> stayP;
double prob[300][300], buf[300][300];
int state[30][30];
int getState(int a, int b) {
if (a > b) swap(a, b);
return state[a][b];
}
void mult() {
memset(buf, 0, sizeof(buf));
for (int i = 0; i < stateCnt; i++)
for (int j = 0; j < stateCnt; j++)
for (int k = 0; k < stateCnt; k++) buf[i][j] += prob[i][k] * prob[k][j];
memcpy(prob, buf, sizeof(buf));
}
void clean() {
for (int i = 0; i < stateCnt; i++)
for (int j = 0; j < stateCnt; j++)
if (prob[i][j] < 1e-10) prob[i][j] = 0;
}
int main() {
cin >> n >> m >> a >> b;
stateCnt = 0;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
state[i][j] = stateCnt;
stateCnt++;
}
a--, b--;
g.resize(n);
stayP.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) cin >> stayP[i];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
if (i == j)
prob[getState(i, j)][getState(i, j)] = 1;
else {
prob[getState(i, j)][getState(i, j)] = stayP[i] * stayP[j];
double ta = (1 - stayP[i]) / (int)((g[i]).size());
double tb = (1 - stayP[j]) / (int)((g[j]).size());
for (int b = 0; b < (int)((g[j]).size()); b++) {
int tob = g[j][b];
prob[getState(i, j)][getState(i, tob)] += stayP[i] * tb;
}
for (int a = 0; a < (int)((g[i]).size()); a++) {
int toa = g[i][a];
prob[getState(i, j)][getState(toa, j)] += ta * stayP[j];
}
for (int a = 0; a < (int)((g[i]).size()); a++)
for (int b = 0; b < (int)((g[j]).size()); b++) {
int toa = g[i][a];
int tob = g[j][b];
prob[getState(i, j)][getState(toa, tob)] += ta * tb;
}
}
}
for (int i = 0; i < 50; i++) {
mult();
clean();
}
int t = getState(a, b);
cout.precision(9);
for (int i = 0; i < n; i++) cout << prob[t][getState(i, i)] << ' ';
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Find places where a string P is found within a text T. Print all indices of T where P found. The indices of T start with 0.
Constraints
* 1 ≤ length of T ≤ 1000
* 1 ≤ length of P ≤ 1000
* The input consists of alphabetical characters and digits
Input
In the first line, a text T is given. In the second line, a string P is given.
Examples
Input
aabaaa
aa
Output
0
3
4
Input
xyzz
yz
Output
1
Input
abc
xyz
Output
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main() {
string T, P;
int p = 0;
cin >> T >> P;
while(p < int(T.length() - P.length() + 1)) {
if(p == (int)T.find(P,p)) {
cout << (int)T.find(P, p) << endl;
}
p++;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Omkar has a pie tray with k (2 ≤ k ≤ 20) spots. Each spot in the tray contains either a chocolate pie or a pumpkin pie. However, Omkar does not like the way that the pies are currently arranged, and has another ideal arrangement that he would prefer instead.
To assist Omkar, n elves have gathered in a line to swap the pies in Omkar's tray. The j-th elf from the left is able to swap the pies at positions a_j and b_j in the tray.
In order to get as close to his ideal arrangement as possible, Omkar may choose a contiguous subsegment of the elves and then pass his pie tray through the subsegment starting from the left. However, since the elves have gone to so much effort to gather in a line, they request that Omkar's chosen segment contain at least m (1 ≤ m ≤ n) elves.
Formally, Omkar may choose two integers l and r satisfying 1 ≤ l ≤ r ≤ n and r - l + 1 ≥ m so that first the pies in positions a_l and b_l will be swapped, then the pies in positions a_{l + 1} and b_{l + 1} will be swapped, etc. until finally the pies in positions a_r and b_r are swapped.
Help Omkar choose a segment of elves such that the amount of positions in Omkar's final arrangement that contain the same type of pie as in his ideal arrangement is the maximum possible. Note that since Omkar has a big imagination, it might be that the amounts of each type of pie in his original arrangement and in his ideal arrangement do not match.
Input
The first line contains three integers n, m, and k (1 ≤ m ≤ n ≤ 10^6 and 2 ≤ k ≤ 20) — the number of elves, the minimum subsegment length, and the number of spots in Omkar's tray respectively.
The second and third lines each contain a string of length k consisting of 0s and 1s that represent initial arrangement of pies and ideal arrangement of pies; the j-th character in each string is equal to 0 if the j-th spot in the arrangement contains a chocolate pie and is equal to 1 if the j-th spot in the arrangement contains a pumpkin pie. It is not guaranteed that the two strings have the same amount of 0s or the same amount of 1s.
n lines follow. The j-th of these lines contains two integers a_j and b_j (1 ≤ a_j, b_j ≤ k, a_j ≠ b_j) which indicate that the j-th elf from the left can swap the pies at positions a_j and b_j in the tray.
Output
Output two lines.
The first line should contain a single integer s (0 ≤ s ≤ k) equal to the amount of positions that contain the same type of pie in Omkar's final arrangement and in Omkar's ideal arrangement; s should be the maximum possible.
The second line should contain two integers l and r satisfying 1 ≤ l ≤ r ≤ n and r - l + 1 ≥ m, indicating that Omkar should pass his tray through the subsegment l, l + 1, ..., r to achieve a final arrangement with s positions having the same type of pie as his ideal arrangement.
If there are multiple answers you may output any of them.
Examples
Input
4 2 5
11000
00011
1 3
3 5
4 2
3 4
Output
5
1 3
Input
4 3 5
11000
00011
1 3
1 5
2 4
1 5
Output
3
1 4
Note
In the first test case, the swaps will go like this:
* Swap 1 and 3: 11000 becomes 01100
* Swap 3 and 5: 01100 becomes 01001
* Swap 4 and 2: 01001 becomes 00011
The final arrangement is the same as the ideal arrangement 00011, so there are 5 positions with the same type of pie, which is optimal.
In the second test case, the swaps will go like this:
* Swap 1 and 3: 11000 becomes 01100
* Swap 1 and 5: 01100 becomes 01100
* Swap 4 and 2: 01100 becomes 00110
* Swap 1 and 5: 00110 becomes 00110
The final arrangement has 3 positions with the same type of pie as the ideal arrangement 00011, those being positions 1, 2, and 4. In this case the subsegment of elves (l, r) = (2, 3) is more optimal, but that subsegment is only length 2 and therefore does not satisfy the constraint that the subsegment be of length at least m = 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string s;
string ss;
int aa[21];
int bb[21];
int pre3[1 << 10];
pair<int, int> dp[1100][1100];
void add(int i, int j) {
int xx = (i - (i & (1023))) / 1024;
for (int ii = 0; ii < (1 << 10); ii++) {
int mm = pre3[((i & 1023) ^ ii)];
if (dp[ii][xx].first == -1) {
dp[ii][xx] = {mm, j + 1};
}
if (mm < dp[ii][xx].first) {
dp[ii][xx] = {mm, j + 1};
}
}
}
pair<int, int> it[1000001];
int pre[1000001];
int pre2[1000001];
int vis[1000001];
int vis2[1000001];
int vis3[1 << 20];
int cur[21];
int ans = -1;
pair<int, int> cot;
void remin(int ac, pair<int, int> dd) {
if (ac > ans) {
ans = ac;
cot = dd;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
cin >> s;
cin >> ss;
for (int i = 0; i < k; i++) {
aa[i] = s[i] - '0';
bb[i] = ss[i] - '0';
}
for (int i = 0; i < n; i++) {
cin >> it[i].first >> it[i].second;
it[i].first--;
it[i].second--;
}
for (int i = 0; i < k; i++) {
cur[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
if (aa[j] == 1) {
pre[i] += (1 << cur[j]);
}
}
swap(cur[it[i].first], cur[it[i].second]);
}
for (int i = 0; i < k; i++) {
cur[i] = i;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < k; j++) {
if (bb[j] == 1) {
pre2[i] += (1 << cur[j]);
}
}
if (i == n) {
break;
}
swap(cur[it[i].first], cur[it[i].second]);
}
long long yy = 0;
for (int i = n; i >= 0; i--) {
if (vis3[pre2[i]]) {
continue;
}
vis3[pre2[i]] = 1;
vis[i] = 1;
yy += 1;
}
assert(yy <= 200000);
for (int i = 0; i < (1 << 20); i++) {
vis3[i] = 0;
}
for (int i = 0; i < (1 << 10); i++) {
pre3[i] = __builtin_popcount(i);
}
for (int i = 0; i < n; i++) {
if (vis3[pre[i]]) {
continue;
}
vis3[pre[i]] = 1;
vis2[i] = 1;
}
for (int i = 0; i < (1 << 10); i++) {
for (int ii = 0; ii < (1 << 10); ii++) {
dp[i][ii] = {-1, -1};
}
}
for (int i = 1; i <= n; i++) {
if (i >= m) {
if (vis2[i - m]) {
add(pre[i - m], i - m);
}
}
if (vis[i]) {
int pp = (pre2[i] & (1023));
int qq = (pre2[i] - pp) / 1024;
for (int j = 0; j < (1 << 10); j++) {
if (dp[pp][j].first > -1) {
int cost = k - dp[pp][j].first;
cost -= pre3[j ^ qq];
remin(cost, {dp[pp][j].second, i});
}
}
}
}
cout << ans << endl;
cout << cot.first << " " << cot.second << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
This problem consists of three subproblems: for solving subproblem C1 you will receive 4 points, for solving subproblem C2 you will receive 4 points, and for solving subproblem C3 you will receive 8 points.
Manao decided to pursue a fighter's career. He decided to begin with an ongoing tournament. Before Manao joined, there were n contestants in the tournament, numbered from 1 to n. Each of them had already obtained some amount of tournament points, namely the i-th fighter had pi points.
Manao is going to engage in a single fight against each contestant. Each of Manao's fights ends in either a win or a loss. A win grants Manao one point, and a loss grants Manao's opponent one point. For each i, Manao estimated the amount of effort ei he needs to invest to win against the i-th contestant. Losing a fight costs no effort.
After Manao finishes all of his fights, the ranklist will be determined, with 1 being the best rank and n + 1 being the worst. The contestants will be ranked in descending order of their tournament points. The contestants with the same number of points as Manao will be ranked better than him if they won the match against him and worse otherwise. The exact mechanism of breaking ties for other fighters is not relevant here.
Manao's objective is to have rank k or better. Determine the minimum total amount of effort he needs to invest in order to fulfill this goal, if it is possible.
Input
The first line contains a pair of integers n and k (1 ≤ k ≤ n + 1). The i-th of the following n lines contains two integers separated by a single space — pi and ei (0 ≤ pi, ei ≤ 200000).
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem C1 (4 points), the constraint 1 ≤ n ≤ 15 will hold.
* In subproblem C2 (4 points), the constraint 1 ≤ n ≤ 100 will hold.
* In subproblem C3 (8 points), the constraint 1 ≤ n ≤ 200000 will hold.
Output
Print a single number in a single line — the minimum amount of effort Manao needs to use to rank in the top k. If no amount of effort can earn Manao such a rank, output number -1.
Examples
Input
3 2
1 1
1 4
2 2
Output
3
Input
2 1
3 2
4 0
Output
-1
Input
5 2
2 10
2 10
1 1
3 1
3 1
Output
12
Note
Consider the first test case. At the time when Manao joins the tournament, there are three fighters. The first of them has 1 tournament point and the victory against him requires 1 unit of effort. The second contestant also has 1 tournament point, but Manao needs 4 units of effort to defeat him. The third contestant has 2 points and victory against him costs Manao 2 units of effort. Manao's goal is top be in top 2. The optimal decision is to win against fighters 1 and 3, after which Manao, fighter 2, and fighter 3 will all have 2 points. Manao will rank better than fighter 3 and worse than fighter 2, thus finishing in second place.
Consider the second test case. Even if Manao wins against both opponents, he will still rank third.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int MOD = 1000000007;
struct Node {
int p, e;
void input() { scanf("%d %d", &p, &e); }
bool operator<(const Node &n) const { return p > n.p; }
} a[N];
int n, k;
int main() {
scanf("%d %d", &n, &k);
k--;
for (int i = 0; i < n; i++) {
a[i].input();
}
long long ans = 1LL << 60;
sort(a, a + n);
for (int d = -2; d < 3; d++) {
int score = a[k].p + d, before = 0;
long long ret = 0;
priority_queue<int, vector<int>, less<int> > large;
priority_queue<int, vector<int>, greater<int> > small;
for (int i = 0; i < n; i++) {
if (a[i].p <= score && a[i].p >= score - 1) {
large.push(a[i].e);
} else {
if (a[i].p > score) before++;
small.push(a[i].e);
}
}
if (before > k) continue;
while (!large.empty()) {
if (before < k) {
small.push(large.top());
before++;
} else {
score--;
ret += large.top();
}
large.pop();
}
while (score > 0 && !small.empty()) {
ret += small.top();
small.pop();
score--;
}
if (score <= 0) ans = min(ans, ret);
}
if (ans == 1LL << 60) ans = -1;
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Drazil is playing a math game with Varda.
Let's define <image> for positive integer x as a product of factorials of its digits. For example, <image>.
First, they choose a decimal number a consisting of n digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number x satisfying following two conditions:
1. x doesn't contain neither digit 0 nor digit 1.
2. <image> = <image>.
Help friends find such number.
Input
The first line contains an integer n (1 ≤ n ≤ 15) — the number of digits in a.
The second line contains n digits of a. There is at least one digit in a that is larger than 1. Number a may possibly contain leading zeroes.
Output
Output a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation.
Examples
Input
4
1234
Output
33222
Input
3
555
Output
555
Note
In the first case, <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 5;
const long long mod = 10000000000000007;
const long long nary = 9;
long long a;
int ans[100], n;
int main() {
while (scanf("%d%I64d", &n, &a) != EOF) {
n = 0;
while (a > 0) {
int d = (int)(a % 10);
a /= (long long)10;
if (d == 9) {
d -= 2;
ans[++n] = 3;
ans[++n] = 3;
ans[++n] = 2;
}
if (d == 8) {
d--;
ans[++n] = 2;
ans[++n] = 2;
ans[++n] = 2;
}
if (d == 6) {
d--;
ans[++n] = 3;
}
if (d == 4) {
d--;
ans[++n] = 2;
ans[++n] = 2;
}
if (d > 1) ans[++n] = d;
}
sort(ans + 1, ans + n + 1);
for (int i = n; i > 0; i--) printf("%d", ans[i]);
printf("\n");
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Stick n circular stickers with a radius of 1 on a square origami paper with a side length of 10. The stickers can be stacked. Create a program that reads the coordinates of the position where the stickers are to be attached and outputs the number of stickers at the place where the stickers overlap most on the origami paper (assuming that even one sticker "overlaps"). ..
Gives the x and y coordinates with the lower left corner of the origami as the origin. Let's put the sticker with these x and y as the center of the circle. The center of the circle never goes out of the origami. Also, multiple stickers will not be attached at the same coordinates.
Hint
It is a figure with a sticker attached as shown in the input example. The circle represents the sticker, and the number represents the number of lines in the input example. At point (2.3, 4.6), the four stickers on the second, third, sixth, and tenth lines of the input example overlap.
<image>
The distance between the centers of 6 and 9 is 2.01293, so the seals do not overlap. The distance between the centers of 1 and 12 is 1.98231, so the seals overlap.
When two circles are in contact (when the distance between the centers is 2), they are assumed to overlap.
Input
Given multiple datasets. Each dataset is given in the following format:
n
x1, y1
x2, y2
::
xn, yn
The first line gives the number of stickers n (0 ≤ 100). The next n lines give the center coordinates of each seal. xi and yi represent the x and y coordinates of the center of the i-th sticker. Each value is given as a real number, including up to 6 digits after the decimal point.
When n is 0, it is the end of the input. The number of datasets does not exceed 50.
Output
For each data set, output the number of stickers (integer) at the place where the stickers overlap most on the origami paper.
Example
Input
15
3.14979,8.51743
2.39506,3.84915
2.68432,5.39095
5.61904,9.16332
7.85653,4.75593
2.84021,5.41511
1.79500,8.59211
7.55389,8.17604
4.70665,4.66125
1.63470,4.42538
7.34959,4.61981
5.09003,8.11122
5.24373,1.30066
0.13517,1.83659
7.57313,1.58150
0
Output
4
### Response
```cpp
#include<iostream>
#include<cfloat>
#include<cassert>
#include<cmath>
#include<vector>
#include<algorithm>
#include<stdio.h>
using namespace std;
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS )
#define dle(a, b) (equals(a, b) || a < b )
static const double PI = acos(-1);
class Point{
public:
double x, y;
Point ( double x = 0, double y = 0): x(x), y(y){}
Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
Point operator * ( double a ){ return Point(x*a, y*a); }
Point operator / ( double a ){ return Point(x/a, y/a); }
double abs() { return sqrt(norm());}
double norm() { return x*x + y*y; }
void rotate(double s,Point g = Point(0.0,0.0)){
x=x-g.x;
y=y-g.y;
double nx=x*cos(s)-y*sin(s);
double ny=x*sin(s)+y*cos(s);
x=nx+g.x;
y=ny+g.y;
}
bool operator < ( const Point &p ) const {
return x != p.x ? x < p.x : y < p.y;
}
bool operator == ( const Point &p ) const {
return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
}
};
typedef Point Vector;
double getDistance(Point a,Point b){
return sqrt(pow(a.x-b.x,2.0)+pow(a.y-b.y,2.0));
}
//PerfectCircle
class Circle{
public:
Point o;
double r;
Circle ( Point o = Point(0.0,0.0), double r = 0.0): o(o), r(r){}
double area() { return r*r*PI; }
};
int getCrossState(Circle a,Circle b){
double x=getDistance(a.o,b.o);
if(x+b.r < a.r)return 2;
else if(x+a.r<b.r)return -2;
else if(x<=a.r+b.r)return 1;
else return 0;
}
vector<Point> getCrossPoints(Circle a,Circle b){
vector<Point> res;
if(getCrossState(a,b)!=1){
return res;
}
double n = getDistance(a.o,b.o);
double rate = b.r/(a.r+b.r);
n*=rate;
double h = sqrt(abs(b.r * b.r - n*n));
//cout<<a.o.y<<" "<<b.o.y<<endl;
Point g = b.o+((a.o-b.o)*rate);
//cout<<g.x<<' '<<g.y<<endl;
Vector gb = b.o-g;
gb.rotate( PI/2.0);
res.push_back(g + gb*(h/gb.abs()));
if(abs(h)<EPS)return res;
gb.rotate(PI);
res.push_back(g + gb*(h/gb.abs()));
return res;
}
int main(){
Circle t[100];
vector <Point> crosspoints,tmp;
int n,cnt,ans;
char ch;
while(cin>>n){
if(n==0)break;
crosspoints.clear();
tmp.clear();
for(int i=0;i<n;i++){
cin>>t[i].o.x>>ch>>t[i].o.y;
t[i].r=1.0;
for(int j=i-1;j>=0;j--){
tmp=getCrossPoints(t[i],t[j]);
for(int k=0;k<(int)tmp.size();k++){
if(tmp[k].x<0.0||tmp[k].y<0.0)continue;
if(tmp[k].x>10.0||tmp[k].y>10.0)continue;
crosspoints.push_back(tmp[k]);
}//k
}//j
}//i
crosspoints.push_back(Point(0.0,0.0));
crosspoints.push_back(Point(10.0,0.0));
crosspoints.push_back(Point(0.0,10.0));
crosspoints.push_back(Point(10.0,10.0));
ans=0;
for(int i=0;i<(int)crosspoints.size();i++){
//cout<<crosspoints[i].x<<" "<<crosspoints[i].y<<endl;
cnt=0;
for(int j=0;j<n;j++){
if(getDistance(crosspoints[i],t[j].o)<=t[j].r+EPS)cnt++;
}
ans=max(ans,cnt);
}
cout<<ans<<endl;
}//while
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Professor GukiZ has two arrays of integers, a and b. Professor wants to make the sum of the elements in the array a sa as close as possible to the sum of the elements in the array b sb. So he wants to minimize the value v = |sa - sb|.
In one operation professor can swap some element from the array a and some element from the array b. For example if the array a is [5, 1, 3, 2, 4] and the array b is [3, 3, 2] professor can swap the element 5 from the array a and the element 2 from the array b and get the new array a [2, 1, 3, 2, 4] and the new array b [3, 3, 5].
Professor doesn't want to make more than two swaps. Find the minimal value v and some sequence of no more than two swaps that will lead to the such value v. Professor makes swaps one by one, each new swap he makes with the new arrays a and b.
Input
The first line contains integer n (1 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n integers ai ( - 109 ≤ ai ≤ 109) — the elements of the array a.
The third line contains integer m (1 ≤ m ≤ 2000) — the number of elements in the array b.
The fourth line contains m integers bj ( - 109 ≤ bj ≤ 109) — the elements of the array b.
Output
In the first line print the minimal value v = |sa - sb| that can be got with no more than two swaps.
The second line should contain the number of swaps k (0 ≤ k ≤ 2).
Each of the next k lines should contain two integers xp, yp (1 ≤ xp ≤ n, 1 ≤ yp ≤ m) — the index of the element in the array a and the index of the element in the array b in the p-th swap.
If there are several optimal solutions print any of them. Print the swaps in order the professor did them.
Examples
Input
5
5 4 3 2 1
4
1 1 1 1
Output
1
2
1 1
4 2
Input
5
1 2 3 4 5
1
15
Output
0
0
Input
5
1 2 3 4 5
4
1 2 3 4
Output
1
1
3 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long A[3000], B[3000];
vector<long long> VA, VB;
unordered_map<long long, pair<int, int> > MA, MB;
int X1, Y1, X2, Y2;
long long diff = 0;
long long mindiff;
long long sa = 0, sb = 0;
long long t = 0;
void check(int j, int i) {
diff = llabs(sa - sb - VA[i] + VB[j]);
if (diff < mindiff) {
mindiff = diff;
X1 = MA[VA[i]].first;
X2 = MA[VA[i]].second;
Y1 = (MB[VB[j]]).first;
Y2 = MB[VB[j]].second;
}
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, j;
cin >> n;
for (i = 0; i < n; i++) cin >> A[i];
cin >> m;
for (j = 0; j < m; j++) cin >> B[j];
sa = accumulate(A, A + n, 0LL);
sb = accumulate(B, B + m, 0LL);
if (sa == sb) {
cout << "0\n0";
return 0;
}
mindiff = llabs(sa - sb);
X1 = -1;
Y1 = -1;
X2 = -1;
Y2 = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
diff = llabs(sa - sb - 2 * A[i] + 2 * B[j]);
if (diff < mindiff) {
mindiff = diff;
X1 = i;
Y1 = j;
}
}
}
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) {
VA.push_back(2LL * (A[i] + A[j]));
MA[2LL * (A[i] + A[j])] = pair<int, int>(i, j);
}
for (i = 0; i < m; i++)
for (j = i + 1; j < m; j++) {
VB.push_back(2LL * (B[i] + B[j]));
MB[2LL * (B[i] + B[j])] = pair<int, int>(i, j);
}
sort(VA.begin(), VA.end());
sort(VB.begin(), VB.end());
for (i = 0; i < VB.size(); i++) {
t = sa - sb + VB[i];
int pos = (int)(lower_bound(VA.begin(), VA.end(), t) - VA.begin());
if (pos == VA.size()) {
if (pos == 0)
continue;
else
check(i, pos - 1);
} else if (pos == 0) {
if (pos == VA.size() - 1)
check(i, pos);
else {
check(i, pos);
check(i, pos + 1);
}
} else if (pos == VA.size() - 1) {
if (pos == 0)
check(i, pos);
else {
check(i, pos);
check(i, pos - 1);
}
} else {
check(i, pos);
check(i, pos + 1);
check(i, pos - 1);
}
}
if (X1 == -1 && Y1 == -1) {
cout << mindiff << "\n0\n";
} else if (X2 == -1 && Y2 == -1) {
cout << mindiff << "\n";
cout << 1 << "\n";
cout << X1 + 1 << " " << Y1 + 1;
} else {
cout << mindiff << "\n";
cout << 2 << "\n";
cout << X1 + 1 << " " << Y1 + 1 << "\n";
cout << X2 + 1 << " " << Y2 + 1;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Phoenix has a string s consisting of lowercase Latin letters. He wants to distribute all the letters of his string into k non-empty strings a_1, a_2, ..., a_k such that every letter of s goes to exactly one of the strings a_i. The strings a_i do not need to be substrings of s. Phoenix can distribute letters of s and rearrange the letters within each string a_i however he wants.
For example, if s = baba and k=2, Phoenix may distribute the letters of his string in many ways, such as:
* ba and ba
* a and abb
* ab and ab
* aa and bb
But these ways are invalid:
* baa and ba
* b and ba
* baba and empty string (a_i should be non-empty)
Phoenix wants to distribute the letters of his string s into k strings a_1, a_2, ..., a_k to minimize the lexicographically maximum string among them, i. e. minimize max(a_1, a_2, ..., a_k). Help him find the optimal distribution and print the minimal possible value of max(a_1, a_2, ..., a_k).
String x is lexicographically less than string y if either x is a prefix of y and x ≠ y, or there exists an index i (1 ≤ i ≤ min(|x|, |y|)) such that x_i < y_i and for every j (1 ≤ j < i) x_j = y_j. Here |x| denotes the length of the string x.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. Each test case consists of two lines.
The first line of each test case consists of two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the length of string s and the number of non-empty strings, into which Phoenix wants to distribute letters of s, respectively.
The second line of each test case contains a string s of length n consisting only of lowercase Latin letters.
It is guaranteed that the sum of n over all test cases is ≤ 10^5.
Output
Print t answers — one per test case. The i-th answer should be the minimal possible value of max(a_1, a_2, ..., a_k) in the i-th test case.
Example
Input
6
4 2
baba
5 2
baacb
5 3
baacb
5 3
aaaaa
6 4
aaxxzz
7 1
phoenix
Output
ab
abbc
b
aa
x
ehinopx
Note
In the first test case, one optimal solution is to distribute baba into ab and ab.
In the second test case, one optimal solution is to distribute baacb into abbc and a.
In the third test case, one optimal solution is to distribute baacb into ac, ab, and b.
In the fourth test case, one optimal solution is to distribute aaaaa into aa, aa, and a.
In the fifth test case, one optimal solution is to distribute aaxxzz into az, az, x, and x.
In the sixth test case, one optimal solution is to distribute phoenix into ehinopx.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, n, k;
cin >> t;
while (t--) {
string s;
set<char> st;
cin >> n >> k >> s;
sort(s.begin(), s.end());
vector<string> si(k);
long long first_count = (upper_bound(s.begin(), s.end(), s[0]) - s.begin());
if (k == 1) {
cout << s << '\n';
} else if (k > first_count) {
cout << s[k - 1] << '\n';
} else {
for (long long i = k; i < n; i++) {
st.insert(s[i]);
}
long long dist = st.size();
if (dist == 1) {
string ans;
long long ind = 0;
while (ind < n) {
ans += s[ind];
ind += k;
}
cout << ans << '\n';
} else {
string ans;
ans += s[0];
for (long long i = k; i < n; i++) {
ans += s[i];
}
cout << ans << '\n';
}
}
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Example
Input
4 4
1 2 3
1 3 3
2 3 3
2 4 3
Output
1 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
#define repn(i,x) for(int i=1;i<=x;i++)
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
int n,m;
vector<P1>edge[10005];
int par[505],ran[505];
void init(){ for(int i=0;i<505;i++) par[i] = i; }
int find(int x){ if(x == par[x]) return x; else return par[x] = find(par[x]); }
void unite(int x,int y){
x = find(x); y = find(y); if(x==y) return;
if(ran[x] < ran[y]) par[x] = y;
else{
par[y] = x;
if(ran[x] == ran[y]) ran[x]++;
}
}
bool same(int x,int y){ return find(x)==find(y); }
vector<P>G[505];
int cnt[505];
bool used[505];
int dep[505];
vector<P>H[505];
int cnty;
ll sum;
void dfs(int v,int u,int d){
if(used[v]) return;
dep[v] = d; used[v] = 1;
for(int i=0;i<G[v].size();i++){
int to = G[v][i].fi;
if(to == u) continue;
if(!used[to]){
H[v].pb(G[v][i]);
dfs(to,v,d+1);
//cout<<v<<" "<<to<<endl;
}
else{
if(dep[v] > dep[to]){
cnt[v]++;
cnt[to]--;
}
else{
cnt[v]--;
cnt[to]++;
}
//cout<<v<<"a "<<to<<endl;
}
}
}
int dfs2(int v,int u,int add){
int x = cnt[v];
for(int i=0;i<H[v].size();i++){
int to = H[v][i].fi;
int nm = H[v][i].sc;
int ret = dfs2(to,v,add);
if(ret == 0){
cnty++;
sum+=add;
}
x += ret;
}
return x;
}
int main(){
cin>>n>>m;
rep(i,m){
int a,b,d; cin>>a>>b>>d;
edge[d].pb(mp(i,mp(a,b)));
}
init();
rep(i,10005){
rep(i,505){
G[i].clear();
H[i].clear();
}
rep(j,edge[i].size()){
int a = edge[i][j].sc.fi;
int b = edge[i][j].sc.sc;
a = find(a);
b = find(b);
if(a != b){
G[a].pb(mp(b,edge[i][j].fi));
G[b].pb(mp(a,edge[i][j].fi));
}
}
memset(used,0,sizeof(used));
memset(cnt,0,sizeof(cnt));
rep(j,505){
if(used[j]) continue;
dfs(j,-1,0);
dfs2(j,0,i);
}
rep(j,edge[i].size()){
int a = edge[i][j].sc.fi;
int b = edge[i][j].sc.sc;
unite(a,b);
}
}
cout<<cnty<<" "<<sum<<endl;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Little Alyona is celebrating Happy Birthday! Her mother has an array of n flowers. Each flower has some mood, the mood of i-th flower is ai. The mood can be positive, zero or negative.
Let's define a subarray as a segment of consecutive flowers. The mother suggested some set of subarrays. Alyona wants to choose several of the subarrays suggested by her mother. After that, each of the flowers will add to the girl's happiness its mood multiplied by the number of chosen subarrays the flower is in.
For example, consider the case when the mother has 5 flowers, and their moods are equal to 1, - 2, 1, 3, - 4. Suppose the mother suggested subarrays (1, - 2), (3, - 4), (1, 3), (1, - 2, 1, 3). Then if the girl chooses the third and the fourth subarrays then:
* the first flower adds 1·1 = 1 to the girl's happiness, because he is in one of chosen subarrays,
* the second flower adds ( - 2)·1 = - 2, because he is in one of chosen subarrays,
* the third flower adds 1·2 = 2, because he is in two of chosen subarrays,
* the fourth flower adds 3·2 = 6, because he is in two of chosen subarrays,
* the fifth flower adds ( - 4)·0 = 0, because he is in no chosen subarrays.
Thus, in total 1 + ( - 2) + 2 + 6 + 0 = 7 is added to the girl's happiness. Alyona wants to choose such subarrays from those suggested by the mother that the value added to her happiness would be as large as possible. Help her do this!
Alyona can choose any number of the subarrays, even 0 or all suggested by her mother.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100) — the number of flowers and the number of subarrays suggested by the mother.
The second line contains the flowers moods — n integers a1, a2, ..., an ( - 100 ≤ ai ≤ 100).
The next m lines contain the description of the subarrays suggested by the mother. The i-th of these lines contain two integers li and ri (1 ≤ li ≤ ri ≤ n) denoting the subarray a[li], a[li + 1], ..., a[ri].
Each subarray can encounter more than once.
Output
Print single integer — the maximum possible value added to the Alyona's happiness.
Examples
Input
5 4
1 -2 1 3 -4
1 2
4 5
3 4
1 4
Output
7
Input
4 3
1 2 3 4
1 3
2 4
1 1
Output
16
Input
2 2
-1 -2
1 1
1 2
Output
0
Note
The first example is the situation described in the statements.
In the second example Alyona should choose all subarrays.
The third example has answer 0 because Alyona can choose none of the subarrays.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 9;
const long double eps = -0.00000001;
const long long mod = 1e9 + 7;
int a[MX], l[MX], r[MX];
int main() {
long long n, m, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
for (int i = 0; i < m; i++) {
long long c = 0;
for (int j = l[i]; j <= r[i]; j++) {
c += a[j];
}
if (c >= 0) {
ans += c;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 1e5 + 7, M = 20;
int n, m, cnt[M][M];
int pos[(1 << M) + 7], f[(1 << M) + 7], g[M][(1 << M) + 7], h[(1 << M) + 7];
char s[N];
int main() {
n = read(), m = read();
scanf("%s", s + 1);
for (int i = 1; i < n; i++)
cnt[s[i] - 'a'][s[i + 1] - 'a']++, cnt[s[i + 1] - 'a'][s[i] - 'a']++;
for (int i = 0; i < m; i++) pos[1 << i] = i;
memset(f, 0x3f, sizeof(f));
int mx = (1 << m) - 1;
f[0] = 0;
for (int p = 0; p < m; p++)
for (int o = 1; o < mx; o++) {
if (o & (1 << p)) continue;
g[p][o] = g[p][o - (o & -o)] + cnt[p][pos[o & -o]];
}
for (int o = 0; o < mx; o++)
for (int p = 0; p < m; p++)
if (o & (1 << p)) h[o] += g[p][mx ^ o];
for (int o = 0; o < mx; o++)
for (int p = 0; p < m; p++) {
if (o & (1 << p)) continue;
f[o ^ (1 << p)] = min(f[o ^ (1 << p)], f[o] + h[o]);
}
printf("%d\n", f[mx]);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Mike wants to prepare for IMO but he doesn't know geometry, so his teacher gave him an interesting geometry problem. Let's define f([l, r]) = r - l + 1 to be the number of integer points in the segment [l, r] with l ≤ r (say that <image>). You are given two integers n and k and n closed intervals [li, ri] on OX axis and you have to find:
<image>
In other words, you should find the sum of the number of integer points in the intersection of any k of the segments.
As the answer may be very large, output it modulo 1000000007 (109 + 7).
Mike can't solve this problem so he needs your help. You will help him, won't you?
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 200 000) — the number of segments and the number of segments in intersection groups respectively.
Then n lines follow, the i-th line contains two integers li, ri ( - 109 ≤ li ≤ ri ≤ 109), describing i-th segment bounds.
Output
Print one integer number — the answer to Mike's problem modulo 1000000007 (109 + 7) in the only line.
Examples
Input
3 2
1 2
1 3
2 3
Output
5
Input
3 3
1 3
1 3
1 3
Output
3
Input
3 1
1 2
2 3
3 4
Output
6
Note
In the first example:
<image>;
<image>;
<image>.
So the answer is 2 + 1 + 2 = 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, INV = 1e9 + 5, MAX = 2 * 1e5;
vector<pair<long long, long long> > vec;
long long N, K, total = 0, fac[200010], inv_fac[200010];
long long fastPow(long long N, long long X) {
if (X == 0) return 1;
if (X == 1) return N;
long long temp = fastPow(N, X / 2);
if (X % 2 == 0)
return temp * temp % MOD;
else
return temp * temp % MOD * N % MOD;
}
void factorial() {
fac[0] = 1;
for (long long i = 1; i <= MAX; i++) fac[i] = i * fac[i - 1] % MOD;
}
void inverse_fac() {
for (long long i = 0; i <= MAX; i++) {
inv_fac[i] = fastPow(fac[i], INV);
}
}
long long C(long long n, long long k) {
return fac[n] * inv_fac[k] % MOD * inv_fac[n - k] % MOD;
}
void LineSweep() {
long long cnt = 0, prev = 0;
for (pair<long long, long long> &a : vec) {
if (cnt >= K) total = (total + C(cnt, K) * (a.first - prev) % MOD) % MOD;
cnt += a.second;
prev = a.first;
}
cout << total << '\n';
}
void Solve() {
cin >> N >> K;
for (long long i = 0; i < N; i++) {
long long st, fin;
cin >> st >> fin;
vec.push_back({st, 1});
vec.push_back({fin + 1, -1});
}
sort(vec.begin(), vec.end());
factorial();
inverse_fac();
LineSweep();
}
int main() { Solve(); }
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given a directed weighted graph with n nodes and 2n - 2 edges. The nodes are labeled from 1 to n, while the edges are labeled from 1 to 2n - 2. The graph's edges can be split into two parts.
* The first n - 1 edges will form a rooted spanning tree, with node 1 as the root. All these edges will point away from the root.
* The last n - 1 edges will be from node i to node 1, for all 2 ≤ i ≤ n.
You are given q queries. There are two types of queries
* 1 i w: Change the weight of the i-th edge to w
* 2 u v: Print the length of the shortest path between nodes u to v
Given these queries, print the shortest path lengths.
Input
The first line of input will contain two integers n, q (2 ≤ n, q ≤ 200 000), the number of nodes, and the number of queries, respectively.
The next 2n - 2 integers will contain 3 integers ai, bi, ci, denoting a directed edge from node ai to node bi with weight ci.
The first n - 1 of these lines will describe a rooted spanning tree pointing away from node 1, while the last n - 1 of these lines will have bi = 1.
More specifically,
* The edges (a1, b1), (a2, b2), ... (an - 1, bn - 1) will describe a rooted spanning tree pointing away from node 1.
* bj = 1 for n ≤ j ≤ 2n - 2.
* an, an + 1, ..., a2n - 2 will be distinct and between 2 and n.
The next q lines will contain 3 integers, describing a query in the format described in the statement.
All edge weights will be between 1 and 106.
Output
For each type 2 query, print the length of the shortest path in its own line.
Example
Input
5 9
1 3 1
3 2 2
1 4 3
3 5 4
5 1 5
3 1 6
2 1 7
4 1 8
2 1 1
2 1 3
2 3 5
2 5 2
1 1 100
2 1 3
1 8 30
2 4 2
2 2 4
Output
0
1
4
8
100
132
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> e[200005];
int u[400005], v[400005], w[400005];
int l[200005], r[200005], t;
long long d0[200005], tmh[200005];
void dfs(int x, long long d) {
l[x] = ++t;
d0[x] = d;
for (int eid : e[x]) {
dfs(v[eid], d + w[eid]);
}
r[x] = t;
}
const int MAXN = 262144;
struct tree {
long long mn[2 * MAXN], lazy[2 * MAXN];
void init() {
for (int i = MAXN - 1; i >= 1; i--) {
mn[i] = min(mn[2 * i], mn[2 * i + 1]);
}
}
void push(int x) {
if (x < MAXN) {
lazy[2 * x] += lazy[x];
lazy[2 * x + 1] += lazy[x];
}
mn[x] += lazy[x];
lazy[x] = 0;
}
void add(int l, int r, long long val, int node = 1, int nl = 1,
int nr = MAXN) {
push(node);
if (r < nl || nr < l) {
return;
}
if (l <= nl && nr <= r) {
lazy[node] += val;
push(node);
return;
}
int nm = (nl + nr) >> 1;
add(l, r, val, 2 * node, nl, nm);
add(l, r, val, 2 * node + 1, nm + 1, nr);
mn[node] = min(mn[2 * node], mn[2 * node + 1]);
}
long long get(int l, int r, int node = 1, int nl = 1, int nr = MAXN) {
push(node);
if (r < nl || nr < l) {
return 1e18;
}
if (l <= nl && nr <= r) {
return mn[node];
}
int nm = (nl + nr) >> 1;
return min(get(l, r, 2 * node, nl, nm),
get(l, r, 2 * node + 1, nm + 1, nr));
}
};
tree drvo_dubina, drvo_takemehome;
void update_w(int eid, int nuw) {
int delta = nuw - w[eid];
w[eid] += delta;
if (eid < n) {
drvo_dubina.add(l[v[eid]], r[v[eid]], delta);
drvo_takemehome.add(l[v[eid]], r[v[eid]], delta);
} else {
drvo_takemehome.add(l[u[eid]], l[u[eid]], delta);
}
}
long long find_len(int a, int b) {
if (l[a] <= l[b] && r[b] <= r[a]) {
return drvo_dubina.get(l[b], l[b]) - drvo_dubina.get(l[a], l[a]);
} else {
return drvo_takemehome.get(l[a], r[a]) - drvo_dubina.get(l[a], l[a]) +
find_len(1, b);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int q;
cin >> n >> q;
for (int i = 1; i <= 2 * n - 2; i++) {
cin >> u[i] >> v[i] >> w[i];
if (i < n) {
e[u[i]].push_back(i);
} else {
tmh[u[i]] = w[i];
}
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
drvo_dubina.add(l[i], l[i], d0[i]);
}
for (int i = 1; i <= n; i++) {
drvo_takemehome.add(l[i], l[i], d0[i] + tmh[i]);
}
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
update_w(x, y);
} else {
cout << find_len(x, y) << '\n';
}
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Johnny is at a carnival which has n raffles. Raffle i has a prize with value pi. Each participant can put tickets in whichever raffles they choose (they may have more than one ticket in a single raffle). At the end of the carnival, one ticket is selected at random from each raffle, and the owner of the ticket wins the associated prize. A single person can win multiple prizes from different raffles.
However, county rules prevent any one participant from owning more than half the tickets in a single raffle, i.e. putting more tickets in the raffle than all the other participants combined. To help combat this (and possibly win some prizes), the organizers started by placing a single ticket in each raffle, which they will never remove.
Johnny bought t tickets and is wondering where to place them. Currently, there are a total of li tickets in the i-th raffle. He watches as other participants place tickets and modify their decisions and, at every moment in time, wants to know how much he can possibly earn. Find the maximum possible expected value of Johnny's winnings at each moment if he distributes his tickets optimally. Johnny may redistribute all of his tickets arbitrarily between each update, but he may not place more than t tickets total or have more tickets in a single raffle than all other participants combined.
Input
The first line contains two integers n, t, and q (1 ≤ n, t, q ≤ 200 000) — the number of raffles, the number of tickets Johnny has, and the total number of updates, respectively.
The second line contains n space-separated integers pi (1 ≤ pi ≤ 1000) — the value of the i-th prize.
The third line contains n space-separated integers li (1 ≤ li ≤ 1000) — the number of tickets initially in the i-th raffle.
The last q lines contain the descriptions of the updates. Each description contains two integers tk, rk (1 ≤ tk ≤ 2, 1 ≤ rk ≤ n) — the type of the update and the raffle number. An update of type 1 represents another participant adding a ticket to raffle rk. An update of type 2 represents another participant removing a ticket from raffle rk.
It is guaranteed that, after each update, each raffle has at least 1 ticket (not including Johnny's) in it.
Output
Print q lines, each containing a single real number — the maximum expected value of Johnny's winnings after the k-th update. Your answer will be considered correct if its absolute or relative 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 <image>.
Examples
Input
2 1 3
4 5
1 2
1 1
1 2
2 1
Output
1.666666667
1.333333333
2.000000000
Input
3 20 5
6 8 10
6 6 6
1 1
1 2
1 3
2 3
2 3
Output
12.000000000
12.000000000
11.769230769
12.000000000
12.000000000
Note
In the first case, Johnny only has one ticket to distribute. The prizes are worth 4 and 5, and the raffles initially have 1 and 2 tickets, respectively. After the first update, each raffle has 2 tickets, so Johnny has expected value <image> of winning by placing his ticket into the second raffle. The second update adds a ticket to the second raffle, so Johnny can win <image> in the first raffle. After the final update, Johnny keeps his ticket in the first raffle and wins <image>.
In the second case, Johnny has more tickets than he is allowed to spend. In particular, after the first update, there are 7, 6, and 6 tickets in each raffle, respectively, so Johnny can only put in 19 tickets, winning each prize with probability <image>. Also, note that after the last two updates, Johnny must remove a ticket from the last raffle in order to stay under <image> the tickets in the third raffle.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int MAXN = 1 << 18;
const int MOD = 1;
long long gcd(long long a, long long b) {
a = abs(a), b = abs(b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
double d(long long a, long long b) { return a * 1.0 / b; }
int n, t, q;
int ct;
int p[MAXN], l[MAXN];
long long cnt[MAXN];
double ans;
double ifAdd[MAXN], ifDel[MAXN];
set<pair<double, int> > stAdd, stDel;
void setIfAdd(int id) {
if (cnt[id] == l[id])
ifAdd[id] = -10000;
else
ifAdd[id] = d(p[id] * (cnt[id] + 1), cnt[id] + 1 + l[id]) -
d(p[id] * cnt[id], cnt[id] + l[id]);
}
void setIfDel(int id) {
if (cnt[id] == 0)
ifDel[id] = 10000;
else
ifDel[id] = d(p[id] * cnt[id], cnt[id] + l[id]) -
d(p[id] * (cnt[id] - 1), cnt[id] + l[id] - 1);
}
double getExp(int id) { return cnt[id] * p[id] * 1.0 / (l[id] + cnt[id]); }
void addTicket(int id) {
stAdd.erase(make_pair(ifAdd[id], id));
stDel.erase(make_pair(ifDel[id], id));
ans -= getExp(id);
cnt[id]++, ct++;
setIfAdd(id);
setIfDel(id);
ans += getExp(id);
stAdd.insert(make_pair(ifAdd[id], id));
stDel.insert(make_pair(ifDel[id], id));
}
void delTicket(int id) {
stAdd.erase(make_pair(ifAdd[id], id));
stDel.erase(make_pair(ifDel[id], id));
ans -= getExp(id);
cnt[id]--, ct--;
setIfAdd(id);
setIfDel(id);
ans += getExp(id);
stAdd.insert(make_pair(ifAdd[id], id));
stDel.insert(make_pair(ifDel[id], id));
}
void init() {
stAdd.clear();
stDel.clear();
ans = 0;
ct = 0;
for (int i = 0; i < n; i++) {
cnt[i] = 0;
setIfAdd(i);
setIfDel(i);
stAdd.insert(make_pair(ifAdd[i], i));
stDel.insert(make_pair(ifDel[i], i));
}
for (int i = 0; i < t; i++) {
int id = stAdd.rbegin()->second;
if (!(d(0, 1) < stAdd.rbegin()->first)) continue;
addTicket(id);
}
}
void fix(int id) {
stAdd.erase(make_pair(ifAdd[id], id));
stDel.erase(make_pair(ifDel[id], id));
if (cnt[id] > l[id]) cnt[id]--, ct--;
while (ct < t && cnt[id] < l[id]) cnt[id]++, ct++;
while (!stAdd.empty()) {
setIfAdd(id);
setIfDel(id);
if (ifDel[id] < stAdd.rbegin()->first) {
int nid = stAdd.rbegin()->second;
addTicket(nid);
cnt[id]--;
ct--;
} else
break;
}
while (!stDel.empty()) {
setIfAdd(id);
setIfDel(id);
if (stDel.begin()->first < ifAdd[id]) {
int nid = stDel.begin()->second;
delTicket(nid);
cnt[id]++;
ct++;
} else
break;
}
while (ct < t) {
if (d(0, 1) < stAdd.rbegin()->first) {
addTicket(stAdd.rbegin()->second);
} else
break;
}
setIfAdd(id);
setIfDel(id);
stAdd.insert(make_pair(ifAdd[id], id));
stDel.insert(make_pair(ifDel[id], id));
}
int main() {
while (scanf("%d%d%d", &n, &t, &q) == 3) {
for (int i = 0; i < n; i++) scanf("%d", &p[i]);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
init();
for (int i = 0; i < q; i++) {
int t, id;
scanf("%d%d", &t, &id);
--id;
ans -= getExp(id);
if (t == 1) {
l[id]++;
}
if (t == 2) {
l[id]--;
}
fix(id);
ans += getExp(id);
printf("%.15f\n", ans);
}
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Abendsen assigned a mission to Juliana. In this mission, Juliana has a rooted tree with n vertices. Vertex number 1 is the root of this tree. Each vertex can be either black or white. At first, all vertices are white. Juliana is asked to process q queries. Each query is one of three types:
1. If vertex v is white, mark it as black; otherwise, perform this operation on all direct sons of v instead.
2. Mark all vertices in the subtree of v (including v) as white.
3. Find the color of the i-th vertex.
<image> An example of operation "1 1" (corresponds to the first example test). The vertices 1 and 2 are already black, so the operation goes to their sons instead.
Can you help Juliana to process all these queries?
Input
The first line contains two integers n and q (2≤ n≤ 10^5, 1≤ q≤ 10^5) — the number of vertices and the number of queries.
The second line contains n-1 integers p_2, p_3, …, p_n (1≤ p_i<i), where p_i means that there is an edge between vertices i and p_i.
Each of the next q lines contains two integers t_i and v_i (1≤ t_i≤ 3, 1≤ v_i≤ n) — the type of the i-th query and the vertex of the i-th query.
It is guaranteed that the given graph is a tree.
Output
For each query of type 3, print "black" if the vertex is black; otherwise, print "white".
Examples
Input
8 10
1 2 1 2 5 4 5
1 2
3 2
3 1
1 1
1 1
3 5
3 7
3 4
2 2
3 5
Output
black
white
black
white
black
white
Input
8 11
1 1 2 3 3 6 6
1 1
1 1
1 3
3 2
3 4
3 6
3 7
2 3
1 6
3 7
3 6
Output
black
white
black
white
white
black
Note
The first example is shown on the picture below.
<image>
The second example is shown on the picture below.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
int n, q;
vector<int> adj[N];
int in[N], out[N];
int sz[N], head[N], par[N];
int timer;
void dfs(int u) {
sz[u] = 1;
for (auto& v : adj[u]) {
par[v] = u;
dfs(v);
sz[u] += sz[v];
if (sz[v] > sz[adj[u][0]]) swap(v, adj[u][0]);
}
}
void dfsHLD(int u) {
in[u] = ++timer;
if (adj[u].size()) {
head[adj[u][0]] = head[u];
dfsHLD(adj[u][0]);
}
for (auto v : adj[u])
if (v != adj[u][0]) {
head[v] = v;
dfsHLD(v);
}
out[u] = timer;
}
int lz[N << 2];
struct node {
int sum, mx;
node(int sum = -n * 2, int mx = -n * 2) : sum(sum), mx(mx) {}
} tree[N << 2];
node merge(node L, node R) {
if (L.sum == -n * 2) return R;
if (R.sum == -n * 2) return L;
return node(L.sum + R.sum, max(R.mx, L.mx + R.sum));
}
void build(int o, int s, int e) {
if (s == e) {
tree[o] = node(-1, -1);
} else {
int md = (s + e) >> 1;
build(o << 1, s, md);
build(o << 1 | 1, md + 1, e);
tree[o] = merge(tree[o << 1], tree[o << 1 | 1]);
}
}
void push(int o, int s, int e) {
if (!lz[o]) return;
tree[o] = node(-(e - s + 1), -1);
if (s != e) {
lz[o << 1] = lz[o << 1 | 1] = 1;
}
lz[o] = 0;
}
void upd(int o, int s, int e, int l, int r) {
push(o, s, e);
if (r < s || e < l) return;
if (l <= s && e <= r) {
lz[o] = 1;
push(o, s, e);
} else {
int md = (s + e) >> 1;
upd(o << 1, s, md, l, r);
upd(o << 1 | 1, md + 1, e, l, r);
tree[o] = merge(tree[o << 1], tree[o << 1 | 1]);
}
}
void updIdx(int o, int s, int e, int idx, int v) {
push(o, s, e);
if (idx < s || e < idx) return;
if (s == e) {
tree[o].sum += v;
tree[o].mx += v;
return;
}
int md = (s + e) >> 1;
updIdx(o << 1, s, md, idx, v);
updIdx(o << 1 | 1, md + 1, e, idx, v);
tree[o] = merge(tree[o << 1], tree[o << 1 | 1]);
}
node qry(int o, int s, int e, int l, int r) {
push(o, s, e);
if (r < s || e < l) return node();
if (l <= s && e <= r) {
return tree[o];
}
int md = (s + e) >> 1;
return merge(qry(o << 1, s, md, l, r), qry(o << 1 | 1, md + 1, e, l, r));
}
node get(int u) {
node ret = node();
while (head[u] != 1) {
ret = merge(qry(1, 1, n, in[head[u]], in[u]), ret);
u = par[head[u]];
}
ret = merge(qry(1, 1, n, 1, in[u]), ret);
return ret;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
adj[p].push_back(i);
}
dfs(1);
head[1] = 1;
dfsHLD(1);
build(1, 1, n);
while (q--) {
int tp, u;
scanf("%d%d", &tp, &u);
if (tp == 1) {
updIdx(1, 1, n, in[u], 1);
} else if (tp == 2) {
upd(1, 1, n, in[u], out[u]);
node cur = get(u);
if (cur.mx >= 0) {
updIdx(1, 1, n, in[u], -cur.mx - 1);
}
} else {
node cur = get(u);
puts(cur.mx < 0 ? "white" : "black");
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A duck hunter is doing his favorite thing, hunting. He lives in a two dimensional world and is located at point (0, 0). As he doesn't like walking for his prey, he prefers to shoot only vertically up (because in this case, the ducks fall straight into his hands). The hunter doesn't reload the gun immediately — r or more seconds must pass between the shots. When the hunter shoots up, the bullet immediately hits all the ducks who are directly above the hunter.
In a two dimensional world each duck is a horizontal segment that moves horizontally in the negative direction of the Ox axis at the speed 1 length unit per second. For each duck we know the values hi and ti — the x-coordinates of its head (the left end of the segment) and its tail (the right end of the segment) at time 0. The height where the duck is flying isn't important as the gun shoots vertically up to the infinite height and hits all the ducks on its way.
<image> The figure to the first sample.
What maximum number of ducks can the hunter shoot? The duck is considered shot by the hunter if at the moment of the shot at least one of its point intersects the Oy axis. After the hunter shoots the duck, it falls and it can't be shot anymore. The hunter cannot make shots before the moment of time 0.
Input
The first line of the input contains integers n, r (1 ≤ n ≤ 200 000, 1 ≤ r ≤ 109) — the number of ducks and the minimum time in seconds between the shots.
Then n lines follow, each of them contains two integers hi, ti ( - 109 ≤ hi < ti ≤ 109) — the x-coordinate of the head and tail of the i-th duck at the moment 0.
Output
Print a single integer — the maximum number of ducks that can be shot by the hunter.
Examples
Input
3 3
-3 0
1 3
-1 2
Output
3
Input
4 5
-1 1
2 4
5 9
6 8
Output
3
Note
In the first sample the hunter must shoot at time 0, this shot kills ducks 1 and 3. Then the hunter needs to reload the gun and shoot again at time 3. His second shot hits the tail of duck 2.
In the second sample the hunter can make shots at times 0 and 6 to hit three ducks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
struct Node {
int mx, add;
Node *ch[2];
Node() {}
Node(int mx, int add) : mx(mx), add(add) { ch[0] = ch[1] = NULL; }
};
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
int query(Node *rt, int ql, int qr, int l = 0, int r = inf) {
if (!rt || ql > qr) return 0;
if (ql <= l && r <= qr) return rt->mx;
int ret = 0, mid = l + r >> 1;
if (ql <= mid) ret = max(ret, query(rt->ch[0], ql, qr, l, mid));
if (qr > mid) ret = max(ret, query(rt->ch[1], ql, qr, mid + 1, r));
return ret + rt->add;
}
void up(Node *rt) {
rt->mx =
max((rt->ch[0] ? rt->ch[0]->mx : 0), (rt->ch[1] ? rt->ch[1]->mx : 0)) +
rt->add;
}
void modify(Node *&rt, int ql, int v, int l = 0, int r = inf) {
if (!rt) rt = new Node(0, 0);
if (l == r) {
rt->mx = v;
} else {
int mid = l + r >> 1;
if (ql <= mid)
modify(rt->ch[0], ql, v, l, mid);
else
modify(rt->ch[1], ql, v, mid + 1, r);
up(rt);
}
}
void insert(Node *&rt, int ql, int qr, int l = 0, int r = inf) {
if (!rt) rt = new Node(0, 0);
if (ql <= l && r <= qr) {
rt->mx++;
rt->add++;
} else {
int mid = l + r >> 1;
if (ql <= mid) {
insert(rt->ch[0], ql, qr, l, mid);
}
if (qr > mid) {
insert(rt->ch[1], ql, qr, mid + 1, r);
}
up(rt);
}
}
int main() {
Node *rt = new Node(0, 0);
int n, k, l, r;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d%d", &l, &r);
l = max(0, l);
if (r >= 0) {
pq.push({r, l});
pq.push({l, -2});
}
}
int pre = -1, preValue = 0;
while (!pq.empty()) {
int l = pq.top().second, r = pq.top().first;
pq.pop();
if (l < 0) {
if (pre == r) continue;
int v = query(rt, 0, r - k);
if (l == -2 || v > preValue) {
modify(rt, r, v);
pre = r;
preValue = v;
if (r + k <= inf) {
pq.push({r + k, -1});
}
}
} else {
insert(rt, l, r);
}
}
printf("%d\n", rt->mx);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
People like to be fit. That's why many of them are ready to wake up at dawn, go to the stadium and run. In this problem your task is to help a company design a new stadium.
The city of N has a shabby old stadium. Many people like it and every morning thousands of people come out to this stadium to run. The stadium can be represented as a circle, its length is exactly l meters with a marked start line. However, there can't be simultaneous start in the morning, so exactly at 7, each runner goes to his favorite spot on the stadium and starts running from there. Note that not everybody runs in the same manner as everybody else. Some people run in the clockwise direction, some of them run in the counter-clockwise direction. It mostly depends on the runner's mood in the morning, so you can assume that each running direction is equiprobable for each runner in any fixed morning.
The stadium is tiny and is in need of major repair, for right now there only is one running track! You can't get too playful on a single track, that's why all runners keep the same running speed — exactly 1 meter per a time unit. Nevertheless, the runners that choose different directions bump into each other as they meet.
The company wants to design a new stadium, but they first need to know how bad the old one is. For that they need the expectation of the number of bumpings by t time units after the running has begun. Help the company count the required expectation. Note that each runner chooses a direction equiprobably, independently from the others and then all runners start running simultaneously at 7 a.m. Assume that each runner runs for t time units without stopping. Consider the runners to bump at a certain moment if at that moment they found themselves at the same point in the stadium. A pair of runners can bump more than once.
Input
The first line of the input contains three integers n, l, t (1 ≤ n ≤ 106, 1 ≤ l ≤ 109, 1 ≤ t ≤ 109). The next line contains n distinct integers a1, a2, ..., an (0 ≤ a1 < a2 < ... < an < l), here ai is the clockwise distance from the start line to the i-th runner's starting position.
Output
Print a single real number — the answer to the problem with absolute or relative error of at most 10 - 6.
Examples
Input
2 5 1
0 2
Output
0.2500000000
Input
3 7 3
0 1 6
Output
1.5000000000
Note
There are two runners in the first example. If the first runner run clockwise direction, then in 1 time unit he will be 1m away from the start line. If the second runner run counter-clockwise direction then in 1 time unit he will be also 1m away from the start line. And it is the only possible way to meet. We assume that each running direction is equiprobable, so the answer for the example is equal to 0.5·0.5 = 0.25.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const long long LINF = 1e15;
const int N_ = 2500005;
long long N, L, B;
long long P, Q;
long long D[N_];
double res;
int main() {
int i, j, k;
scanf("%I64d%I64d%I64d", &N, &L, &B);
P = (B * 2) / L;
Q = (B * 2) % L;
res += (double)P * (double)N * (double)(N - 1) * 2;
for (i = 1; i <= N; i++) {
scanf("%I64d", &D[i]);
}
for (i = 1; i <= N; i++) D[i + N] = D[i] + L;
for (i = 1, k = 2; i <= N; i++) {
while (k <= 2 * N && D[k] <= D[i] + Q) ++k;
res += (double)(k - i - 1);
}
for (i = 2 * N, k = 2 * N - 1; i > N; i--) {
while (k > 0 && D[k] >= D[i] - Q) --k;
res += (double)(i - k - 1);
}
if (res >= (1ll << 30)) res += 1;
printf("%.10lf\n", res / 8.);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
### Response
```cpp
#include<iostream>
using namespace std;
int P,Q,A,N;
int accum(int p,int q,int depth,int dono,int prd){
if(p==0)return 1;
int res=0;
for(int i=dono;prd*i<=A;i++){
if((N-depth)*q<i*p)break;
if(p*i<q)continue;
res+=accum(p*i-q,q*i,depth+1,i,prd*i);
//cout<<depth<<" "<<res<<endl;
}
return res;
}
int main(){
while(cin>>P>>Q>>A>>N,A) cout<<accum(P,Q,0,1,1)<<endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Takahashi loves takoyaki - a ball-shaped snack.
With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.
How long does it take to make N takoyaki?
Constraints
* 1 \leq N,X,T \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N X T
Output
Print an integer representing the minimum number of minutes needed to make N pieces of takoyaki.
Examples
Input
20 12 6
Output
12
Input
1000 1 1000
Output
1000000
### Response
```cpp
#include <iostream>
using namespace std;
int main() {
int n,x,t;
cin>>n>>x>>t;
int a=(n+x-1)/x;
cout<<a*t;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
mt19937 rng(steady_clock::now().time_since_epoch().count());
const long long mod = 998244353;
long long madd(long long a, long long b) { return (a + b) % mod; }
long long msub(long long a, long long b) {
return (((a - b) % mod) + mod) % mod;
}
long long mmul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long mpow(long long base, long long exp) {
long long res = 1;
while (exp) {
if (exp % 2 == 1) {
res = (res * base) % mod;
}
exp >>= 1;
base = (base * base) % mod;
}
return res;
}
long long minv(long long base) { return mpow(base, mod - 1); }
long long mdiv(long long a, long long b) { return mmul(a, minv(b)); }
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool prime[10000006];
void sieve(int n) {
for (long long i = 0; i < n + 1; i++) prime[i] = 1;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
prime[1] = prime[0] = 0;
}
long long n, q, Q, T, m, k, l, r, x, y, z, g;
vector<long long> turns[200002][3];
long long dp[200001][11];
long long a[11];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> k;
for (long long j = 0; j < k; j++) {
cin >> x >> y;
turns[i + 1][--x].push_back(y);
}
for (long long j = 0; j < 3; j++) {
sort(turns[i + 1][j].begin(), turns[i + 1][j].end());
reverse(turns[i + 1][j].begin(), turns[i + 1][j].end());
}
}
for (long long i = 0; i < n + 1; i++)
for (long long j = 0; j < 10; j++) dp[i][j] = -1;
for (long long j = 0; j < 10; j++) dp[0][j] = -1;
dp[0][0] = 0;
for (long long i = 1; i < n + 1; i++) {
for (long long j = 0; j < 10; j++) a[j] = -1;
for (long long j = 0; j < 10; j++) {
if (dp[i - 1][j] != -1) {
a[j] = max(a[j], dp[i - 1][j]);
if (j + 1 > 9) {
if (turns[i][0].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][0][0]);
if (turns[i][1].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][1][0]);
if (turns[i][2].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][2][0]);
} else {
if (turns[i][0].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][0][0]);
if (turns[i][1].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][1][0]);
if (turns[i][2].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][2][0]);
}
if (j + 2 > 9) {
if (turns[i][0].size() > 1)
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + 2 * turns[i][0][0] + turns[i][0][1]);
if (turns[i][0].size() && turns[i][1].size())
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + 2 * max(turns[i][0][0], turns[i][1][0]) +
min(turns[i][0][0], turns[i][1][0]));
} else {
if (turns[i][0].size() > 1)
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + turns[i][0][0] + turns[i][0][1]);
if (turns[i][0].size() && turns[i][1].size())
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + turns[i][0][0] + turns[i][1][0]);
}
if (j + 3 > 9) {
if (turns[i][0].size() > 2)
a[(j + 3) % 10] =
max(a[(j + 3) % 10], dp[i - 1][j] + 2 * turns[i][0][0] +
turns[i][0][1] + turns[i][0][2]);
} else {
if (turns[i][0].size() > 2)
a[(j + 3) % 10] =
max(a[(j + 3) % 10], dp[i - 1][j] + turns[i][0][0] +
turns[i][0][1] + turns[i][0][2]);
}
}
}
for (long long j = 0; j < 10; j++) dp[i][j] = a[j];
}
long long ans = 0;
for (long long i = 0; i < 10; i++) ans = max(dp[n][i], ans);
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Sonya was unable to think of a story for this problem, so here comes the formal description.
You are given the array containing n positive integers. At one turn you can pick any element and increase or decrease it by 1. The goal is the make the array strictly increasing by making the minimum possible number of operations. You are allowed to change elements in any way, they can become negative or equal to 0.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 3000) — the length of the array.
Next line contains n integer ai (1 ≤ ai ≤ 109).
Output
Print the minimum number of operation required to make the array strictly increasing.
Examples
Input
7
2 1 5 11 5 9 11
Output
9
Input
5
5 4 3 2 1
Output
12
Note
In the first sample, the array is going to look as follows:
2 3 5 6 7 9 11
|2 - 2| + |1 - 3| + |5 - 5| + |11 - 6| + |5 - 7| + |9 - 9| + |11 - 11| = 9
And for the second sample:
1 2 3 4 5
|5 - 1| + |4 - 2| + |3 - 3| + |2 - 4| + |1 - 5| = 12
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long d[3333][3333], a[3333], b[3333];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
int bn = unique(b + 1, b + 1 + n) - b - 1;
memset(d, 127, sizeof(d));
for (int i = 1; i <= bn; ++i) {
d[1][i] = min(d[1][i - 1], abs(a[1] - b[i]));
}
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= bn; ++j) {
d[i][j] = min(d[i][j - 1], d[i - 1][j] + abs(a[i] - b[j]));
}
}
printf("%I64d", d[n][bn]);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
problem
President K decided to make a flag for IOI 2016 in Russia. Chairman K first took out the old flag from the warehouse. This flag is divided into squares of N rows and M columns, and each square is painted in one of white, blue, and red.
Chairman K is trying to repaint some of the squares on this flag to make it the Russian flag. However, the Russian flag in this problem is as follows.
* Several lines (one or more lines) from the top are all painted in white.
* The next few lines (one or more lines) are all painted in blue.
* All the cells in the other lines (one or more lines) are painted in red.
Find the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
input
The input consists of 1 + N lines.
On the first line, two integers N and M (3 ≤ N ≤ 50, 3 ≤ M ≤ 50) are written separated by a blank. This means that the flags are separated by N rows and M columns.
The following N lines each contain a string of M characters, which represents the color information painted in the squares of the old flag. The jth character (1 ≤ i ≤ N, 1 ≤ j ≤ M) on the i-th line of the N-line represents the color of the cell on the i-th line and j-th column of the old flag. It is either B'or'R'. 'W' stands for white,'B' stands for blue, and'R' stands for red.
output
Output in one line the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
Input / output example
Input example 1
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output example 1
11
Input example 2
6 14
WWWWWWWWWWWWWW
WBBBWWRRWWBBBW
WWBWWRRRRWWBWW
BWBWWRRRRWWBWW
WBBWWWRRWWBBBW
WWWWWWWWWWWWWW
Output example 2
44
In I / O example 1, the old flag is colored as shown in the figure below.
fig01
In the figure below, repaint the 11 squares with an'X'.
fig02
This makes it possible to make the Russian flag as shown in the figure below.
fig03
Since it is not possible to make a Russian flag by repainting less than 11 squares, 11 is output.
In I / O example 2, the old flag is colored as shown in the figure below.
fig04
Creative Commons License
Information Olympics Japan Committee work "15th Japan Information Olympics JOI 2015/2016 Qualifying Competition Tasks"
Example
Input
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int count(int sy, int ey, int W, vector< string >& f, char c) {
int ret = 0;
for (int y=sy; y<ey; ++y) for (int x=0; x<W; ++x) if (f[y][x] != c) ++ret;
return ret;
}
int main() {
int N, M;
cin >> N >> M;
vector< string > f(N);
for (int i=0; i<N; ++i) cin >> f[i];
int ans = N * M;
for (int s=1; s<N-1; ++s) for (int t=s+1; t<N; ++t) {
int w = count(0, s, M, f, 'W');
int b = count(s, t, M, f, 'B');
int r = count(t, N, M, f, 'R');
ans = min(ans, w + b + r);
}
cout << ans << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Taro is a member of a programming contest circle. In this circle, the members manage their schedules in the system called Great Web Calender.
Taro has just added some of his friends to his calendar so that he can browse their schedule on his calendar. Then he noticed that the system currently displays all the schedules in only one color, mixing the schedules for all his friends. This is difficult to manage because it's hard to tell whose schedule each entry is.
But actually this calender system has the feature to change the color of schedule entries, based on the person who has the entries. So Taro wants to use that feature to distinguish their plans by color.
Given the colors Taro can use and the number of members, your task is to calculate the subset of colors to color all schedule entries. The colors are given by "Lab color space".
In Lab color space, the distance between two colors is defined by the square sum of the difference of each element. Taro has to pick up the subset of colors that maximizes the sum of distances of all color pairs in the set.
Input
The input is like the following style.
N M
L_{0} a_{0} b_{0}
L_{1} a_{1} b_{1}
...
L_{N-1} a_{N-1} b_{N-1}
The first line contains two integers N and M (0 \leq M \leq N \leq 20), where N is the number of colors in the input, and M is the number of friends Taro wants to select the colors for. Each of the following N lines contains three decimal integers L(0.0 \leq L \leq 100.0), a(-134.0 \leq a \leq 220.0) and b(-140.0 \leq b \leq 122.0) which represents a single color in Lab color space.
Output
Output the maximal of the total distance. The output should not contain an error greater than 10^{-5}.
Examples
Input
3 2
0 0 0
10 10 10
100 100 100
Output
30000.00000000000000000000
Input
5 3
12.0 15.0 9.0
10.0 -3.0 2.2
3.5 6.8 9.0
2.1 4.4 5.9
1.2 4.0 -5.4
Output
1003.44000000000005456968
Input
2 1
1.0 1.0 1.0
0.0 0.0 0.0
Output
0.00000000000000000000
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
int n, m;
double l[20], a[20], b[20];
vector<int> use;
// idx以降でk個選ぶときの最大値
double dfs(int idx, int k){
double res = 0;
if (k == 0){
for (int i = 0; i < use.size(); i++)
{
for (int j = 0; j < i; j++)
{
double dl = l[use[i]] - l[use[j]];
double da = a[use[i]] - a[use[j]];
double db = b[use[i]] - b[use[j]];
res += dl*dl + da*da + db*db;
}
}
}
else
{
for (int i = idx; i < n - k + 1; i++)
{
use.push_back(i);
res = max(res, dfs(i+1, k - 1));
use.pop_back();
}
}
return res;
}
int main(){
while (cin >> n >> m && n | m)
{
for (int i = 0; i < n; i++)
{
cin >> l[i] >> a[i] >> b[i];
}
cout << fixed << setprecision(20) << dfs(0, m) << endl;
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
At Akabe High School, which is a programmer training school, the roles of competition programmers in team battles are divided into the following three types.
C: | Coder | I am familiar with the language and code.
--- | --- | ---
A: | Algorithm | I am good at logical thinking and think about algorithms.
N: | Navigator | Good at reading comprehension, analyze and debug problems.
At this high school, a team of three people is formed in one of the following formations.
CCA: | Well-balanced and stable
--- | ---
CCC: | Fast-paced type with high risk but expected speed
CAN: | Careful solving of problems accurately
As a coach of the Competitive Programming Department, you take care every year to combine these members and form as many teams as possible. Therefore, create a program that outputs the maximum number of teams that can be created when the number of coders, the number of algorithms, and the number of navigators are given as inputs.
input
The input consists of one dataset. Input data is given in the following format.
Q
c1 a1 n1
c2 a2 n2
::
cQ aQ nQ
Q (0 ≤ Q ≤ 100) on the first line is the number of years for which you want to find the number of teams. The number of people by role in each year is given to the following Q line. Each row is given the number of coders ci (0 ≤ ci ≤ 1000), the number of algorithms ai (0 ≤ ai ≤ 1000), and the number of navigators ni (0 ≤ ni ≤ 1000).
output
Output the maximum number of teams that can be created on one line for each year.
Example
Input
4
3 0 0
1 1 1
9 4 1
0 1 2
Output
1
1
4
0
### Response
```cpp
#include <stdio.h>
int min(int a, int b) {
return a < b ? a : b;
}
int main(void) {
int i, j, k, q, c, a, n;
scanf("%d", &q);
for(i = 0; i < q; ++i) {
int ans = 0, t;
scanf("%d%d%d", &c, &a, &n);
ans = min(c, min(a, n));
c -= ans, a -= ans, n -= ans;
ans += min(c / 2, a);
t = min(c / 2, a);
c -= 2 * t, a -= t;
ans += c / 3;
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Taro is planning a long trip by train during the summer vacation. However, in order for Taro, who is a high school student, to travel as far as possible during the summer vacation, which has only one month, he cannot make a good plan unless he finds the cheapest and the fastest way. Let's create a program to help Taro's plan so that he can enjoy a wonderful trip.
<image>
Create a program that outputs the minimum amount or the shortest time in response to inquiries by inputting track information and the number of stations.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
a1 b1 cost1 time1
a2 b2 cost2 time2
::
an bn costn timen
k
p1 q1 r1
p2 q2 r2
::
pk qk rk
The first line gives the number of track information n (1 ≤ n ≤ 3000) and the number of stations m (1 ≤ m ≤ 100).
The following n lines give information on the i-th line. As information on each line, the numbers ai, bi (1 ≤ ai, bi ≤ m) of the two stations connecting the lines, the toll costi (1 ≤ costi ≤ 1000), and the travel time timei (1 ≤ timei ≤ 1000) are given. I will. However, each station shall be numbered in order from 1 to m. If ai and bi are connected by railroad tracks, both ai to bi and bi to ai can be moved at the same rate and time.
The following line is given the number of queries k (1 ≤ k ≤ 200). The next k line is given the i-th query. For each query, the departure station pi, the arrival station qi, and the type of value to output ri (0 or 1) are given. Inquiries must have a route.
The number of datasets does not exceed 50.
Output
Outputs the minimum amount or minimum time on one line for each data set. When ri is 0, the minimum amount is output, and when ri is 1, the minimum time is output.
Example
Input
6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0
Output
450
35
### Response
```cpp
#include <iostream>
using namespace std;
const int inf = 1<<20;
int Cost[100][100];
int Time[100][100];
int main()
{
int n,m,k,a,b,c,t;
while(cin >> n >> m, (n||m))
{
for(int i=0; i<m; i++)
for(int j=0; j<m; j++)
{
Cost[i][j] = Time[i][j] = (i==j?0:inf);
}
while(n--)
{
cin >> a >> b >> c >> t;
a--; b--;
Cost[a][b] = Cost[b][a] = c;
Time[a][b] = Time[b][a] = t;
}
for(int l=0; l<m; l++)
for(int i=0; i<m; i++)
for(int j=0; j<m; j++)
{
if(Time[i][j]>Time[i][l]+Time[l][j]) Time[i][j] = Time[i][l]+Time[l][j];
if(Cost[i][j]>Cost[i][l]+Cost[l][j]) Cost[i][j] = Cost[i][l]+Cost[l][j];
}
cin >> k;
while(k--)
{
cin >> a >> b >> t;
a--; b--;
if(t==0){ cout << Cost[a][b] << endl; }
if(t==1){ cout << Time[a][b] << endl; }
}
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Today, Wet Shark is given n integers. Using any of these integers no more than once, Wet Shark wants to get maximum possible even (divisible by 2) sum. Please, calculate this value for Wet Shark.
Note, that if Wet Shark uses no integers from the n integers, the sum is an even integer 0.
Input
The first line of the input contains one integer, n (1 ≤ n ≤ 100 000). The next line contains n space separated integers given to Wet Shark. Each of these integers is in range from 1 to 109, inclusive.
Output
Print the maximum possible even sum that can be obtained if we use some of the given integers.
Examples
Input
3
1 2 3
Output
6
Input
5
999999999 999999999 999999999 999999999 999999999
Output
3999999996
Note
In the first sample, we can simply take all three integers for a total sum of 6.
In the second sample Wet Shark should take any four out of five integers 999 999 999.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int senar_petit = 1e9 + 1;
long long suma = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
suma += x;
if (x % 2 and x < senar_petit) senar_petit = x;
}
if (suma % 2)
cout << suma - senar_petit << endl;
else
cout << suma << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Alice and Bob play ping-pong with simplified rules.
During the game, the player serving the ball commences a play. The server strikes the ball then the receiver makes a return by hitting the ball back. Thereafter, the server and receiver must alternately make a return until one of them doesn't make a return.
The one who doesn't make a return loses this play. The winner of the play commences the next play. Alice starts the first play.
Alice has x stamina and Bob has y. To hit the ball (while serving or returning) each player spends 1 stamina, so if they don't have any stamina, they can't return the ball (and lose the play) or can't serve the ball (in this case, the other player serves the ball instead). If both players run out of stamina, the game is over.
Sometimes, it's strategically optimal not to return the ball, lose the current play, but save the stamina. On the contrary, when the server commences a play, they have to hit the ball, if they have some stamina left.
Both Alice and Bob play optimally and want to, firstly, maximize their number of wins and, secondly, minimize the number of wins of their opponent.
Calculate the resulting number of Alice's and Bob's wins.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first and only line of each test case contains two integers x and y (1 ≤ x, y ≤ 10^6) — Alice's and Bob's initial stamina.
Output
For each test case, print two integers — the resulting number of Alice's and Bob's wins, if both of them play optimally.
Example
Input
3
1 1
2 1
1 7
Output
0 1
1 1
0 7
Note
In the first test case, Alice serves the ball and spends 1 stamina. Then Bob returns the ball and also spends 1 stamina. Alice can't return the ball since she has no stamina left and loses the play. Both of them ran out of stamina, so the game is over with 0 Alice's wins and 1 Bob's wins.
In the second test case, Alice serves the ball and spends 1 stamina. Bob decides not to return the ball — he loses the play but saves stamina. Alice, as the winner of the last play, serves the ball in the next play and spends 1 more stamina. This time, Bob returns the ball and spends 1 stamina. Alice doesn't have any stamina left, so she can't return the ball and loses the play. Both of them ran out of stamina, so the game is over with 1 Alice's and 1 Bob's win.
In the third test case, Alice serves the ball and spends 1 stamina. Bob returns the ball and spends 1 stamina. Alice ran out of stamina, so she can't return the ball and loses the play. Bob, as a winner, serves the ball in the next 6 plays. Each time Alice can't return the ball and loses each play. The game is over with 0 Alice's and 7 Bob's wins.
### Response
```cpp
/*
* Author: glaucoacassioc
* Created on 2020-11-30, 11:48:30
*/
#include <bits/stdc++.h>
using namespace std;
#define _CRT_SECURE_NO_DEPRECATE
#define INF 0X7f7f7f7
#define all(v) v.begin(), v.end()
#define MOD 1000000007
#define endl "\n"
typedef long long int ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
int32_t main() {
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n, a , b;
cin >> n;
while(n--) {
cin >> a >> b;
cout << --a <<" "<< b << endl;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Japanese video game company has developed the music video game called Step Step Evolution. The gameplay of Step Step Evolution is very simple. Players stand on the dance platform, and step on panels on it according to a sequence of arrows shown in the front screen.
There are eight types of direction arrows in the Step Step Evolution: UP, UPPER RIGHT, RIGHT, LOWER RIGHT, DOWN, LOWER LEFT, LEFT, and UPPER LEFT. These direction arrows will scroll upward from the bottom of the screen. When the direction arrow overlaps the stationary arrow nearby the top, then the player must step on the corresponding arrow panel on the dance platform. The figure below shows how the dance platform looks like.
<image>
Figure 1: the dance platform for Step Step Evolution
In the game, you have to obey the following rule:
* Except for the beginning of the play, you must not press the arrow panel which is not correspond to the edit data.
* The foot must stay upon the panel where it presses last time, and will not be moved until it’s going to press the next arrow panel.
* The left foot must not step on the panel which locates at right to the panel on which the right foot rests. Conversely, the right foot must not step on the panel which locates at left to the panel on which the left foot rests.
As for the third condition, the following figure shows the examples of the valid and invalid footsteps.
<image>
Figure 2: the examples of valid and invalid footsteps
The first one (left foot for LEFT, right foot for DOWN) and the second one (left foot for LOWER LEFT, right foot for UPPER LEFT) are valid footstep. The last one (left foot for RIGHT, right foot for DOWN) is invalid footstep.
Note that, at the beginning of the play, the left foot and right foot can be placed anywhere at the arrow panel. Also, you can start first step with left foot or right foot, whichever you want.
To play this game in a beautiful way, the play style called “ Natural footstep style” is commonly known among talented players. “Natural footstep style” is the style in which players make steps by the left foot and the right foot in turn. However, when a sequence of arrows is difficult, players are sometimes forced to violate this style.
Now, your friend has created an edit data (the original sequence of direction arrows to be pushed) for you. You are interested in how many times you have to violate “Natural footstep style” when you optimally played with this edit data. In other words, what is the minimum number of times you have to step on two consecutive arrows using the same foot?
Input
The input consists of several detasets. Each dataset is specified by one line containing a sequence of direction arrows. Directions are described by numbers from 1 to 9, except for 5. The figure below shows the correspondence between numbers and directions.
You may assume that the length of the sequence is between 1 and 100000, inclusive. Also, arrows of the same direction won’t appear consecutively in the line. The end of the input is indicated by a single “#”.
<image>
Figure 3: the correspondence of the numbers to the direction arrows
Output
For each dataset, output how many times you have to violate “Natural footstep style” when you play optimally in one line.
Examples
Input
1
12
123
369
6748
4247219123
1232123212321232
#
Output
0
0
1
0
1
2
7
Input
1
12
123
369
6748
4247219123
1232123212321232
Output
0
0
1
0
1
2
7
### Response
```cpp
#include "bits/stdc++.h"
#include<unordered_map>
#pragma warning(disable:4996)
using namespace std;
const int My_Inf=2147483647;
const long long int My_LInf=9223372036854775807;
long long int gcd(long long int l, long long int r) {
assert(l > 0 && r > 0);
if (l > r)return gcd(r, l);
else {
if (r%l) {
return gcd(l, r%l);
}
else {
return l;
}
}
}
map<int, int>mp;
int main() {
mp['1'] = 0;
mp['2'] = 1;
mp['3'] = 2;
mp['4'] = 0;
mp['6'] = 2;
mp['7'] = 0;
mp['8'] = 1;
mp['9'] = 2;
while (1) {
string st; cin >> st;
if (st == "#")break;
int ans = 99999999;
{
int l = 0;
int r = 2;
bool isleft = true;
int tired = 0;
for (int i = 0; i < st.size(); ++i) {
if (isleft) {
if (r < mp[st[i]]) {
r = mp[st[i]];
tired++;
}
else {
l = mp[st[i]];
isleft =!isleft;
}
}
else {
if (l > mp[st[i]]) {
l = mp[st[i]];
tired++;
}
else {
r = mp[st[i]];
isleft = !isleft;
}
}
}
ans = min(ans, tired);
}
{
int l = 0;
int r = 2;
bool isleft = false;
int tired = 0;
for (int i = 0; i < st.size(); ++i) {
if (isleft) {
if (r < mp[st[i]]) {
r = mp[st[i]];
tired++;
}
else {
l = mp[st[i]];
isleft = !isleft;
}
}
else {
if (l > mp[st[i]]) {
l = mp[st[i]];
tired++;
}
else {
r = mp[st[i]];
isleft = !isleft;
}
}
}
ans = min(ans, tired);
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
A star is a figure of the following type: an asterisk character '*' in the center of the figure and four rays (to the left, right, top, bottom) of the same positive length. The size of a star is the length of its rays. The size of a star must be a positive number (i.e. rays of length 0 are not allowed).
Let's consider empty cells are denoted by '.', then the following figures are stars:
<image> The leftmost figure is a star of size 1, the middle figure is a star of size 2 and the rightmost figure is a star of size 3.
You are given a rectangular grid of size n × m consisting only of asterisks '*' and periods (dots) '.'. Rows are numbered from 1 to n, columns are numbered from 1 to m. Your task is to draw this grid using any number of stars or find out that it is impossible. Stars can intersect, overlap or even coincide with each other. The number of stars in the output can't exceed n ⋅ m. Each star should be completely inside the grid. You can use stars of same and arbitrary sizes.
In this problem, you do not need to minimize the number of stars. Just find any way to draw the given grid with at most n ⋅ m stars.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 100) — the sizes of the given grid.
The next n lines contains m characters each, the i-th line describes the i-th row of the grid. It is guaranteed that grid consists of characters '*' and '.' only.
Output
If it is impossible to draw the given grid using stars only, print "-1".
Otherwise in the first line print one integer k (0 ≤ k ≤ n ⋅ m) — the number of stars needed to draw the given grid. The next k lines should contain three integers each — x_j, y_j and s_j, where x_j is the row index of the central star character, y_j is the column index of the central star character and s_j is the size of the star. Each star should be completely inside the grid.
Examples
Input
6 8
....*...
...**...
..*****.
...**...
....*...
........
Output
3
3 4 1
3 5 2
3 5 1
Input
5 5
.*...
****.
.****
..**.
.....
Output
3
2 2 1
3 3 1
3 4 1
Input
5 5
.*...
***..
.*...
.*...
.....
Output
-1
Input
3 3
*.*
.*.
*.*
Output
-1
Note
In the first example the output
2
3 4 1
3 5 2
is also correct.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, h, g, c[268456], d[317456], l, r, s, t, k, a[1121][1136],
b1[1213456], b2[1345678], b3[1123456], m, x, y, z;
string p[12345], q;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> p[i];
}
for (i = 1; i < n - 1; i++) {
for (j = 1; j < m - 1; j++) {
t = 0;
if (p[i][j] == '*' && p[i][j + 1] == '*' && p[i][j - 1] == '*' &&
p[i + 1][j] == '*' && p[i - 1][j] == '*') {
l = 1;
a[i][j] = 1;
a[i][j + l] = 1;
a[i][j - l] = 1;
a[i + 1][j] = 1;
a[i - 1][j] = 1;
while (t == 0) {
l++;
t = 1;
if (i < l || j < l || n - i <= l || m - j <= l) break;
if (p[i][j + l] == '*' && p[i][j - l] == '*' && p[i + l][j] == '*' &&
p[i - l][j] == '*')
t = 0;
if (t == 0) {
a[i][j + l] = 1;
a[i][j - l] = 1;
a[i + l][j] = 1;
a[i - l][j] = 1;
}
}
b1[s] = i + 1;
b2[s] = j + 1;
b3[s] = l - 1;
s++;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (p[i][j] == '*' && a[i][j] == 0) {
cout << -1;
return 0;
}
}
}
cout << s << endl;
for (i = 0; i < s; i++) {
cout << b1[i] << ' ' << b2[i] << ' ' << b3[i] << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Dima liked the present he got from Inna very much. He liked the present he got from Seryozha even more.
Dima felt so grateful to Inna about the present that he decided to buy her n hares. Inna was very happy. She lined up the hares in a row, numbered them from 1 to n from left to right and started feeding them with carrots. Inna was determined to feed each hare exactly once. But in what order should she feed them?
Inna noticed that each hare radiates joy when she feeds it. And the joy of the specific hare depends on whether Inna fed its adjacent hares before feeding it. Inna knows how much joy a hare radiates if it eats when either both of his adjacent hares are hungry, or one of the adjacent hares is full (that is, has been fed), or both of the adjacent hares are full. Please note that hares number 1 and n don't have a left and a right-adjacent hare correspondingly, so they can never have two full adjacent hares.
Help Inna maximize the total joy the hares radiate. :)
Input
The first line of the input contains integer n (1 ≤ n ≤ 3000) — the number of hares. Then three lines follow, each line has n integers. The first line contains integers a1 a2 ... an. The second line contains b1, b2, ..., bn. The third line contains c1, c2, ..., cn. The following limits are fulfilled: 0 ≤ ai, bi, ci ≤ 105.
Number ai in the first line shows the joy that hare number i gets if his adjacent hares are both hungry. Number bi in the second line shows the joy that hare number i radiates if he has exactly one full adjacent hare. Number сi in the third line shows the joy that hare number i radiates if both his adjacent hares are full.
Output
In a single line, print the maximum possible total joy of the hares Inna can get by feeding them.
Examples
Input
4
1 2 3 4
4 3 2 1
0 1 1 0
Output
13
Input
7
8 5 7 6 1 8 9
2 7 9 5 4 3 1
2 3 3 4 1 1 3
Output
44
Input
3
1 1 1
1 2 1
1 1 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[100100], b[100100], c[100100];
int dp[100100][5];
int main() {
int n, i, j, k, l, m, q, w, e, r, t;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
memset(dp, 0, sizeof(dp));
dp[1][0] = b[1];
dp[1][1] = a[1];
for (i = 2; i <= n - 1; i++) {
dp[i][0] = max(dp[i - 1][0] + b[i], dp[i - 1][1] + c[i]);
dp[i][1] = max(dp[i - 1][0] + a[i], dp[i - 1][1] + b[i]);
}
if (n == 1)
printf("%d\n", a[1]);
else
printf("%d\n", max(dp[n - 1][0] + a[n], dp[n - 1][1] + b[n]));
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
long long X[maxn], Y[maxn];
vector<int> G[maxn];
int fa[maxn], anc[maxn][25], dep[maxn], q[maxn];
bool vis[maxn];
void init(int n) {
for (int i = 0; i <= n; i++) G[i].clear();
}
void dfs(int u, int d) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!vis[v]) {
vis[v] = 1;
dep[v] = d;
fa[v] = u;
dfs(v, d + 1);
}
}
}
void RMQ(int n) {
memset(anc, 0, sizeof(anc));
for (int i = 1; i <= n; i++) anc[i][0] = fa[i];
for (int k = 1; k <= 20; k++)
for (int v = 1; v <= n; v++) anc[v][k] = anc[anc[v][k - 1]][k - 1];
}
int swim(int x, int H) {
for (int i = 0; H > 0; i++) {
if (H & 1) x = anc[x][i];
H /= 2;
}
return x;
}
int LCA(int u, int v) {
int k;
if (dep[u] > dep[v]) swap(u, v);
v = swim(v, dep[v] - dep[u]);
if (u == v) return v;
while (1) {
for (k = 0; anc[u][k] != anc[v][k]; k++)
;
if (k == 0) return anc[u][0];
u = anc[u][k - 1];
v = anc[v][k - 1];
}
}
int main() {
int n, m, x, y;
while (scanf("%d", &n) != EOF) {
init(n);
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &X[i], &Y[i]);
q[0] = n;
int s = 0;
for (int i = n - 1; i >= 1; i--) {
while (s && (Y[i] - Y[q[s]]) * (X[q[s - 1]] - X[q[s]]) >
(X[q[s]] - X[i]) * (Y[q[s]] - Y[q[s - 1]]))
s--;
s++;
q[s] = i;
G[q[s - 1]].push_back(i);
}
memset(vis, 0, sizeof(vis));
vis[n] = 1;
fa[n] = 0;
dep[n] = 1;
dfs(n, 2);
RMQ(n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
int ans = LCA(x, y);
if (i != m)
printf("%d ", ans);
else
printf("%d", ans);
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 100;
long long n, k, m, x, y;
vector<int> g[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
x = n * (n - 1) / 2;
y = n * k;
if (x < y) {
cout << -1;
return 0;
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
g[j].push_back((j + m) % n + 1);
}
m++;
}
cout << y << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
cout << i << " " << g[i][j] << endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
We have a grid with N rows and M columns of squares. Each integer from 1 to NM is written in this grid once. The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.
You need to rearrange these numbers as follows:
1. First, for each of the N rows, rearrange the numbers written in it as you like.
2. Second, for each of the M columns, rearrange the numbers written in it as you like.
3. Finally, for each of the N rows, rearrange the numbers written in it as you like.
After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j. Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.
Constraints
* 1 \leq N,M \leq 100
* 1 \leq A_{ij} \leq NM
* A_{ij} are distinct.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print one way to rearrange the numbers in the following format:
B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}
Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.
Examples
Input
3 2
2 6
4 3
1 5
Output
2 6
4 3
5 1
2 1
4 3
5 6
Input
3 4
1 4 7 10
2 5 8 11
3 6 9 12
Output
1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10
### Response
```cpp
#include<bits/stdc++.h>
#define pb emplace_back
#define INF 1e9
#define N 210
using namespace std;
struct Info{int nu,ne,qu;}a[N*N];
int m,n,x,y,s,t,num=1,b[N],cur[N],an[N][N],li[N],di[N];
vector<int> c[N][N];
void jb(int x,int y){
a[++num].nu=y;a[num].ne=b[x];b[x]=num;a[num].qu=1;
a[++num].nu=x;a[num].ne=b[y];b[y]=num;a[num].qu=0;
}
int dinic(int x,int sh){
if (x==t) return sh;
int n1=0,n2;
for (int y=cur[x];y;y=a[y].ne){
cur[x]=y;
if (di[a[y].nu]==di[x]+1&&a[y].qu){
n2=dinic(a[y].nu,min(a[y].qu,sh-n1));
n1+=n2;a[y].qu-=n2;a[y^1].qu+=n2;
if (n1==sh) return n1;
}
}
return n1;
}
bool bfs(){
for (int i=1;i<=t;i++)di[i]=INF;
int l=1,r=1;li[l]=s;di[s]=0;
while (l<=r){
for (int y=b[li[l]];y;y=a[y].ne)
if (a[y].qu&&di[a[y].nu]==INF){di[a[y].nu]=di[li[l]]+1;li[++r]=a[y].nu;}
l++;
}
return (di[t]!=INF);
}
int main(){
cin>>n>>m;
s=n+n+1,t=n+n+2;
for (int i=1;i<=n;i++){jb(s,i);jb(i+n,t);}
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++){cin>>x;c[i][(x-1)/m+1].pb(x);jb(i,n+(x-1)/m+1);}
for (int j=1;j<=m;j++){
while (bfs()){for (int i=1;i<=t;i++)cur[i]=b[i];dinic(s,INF);}
for (int i=1;i<=n;i++){
a[i*2].qu=1;a[i*2+1].qu=0;
a[(i+n)*2].qu=1;a[(i+n)*2+1].qu=0;
}
for (int i=3;i<=num;i+=2){
if (a[i].qu){
a[i].qu=0;y=a[i^1].nu-n;
an[a[i].nu][j]=c[a[i].nu][y][c[a[i].nu][y].size()-1];
c[a[i].nu][y].pop_back();
}
}
}
for (int i=1;i<=n;i++){
for (int j=1;j<m;j++)cout<<an[i][j]<<' ';
cout<<an[i][m]<<endl;
}
for (int i=1;i<=m;i++){
vector<int> no;no.clear();
for (int j=1;j<=n;j++)no.pb(an[j][i]);
sort(no.begin(),no.end());
for (int j=1;j<=n;j++)an[j][i]=no[j-1];
}
for (int i=1;i<=n;i++){
for (int j=1;j<m;j++)cout<<an[i][j]<<' ';
cout<<an[i][m]<<endl;
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int c = 0, num = 0;
for (int i = n - 1; i >= 0; i--) {
num++;
if (a[i] * num >= x) {
c++;
num = 0;
}
}
cout << c << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given a tree with N vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N-1 edges, where N is the number of its vertices.
The i-th edge (1≤i≤N-1) connects Vertices a_i and b_i, and has a length of c_i.
You are also given Q queries and an integer K. In the j-th query (1≤j≤Q):
* find the length of the shortest path from Vertex x_j and Vertex y_j via Vertex K.
Constraints
* 3≤N≤10^5
* 1≤a_i,b_i≤N (1≤i≤N-1)
* 1≤c_i≤10^9 (1≤i≤N-1)
* The given graph is a tree.
* 1≤Q≤10^5
* 1≤K≤N
* 1≤x_j,y_j≤N (1≤j≤Q)
* x_j≠y_j (1≤j≤Q)
* x_j≠K,y_j≠K (1≤j≤Q)
Input
Input is given from Standard Input in the following format:
N
a_1 b_1 c_1
:
a_{N-1} b_{N-1} c_{N-1}
Q K
x_1 y_1
:
x_{Q} y_{Q}
Output
Print the responses to the queries in Q lines.
In the j-th line j(1≤j≤Q), print the response to the j-th query.
Examples
Input
5
1 2 1
1 3 1
2 4 1
3 5 1
3 1
2 4
2 3
4 5
Output
3
2
4
Input
7
1 2 1
1 3 3
1 4 5
1 5 7
1 6 9
1 7 11
3 2
1 3
4 5
6 7
Output
5
14
22
Input
10
1 2 1000000000
2 3 1000000000
3 4 1000000000
4 5 1000000000
5 6 1000000000
6 7 1000000000
7 8 1000000000
8 9 1000000000
9 10 1000000000
1 1
9 10
Output
17000000000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
vector<pair<int , int> > v[100005];
long long dp[100005];
void dfs(int n , int p , long long dis)
{
dp[n] = dp[p]+1ll*dis;
for(auto it : v[n])
{
if(it.first!=p)
{
dfs(it.first , n , it.second);
}
}
}
int main()
{
int n;
cin >> n;
for(int i = 1 ; i<n ; i++)
{
int x , y , z;
cin >> x >> y >> z;
v[x].push_back(make_pair(y , z));
v[y].push_back(make_pair(x , z));
}
int q , k;
cin >> q >> k;
dfs(k , 0 , 0);
while(q--)
{
int l , r;
cin >> l >> r;
cout << dp[r]+dp[l] << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given an undirected graph with n vertices and m edges. You have to write a number on each vertex of this graph, each number should be either 0 or 1. After that, you write a number on each edge equal to the sum of numbers on vertices incident to that edge.
You have to choose the numbers you will write on the vertices so that there is at least one edge with 0 written on it, at least one edge with 1 and at least one edge with 2. How many ways are there to do it? Two ways to choose numbers are different if there exists at least one vertex which has different numbers written on it in these two ways.
Input
The first line contains two integers n and m (1 ≤ n ≤ 40, 0 ≤ m ≤ (n(n - 1))/(2)) — the number of vertices and the number of edges, respectively.
Then m lines follow, each line contains two numbers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the endpoints of the i-th edge. It is guaranteed that each pair of vertices is connected by at most one edge.
Output
Print one integer — the number of ways to write numbers on all vertices so that there exists at least one edge with 0 written on it, at least one edge with 1 and at least one edge with 2.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 1
Output
20
Input
4 4
1 2
2 3
3 4
4 1
Output
4
Input
35 29
1 2
2 3
3 1
4 1
4 2
3 4
7 8
8 9
9 10
10 7
11 12
12 13
13 14
14 15
15 16
16 17
17 18
18 19
19 20
20 21
21 22
22 23
23 24
24 25
25 26
26 27
27 28
28 29
29 30
Output
34201047040
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 40;
int n, m;
vector<int> e[maxn];
inline long long f012() { return (1LL << n); }
inline long long fz() { return (m == 0 ? (1LL << n) : 0); }
inline long long f0() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (e[i].empty()) res <<= 1;
}
return res;
}
inline long long f2() { return f0(); }
bool used[maxn];
void dfs(int v) {
used[v] = true;
for (int u : e[v]) {
if (!used[u]) {
dfs(u);
}
}
}
inline long long f02() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
res <<= 1;
}
}
return res;
}
int kt[maxn];
bool is2ch = true;
void dfs1(int v) {
for (int u : e[v]) {
if (!kt[u]) {
kt[u] = 3 - kt[v];
dfs1(u);
} else if (kt[u] == kt[v]) {
is2ch = false;
}
}
}
inline long long f1() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (!kt[i]) {
kt[i] = 1;
dfs1(i);
res <<= 1;
}
}
res = (is2ch ? res : 0);
return res;
}
const int maxmsk = (1 << 20);
long long e2[maxn];
bool nz1[maxmsk], nz2[maxmsk];
int pmsk[maxmsk];
inline long long f01() {
for (int i = 0; i < n; i++) {
for (int j : e[i]) {
e2[i] |= (1LL << j);
}
}
int c1 = n / 2;
nz1[0] = true;
for (int i = 0; i < c1; i++) {
for (int j = 0; j < (1 << i); j++) {
if ((j & e2[i]) == 0) {
nz1[j | (1 << i)] |= nz1[j];
}
}
}
nz2[0] = true;
for (int i = 0; i < n - c1; i++) {
for (int j = 0; j < (1 << i); j++) {
if ((((long long)j << c1) & e2[c1 + i]) == 0) {
nz2[j | (1 << i)] |= nz2[j];
}
}
}
for (int i = 0; i < (1 << (n - c1)); i++) {
pmsk[i] = nz2[i];
}
for (int i = 0; i < (n - c1); i++) {
for (int j = 0; j < (1 << (n - c1)); j++) {
if ((j & (1 << i)) == 0) {
pmsk[j | (1 << i)] += pmsk[j];
}
}
}
long long res = 0;
for (int i = 0; i < (1 << c1); i++) {
if (nz1[i]) {
long long cmsk = 0;
for (int j = 0; j < c1; j++) {
if ((1 << j) & i) cmsk |= e2[j];
}
res += pmsk[(1 << (n - c1)) - 1 - (cmsk >> c1)];
}
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
e[v].push_back(u);
e[u].push_back(v);
}
cout << f012() - 2 * f01() - f02() + f0() + f1() + f2() - fz();
return 0;
}
``` |