text
stringlengths 424
69.5k
|
|---|
### Prompt
Please formulate a CPP solution to the following problem:
There are n stones on the table in a row, each of them can be red, green or blue. Count the minimum number of stones to take from the table so that any two neighboring stones had different colors. Stones in a row are considered neighboring if there are no other stones between them.
Input
The first line contains integer n (1 ≤ n ≤ 50) — the number of stones on the table.
The next line contains string s, which represents the colors of the stones. We'll consider the stones in the row numbered from 1 to n from left to right. Then the i-th character s equals "R", if the i-th stone is red, "G", if it's green and "B", if it's blue.
Output
Print a single integer — the answer to the problem.
Examples
Input
3
RRG
Output
1
Input
5
RRRRR
Output
4
Input
4
BRBG
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
int C = 0;
cin >> N;
string s;
cin >> s;
for (int i = 0; i < N; i++) {
if (s[i] == s[i + 1]) C++;
}
cout << C << endl;
}
```
|
### Prompt
Please create a solution in cpp to the following problem:
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 ≤ l_i ≤ r_i ≤ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 ≤ a_i ≤ q) — the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 ≤ l_i ≤ r_i ≤ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line — the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> poz[200010];
set<int> m;
set<int>::iterator it;
int v1[200010], v[200010], sol[200010], first[200010], last[200010],
aib[200010], n;
void update(int poz) {
for (int i = poz; i <= n; i += i & (-i)) aib[i]++;
}
int query(int poz) {
int s = 0;
for (int i = poz; i > 0; i -= i & (-i)) s += aib[i];
return s;
}
int main() {
int q, ok = 0, l = 0;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
poz[v[i]].push_back(i);
if (v[i] == 0) ok = 1;
if (first[v[i]] == 0) first[v[i]] = i;
last[v[i]] = i;
}
if (first[q] == 0 && ok == 0) {
printf("NO");
return 0;
}
for (int i = 1; i <= q; i++) {
if (first[i] != 0) {
int a = query(last[i]) - query(first[i] - 1);
if (a > 0) {
printf("NO");
return 0;
}
}
for (int j = 0; j < poz[i].size(); j++) update(poz[i][j]);
}
for (int i = 1; i <= n; i++) m.insert(i);
for (int i = q; i >= 1; i--) {
if (first[i] == 0) continue;
it = m.lower_bound(first[i]);
l = 0;
while (it != m.end()) {
if (*it > last[i]) break;
sol[*it] = i;
v1[++l] = *it;
it++;
}
for (int j = 1; j <= l; j++) m.erase(m.find(v1[j]));
}
if (first[q] == 0) {
int t = 0;
for (int i = 1; i <= n; i++)
if (v[i] == 0) t = i;
if (t == 0) {
printf("NO");
return 0;
}
sol[t] = q;
}
for (int i = 2; i <= n; i++)
if (sol[i] == 0) sol[i] = sol[i - 1];
for (int i = n - 1; i >= 1; i--)
if (sol[i] == 0) sol[i] = sol[i + 1];
int a = 1;
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", sol[i]);
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Let's introduce the designation <image>, where x is a string, n is a positive integer and operation " + " is the string concatenation operation. For example, [abc, 2] = abcabc.
We'll say that string s can be obtained from string t, if we can remove some characters from string t and obtain string s. For example, strings ab and aсba can be obtained from string xacbac, and strings bx and aaa cannot be obtained from it.
Sereja has two strings, w = [a, b] and q = [c, d]. He wants to find such maximum integer p (p > 0), that [q, p] can be obtained from string w.
Input
The first line contains two integers b, d (1 ≤ b, d ≤ 107). The second line contains string a. The third line contains string c. The given strings are not empty and consist of lowercase English letters. Their lengths do not exceed 100.
Output
In a single line print an integer — the largest number p. If the required value of p doesn't exist, print 0.
Examples
Input
10 3
abab
bab
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int la, lb;
char A[110];
char B[110];
int n, m;
int IDX[110];
int dp[110];
void preCal() {
for (int j = 0; j < lb; j++) {
int sum = 0;
int k = j;
for (int i = 0; i < la; i++) {
if (A[i] == B[k]) {
k++;
if (k == lb) {
sum++;
k = 0;
}
}
}
dp[j] = sum;
IDX[j] = k;
}
}
int cal() {
preCal();
int a = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = ans + dp[a];
a = IDX[a];
}
return ans / m;
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", &A);
scanf("%s", &B);
la = strlen(A);
lb = strlen(B);
printf("%d\n", cal());
return 0;
}
```
|
### Prompt
Your task is to create a cpp solution to the following problem:
Maksim has n objects and m boxes, each box has size exactly k. Objects are numbered from 1 to n in order from left to right, the size of the i-th object is a_i.
Maksim wants to pack his objects into the boxes and he will pack objects by the following algorithm: he takes one of the empty boxes he has, goes from left to right through the objects, and if the i-th object fits in the current box (the remaining size of the box is greater than or equal to a_i), he puts it in the box, and the remaining size of the box decreases by a_i. Otherwise he takes the new empty box and continues the process above. If he has no empty boxes and there is at least one object not in some box then Maksim cannot pack the chosen set of objects.
Maksim wants to know the maximum number of objects he can pack by the algorithm above. To reach this target, he will throw out the leftmost object from the set until the remaining set of objects can be packed in boxes he has. Your task is to say the maximum number of objects Maksim can pack in boxes he has.
Each time when Maksim tries to pack the objects into the boxes, he will make empty all the boxes he has before do it (and the relative order of the remaining set of objects will not change).
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^9) — the number of objects, the number of boxes and the size of each box.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the size of the i-th object.
Output
Print the maximum number of objects Maksim can pack using the algorithm described in the problem statement.
Examples
Input
5 2 6
5 2 1 4 2
Output
4
Input
5 1 4
4 2 3 4 1
Output
1
Input
5 3 3
1 2 3 1 1
Output
5
Note
In the first example Maksim can pack only 4 objects. Firstly, he tries to pack all the 5 objects. Distribution of objects will be [5], [2, 1]. Maxim cannot pack the next object in the second box and he has no more empty boxes at all. Next he will throw out the first object and the objects distribution will be [2, 1], [4, 2]. So the answer is 4.
In the second example it is obvious that Maksim cannot pack all the objects starting from first, second, third and fourth (in all these cases the distribution of objects is [4]), but he can pack the last object ([1]).
In the third example Maksim can pack all the objects he has. The distribution will be [1, 2], [3], [1, 1].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
int ans = 0, tmp = 0;
for (int i = n - 1; i >= 0; i--, ans++) {
if (tmp + vec[i] <= k) {
tmp += vec[i];
} else {
tmp = vec[i];
m--;
}
if (m == 0) {
break;
}
}
cout << ans << endl;
}
return 0;
}
```
|
### Prompt
Please provide a CPP coded solution to the problem described below:
After observing the results of Spy Syndrome, Yash realised the errors of his ways. He now believes that a super spy such as Siddhant can't use a cipher as basic and ancient as Caesar cipher. After many weeks of observation of Siddhant’s sentences, Yash determined a new cipher technique.
For a given sentence, the cipher is processed as:
1. Convert all letters of the sentence to lowercase.
2. Reverse each of the words of the sentence individually.
3. Remove all the spaces in the sentence.
For example, when this cipher is applied to the sentence
Kira is childish and he hates losing
the resulting string is
ariksihsidlihcdnaehsetahgnisol
Now Yash is given some ciphered string and a list of words. Help him to find out any original sentence composed using only words from the list. Note, that any of the given words could be used in the sentence multiple times.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10 000) — the length of the ciphered text. The second line consists of n lowercase English letters — the ciphered text t.
The third line contains a single integer m (1 ≤ m ≤ 100 000) — the number of words which will be considered while deciphering the text. Each of the next m lines contains a non-empty word wi (|wi| ≤ 1 000) consisting of uppercase and lowercase English letters only. It's guaranteed that the total length of all words doesn't exceed 1 000 000.
Output
Print one line — the original sentence. It is guaranteed that at least one solution exists. If there are multiple solutions, you may output any of those.
Examples
Input
30
ariksihsidlihcdnaehsetahgnisol
10
Kira
hates
is
he
losing
death
childish
L
and
Note
Output
Kira is childish and he hates losing
Input
12
iherehtolleh
5
HI
Ho
there
HeLLo
hello
Output
HI there HeLLo
Note
In sample case 2 there may be multiple accepted outputs, "HI there HeLLo" and "HI there hello" you may output any of them.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma warning(disable : 4996)
#pragma hdrstop
namespace std {
template <typename T, typename U>
struct hash<std::pair<T, U>> {
std::size_t operator()(const std::pair<T, U>& lhs) const {
return lhs.first * 877117 + lhs.second;
}
};
} // namespace std
namespace Random {}
inline char lowerCase(const char ch) {
return (ch >= 'A' && ch <= 'Z') ? ch ^ 32 : ch;
}
inline bool is_digit(const char ch) { return (ch >= '0' && ch <= '9'); }
class IO {
public:
constexpr static const std::size_t kBufferSize = 1 << 18;
IO()
: read_bytes_count_(0),
read_buffer_offset_(0),
current_char_(0),
eof_(false) {
static_assert(kBufferSize > 32,
"Size of a buffer must be greater than 32 due to comparison "
"in IO::flush() method.");
}
~IO() { flush(); }
IO(const IO&) = delete;
IO& operator=(const IO&) = delete;
IO(const IO&&) = delete;
IO& operator=(const IO&&) = delete;
inline void shift_char();
inline void skipws();
inline int32_t next_int();
inline void next_string(char* s);
IO& operator>>(int32_t& x);
IO& operator>>(char* s);
inline void flush();
inline void new_line();
inline void print_char(const char ch);
inline void print_string(const char* s);
IO& operator<<(const char x);
IO& operator<<(const std::string& s);
IO& operator<<(std::ostream& (*)(std::ostream&));
private:
using Buffer = std::array<char, kBufferSize>;
Buffer read_buffer_;
Buffer write_buffer_;
std::size_t read_bytes_count_;
std::size_t read_buffer_offset_;
std::size_t write_buffer_offset_;
bool eof_;
char current_char_;
inline void update_buffer();
template <typename T>
T read_number();
};
extern bool useFastIO;
extern std::istream* pin;
extern std::ostream* pout;
extern IO io;
inline int32_t next_int();
inline void next_string(char* s);
inline void new_line();
inline void print_char(const char x);
inline void print_string(const char* s);
class StringView {
public:
using iterator = const char*;
constexpr StringView() : data_(nullptr), length_(0) {}
constexpr StringView(const StringView&) = default;
StringView(const char* data, size_t length) : data_(data), length_(length) {}
constexpr char operator[](const size_t index) const { return data_[index]; }
constexpr size_t length() const { return length_; }
private:
const char* data_;
size_t length_;
};
class DoubleHasher_t {
public:
static const uint32_t MA = static_cast<uint32_t>(1e9) + 7;
static const uint32_t MB = static_cast<uint32_t>(1e9) + 9;
int a, b;
DoubleHasher_t() {}
DoubleHasher_t(const int x) : a(x), b(x) {}
DoubleHasher_t(const int a, const int b) : a(a), b(b) {}
DoubleHasher_t operator+(const DoubleHasher_t& x) const {
return DoubleHasher_t((a + x.a) % MA, (b + x.b) % MB);
}
DoubleHasher_t operator-(const DoubleHasher_t& x) const {
return DoubleHasher_t((a + MA - x.a) % MA, (b + MB - x.b) % MB);
}
DoubleHasher_t operator*(const int x) const {
return DoubleHasher_t(((int64_t)a * x) % MA, ((int64_t)b * x) % MB);
}
DoubleHasher_t operator*(const DoubleHasher_t& x) const {
return DoubleHasher_t(((int64_t)a * x.a) % MA, ((int64_t)b * x.b) % MB);
}
explicit operator int64_t() const { return (int64_t)a * MB + b + 1; }
};
template <class T>
class Hasher {
public:
T *deg, *hash;
int P;
StringView str;
Hasher(const int n, const int P = std::max(rand(), 307)) : P(P) {
hash = new T[n + 1];
deg = new T[n + 1];
deg[0] = 1;
for (int i = 1; i <= n; ++i) {
deg[i] = deg[i - 1] * P;
}
}
~Hasher() {
delete[] hash;
delete[] deg;
}
void hashString(const StringView& s) {
str = s;
hash[0] = 0;
for (int i = 0; i < s.length(); ++i) {
hash[i + 1] = hash[i] * P + s[i];
}
}
T getHash(const int l, const int r) const {
return hash[r] - hash[l - 1] * deg[r - l + 1];
}
private:
};
using namespace std;
IO io;
const int MAXN = 11111;
const int MAXM = 111111;
int dp[MAXN];
char s[MAXN], t[MAXN];
string a[MAXM];
Hasher<DoubleHasher_t> hasher(MAXN);
unordered_map<std::pair<int64_t, int>, int> str;
void solve(istream& ins, ostream& out) {
srand(time(nullptr));
int ls;
io >> ls >> s;
reverse(s, s + ls);
for (int i = 0; i < ls; ++i) {
s[i] = lowerCase(s[i]);
}
int n;
io >> n;
str.clear();
for (int i = 1; i <= n; ++i) {
io >> t;
int lt = strlen(t);
a[i] = string(t, t + lt);
for (int j = 0; j < lt; ++j) {
t[j] = lowerCase(t[j]);
}
hasher.hashString(StringView(t, lt));
int64_t cur_hash = static_cast<int64_t>(hasher.getHash(1, lt));
str[{cur_hash, lt}] = i;
}
hasher.hashString(StringView(s, ls));
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= ls; ++i) {
for (int j = max(0, i - 1000); j < i; ++j) {
if (dp[j] == -1) {
continue;
}
int64_t cur_hash = static_cast<int64_t>(hasher.getHash(j + 1, i));
std::pair<int64_t, int> cur_pair = {cur_hash, i - j};
if (str.count(cur_pair)) {
dp[i] = str[cur_pair];
break;
}
}
}
vector<int> ans;
int cur_index = ls;
while (cur_index > 0) {
int cur_str = dp[cur_index];
ans.emplace_back(cur_str);
cur_index -= a[cur_str].length();
}
for (const auto& it : ans) {
io << a[it] << ' ';
}
io << endl;
}
extern class IO io;
bool useFastIO = false;
istream* pin;
ostream* pout;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
useFastIO = true;
ostream& out = cout;
out << fixed << setprecision(16);
pin = ∈
pout = &out;
solve(in, out);
return 0;
}
inline void IO::skipws() {
while (!eof_ && (current_char_ == ' ' || current_char_ == '\n')) {
shift_char();
}
}
template <typename T>
T IO::read_number() {
bool is_negative = false;
while (!eof_ && !is_digit(current_char_) &&
(std::is_unsigned<T>() || current_char_ != '-')) {
shift_char();
}
if (std::is_signed<T>() && current_char_ == '-') {
is_negative = true;
shift_char();
}
T result = 0;
while (!eof_ && is_digit(current_char_)) {
result = (result << 3) + (result << 1) + current_char_ - '0';
shift_char();
}
return (is_negative ? result * -1 : result);
}
inline void IO::update_buffer() {
if (read_buffer_offset_ == read_bytes_count_) {
read_bytes_count_ = fread(&read_buffer_[0], sizeof(read_buffer_[0]),
read_buffer_.size(), stdin);
if (read_bytes_count_ == 0) {
eof_ = true;
return;
}
read_buffer_offset_ = 0;
}
}
inline void IO::shift_char() {
update_buffer();
current_char_ = read_buffer_[read_buffer_offset_++];
}
inline int32_t IO::next_int() { return read_number<int32_t>(); }
inline void IO::next_string(char* s) {
if (current_char_ == '\0') {
shift_char();
}
skipws();
std::size_t index = 0;
while (!eof_ && current_char_ != ' ' && current_char_ != '\n') {
s[index++] = current_char_;
shift_char();
}
s[index] = 0;
}
IO& IO::operator>>(int32_t& x) {
x = ::next_int();
return *this;
}
IO& IO::operator>>(char* s) {
::next_string(s);
return *this;
}
inline void IO::flush() {
fwrite(&write_buffer_[0], sizeof(write_buffer_[0]), write_buffer_offset_,
stdout);
write_buffer_offset_ = 0;
}
inline void IO::new_line() {
if (write_buffer_offset_ == kBufferSize) {
flush();
}
write_buffer_[write_buffer_offset_++] = '\n';
}
inline void IO::print_char(const char x) {
if (write_buffer_offset_ == kBufferSize) {
flush();
}
write_buffer_[write_buffer_offset_++] = x;
}
inline void IO::print_string(const char* s) {
for (std::size_t i = 0; s[i] != '\0'; ++i) {
if (write_buffer_offset_ == kBufferSize) {
flush();
}
write_buffer_[write_buffer_offset_++] = s[i];
}
}
IO& IO::operator<<(const char x) {
::print_char(x);
return *this;
}
IO& IO::operator<<(const std::string& s) {
::print_string(s.c_str());
return *this;
}
IO& IO::operator<<(std::ostream& (*)(std::ostream&)) {
::new_line();
return *this;
}
inline int32_t next_int() {
if (useFastIO) {
return io.next_int();
}
int32_t ret;
*pin >> ret;
return ret;
}
inline void next_string(char* s) {
if (useFastIO) {
io.next_string(s);
return;
}
*pin >> s;
}
inline void new_line() {
if (useFastIO) {
io.new_line();
return;
}
*pout << std::endl;
}
inline void print_char(const char x) {
if (useFastIO) {
io.print_char(x);
return;
}
*pout << x;
}
inline void print_string(const char* s) {
if (useFastIO) {
io.print_string(s);
return;
}
*pout << s;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
There are n positive integers written on the blackboard. Also, a positive number k ≥ 2 is chosen, and none of the numbers on the blackboard are divisible by k. In one operation, you can choose any two integers x and y, erase them and write one extra number f(x + y), where f(x) is equal to x if x is not divisible by k, otherwise f(x) = f(x / k).
In the end, there will be a single number of the blackboard. Is it possible to make the final number equal to 1? If so, restore any sequence of operations to do so.
Input
The first line contains two integers n and k — the initial number of integers on the blackboard, and the chosen number (2 ≤ n ≤ 16, 2 ≤ k ≤ 2000).
The second line contains n positive integers a_1, …, a_n initially written on the blackboard. It is guaranteed that none of the numbers a_i is divisible by k, and the sum of all a_i does not exceed 2000.
Output
If it is impossible to obtain 1 as the final number, print "NO" in the only line.
Otherwise, print "YES" on the first line, followed by n - 1 lines describing operations. The i-th of these lines has to contain two integers x_i and y_i to be erased and replaced with f(x_i + y_i) on the i-th operation. If there are several suitable ways, output any of them.
Examples
Input
2 2
1 1
Output
YES
1 1
Input
4 3
7 8 13 23
Output
YES
23 13
8 7
5 4
Input
3 4
1 2 3
Output
NO
Note
In the second sample case:
* f(8 + 7) = f(15) = f(5) = 5;
* f(23 + 13) = f(36) = f(12) = f(4) = 4;
* f(5 + 4) = f(9) = f(3) = f(1) = 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bitset<2010> f[1 << 17];
int n, s, k, lg[1 << 17], a[2010], d[2010];
priority_queue<pair<int, int> > q;
void dfs(int st, int v) {
if (!st) return;
for (; v * k <= s && f[st][v * k]; v *= k)
for (int i = st; i; i -= i & -i) d[lg[i & -i]]++;
for (int i = st; i; i -= i & -i)
if (v >= a[lg[i & -i]] && f[st - (i & -i)][v - a[lg[i & -i]]]) {
dfs(st - (i & -i), v - a[lg[i & -i]]);
return;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
lg[1 << i] = i;
s += a[i];
}
f[0][0] = 1;
for (int i = 1; i < (1 << n); i++) {
for (int j = i; j; j -= j & -j) f[i] |= (f[i - (j & -j)] << a[lg[j & -j]]);
for (int j = s / k; j; j--)
if (f[i][j * k]) f[i][j] = 1;
}
if (!f[(1 << n) - 1][1]) {
puts("NO");
return 0;
}
puts("YES");
dfs((1 << n) - 1, 1);
for (int i = 0; i < n; i++) q.push(make_pair(d[i], a[i]));
while (q.size() > 1) {
pair<int, int> x = q.top();
q.pop();
pair<int, int> y = q.top();
q.pop();
printf("%d %d\n", x.second, y.second);
x.second += y.second;
while (x.second % k == 0) {
x.second /= k;
x.first--;
}
q.push(x);
}
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
Mr. A, who will graduate next spring, decided to move when he got a job. The company that finds a job has offices in several towns, and the offices that go to work differ depending on the day. So Mr. A decided to live in a town where he had a short time to go to any office.
So you decided to find the most convenient town to live in to help Mr. A.
<image>
Towns are numbered starting with 0 and there is a road between towns. Commuting time is fixed for each road. If Mr. A lives in a town, the commuting time to the office in his town is 0. At this time, consider the total commuting time to all towns. For example, if the layout of towns and roads is as shown in the figure above and Mr. A lives in town 1, the commuting time to each town will be
Town 0 to 80
0 to town 1
Up to town 2 20
Up to town 3 70
Town 4 to 90
And the sum is 260.
Enter the number of roads and information on all roads, calculate the total commuting time when living in each town, and output the number of the town that minimizes it and the total commuting time at that time. Create a program. However, if there are multiple towns with the smallest total commuting time, please output the number of the smallest town and the total commuting time at that time. The total number of towns is 10 or less, the total number of roads is 45 or less, all roads can move in both directions, and commuting time does not change depending on the direction. We also assume that there are routes from any town to all other towns.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1 b1 c1
a2 b2 c2
::
an bn cn
The number of roads n (1 ≤ n ≤ 45) is given on the first line. The following n lines give information on the i-th way. ai, bi (0 ≤ ai, bi ≤ 9) is the number of the town to which the i-th road connects, and ci (0 ≤ ci ≤ 100) is the commute time for that road.
Output
For each data set, the town number that minimizes the total commuting time and the total commuting time at that time are output on one line separated by blanks.
Example
Input
6
0 1 80
1 2 20
0 2 60
2 3 50
3 4 60
1 4 90
2
0 1 1
1 2 1
0
Output
2 240
1 2
### Response
```cpp
// AOJ 0189 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0189)
#include<cstdio>
#include<algorithm>
#include<numeric>
#include<limits>
#define rep(i,a) for(int i=0;i<(a);++i)
typedef std::pair<int, int> P;
const int MAX_N = 10, INF = std::numeric_limits<int>::max()>>4;
int d[MAX_N][MAX_N];
int main()
{
int n;
while( scanf( "%d", &n ), n )
{
rep( i, MAX_N ) rep( j, MAX_N )
d[i][j] = i==j?0:INF;
rep( i, n )
{
int a, b, c;
scanf( "%d%d%d", &a, &b, &c );
d[a][b] = d[b][a] = c;
}
rep( k, MAX_N ) rep( i, MAX_N ) rep( j, MAX_N )
d[i][j] = std::min( d[i][j], d[i][k]+d[k][j] );
P ans( INF, INF );
rep( i, MAX_N )
{
int s = 0;
rep( j, MAX_N ) if( d[i][j] != INF )
s += d[i][j];
if( s )
ans = std::min( ans, P( s, i ) );
}
printf( "%d %d\n", ans.second, ans.first );
}
return 0;
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
Many modern text editors automatically check the spelling of the user's text. Some editors even suggest how to correct typos.
In this problem your task to implement a small functionality to correct two types of typos in a word. We will assume that three identical letters together is a typo (for example, word "helllo" contains a typo). Besides, a couple of identical letters immediately followed by another couple of identical letters is a typo too (for example, words "helloo" and "wwaatt" contain typos).
Write a code that deletes the minimum number of letters from a word, correcting described typos in the word. You are allowed to delete letters from both ends and from the middle of the word.
Input
The single line of the input contains word s, its length is from 1 to 200000 characters. The given word s consists of lowercase English letters.
Output
Print such word t that it doesn't contain any typos described in the problem statement and is obtained from s by deleting the least number of letters.
If there are multiple solutions, print any of them.
Examples
Input
helloo
Output
hello
Input
woooooow
Output
woow
Note
The second valid answer to the test from the statement is "heloo".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char g[s.length()];
int j = 0;
for (int i = 2; i < s.length(); i++) {
if (s[i] == s[i - 1] && s[i - 1] == s[i - 2] && s[i] != '0') {
s[i - 2] = '0';
char cc = s[i];
while (i + 1 < s.length() && s[i + 1] == cc) {
s[i + 1] = '0';
i++;
}
}
}
for (int i = 0; i < s.length(); i++) {
if (s[i] != '0') g[j] = s[i], j++;
}
for (int i = 3; i < j; i++) {
if (g[i] == g[i - 1] && g[i - 2] == g[i - 3]) {
g[i] = '0';
}
}
for (int i = 0; i < j; i++)
if (g[i] != '0') cout << g[i];
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
Once upon a time in a kingdom far, far away… Okay, let’s start at the point where Ivan the Fool met Gorynych the Dragon. Ivan took out his magic sword and the battle began. First Gorynych had h heads and t tails. With each strike of the sword Ivan can either cut off several heads (from 1 to n, but not more than Gorynych has at the moment), or several tails (from 1 to m, but not more than Gorynych has at the moment). At the same time, horrible though it seems, Gorynych the Dragon can also grow new heads and tails. And the number of growing heads and tails is determined uniquely by the number of heads or tails cut by the current strike. When the total number of heads and tails exceeds R, Gorynych the Dragon strikes its final blow and destroys Ivan the Fool. That’s why Ivan aims to cut off all the dragon’s heads and tails as quickly as possible and win. The events can also develop in a third way: neither of the opponents can win over the other one and they will continue fighting forever.
The tale goes like this; easy to say, hard to do. Your task is to write a program that will determine the battle’s outcome. Consider that Ivan strikes consecutively. After each blow Gorynych grows a number of new heads and tails depending on the number of cut ones. Gorynych the Dragon is defeated if after the blow he loses all his heads and tails and can’t grow new ones. Ivan fights in the optimal way (fools are lucky), i.e.
* if Ivan can win, he wins having struck the least number of blows;
* if it is impossible to defeat Gorynych, but is possible to resist him for an infinitely long period of time, then that’s the strategy Ivan chooses;
* if Gorynych wins in any case, Ivan aims to resist him for as long as possible.
Input
The first line contains three integers h, t and R (0 ≤ h, t, R ≤ 200, 0 < h + t ≤ R) which represent the initial numbers of Gorynych’s heads and tails and the largest total number of heads and tails with which Gorynych the Dragon does not yet attack. The next line contains integer n (1 ≤ n ≤ 200). The next n contain pairs of non-negative numbers "hi ti" which represent the number of heads and the number of tails correspondingly, that will grow if Gorynych has i heads (1 ≤ i ≤ n) cut. The next line contains an integer m (1 ≤ m ≤ 200) and then — the description of Gorynych’s behavior when his tails are cut off in the format identical to the one described above. All the numbers in the input file do not exceed 200.
Output
Print "Ivan" (without quotes) in the first line if Ivan wins, or "Zmey" (that means a dragon in Russian) if Gorynych the Dragon wins. In the second line print a single integer which represents the number of blows Ivan makes. If the battle will continue forever, print in the first line "Draw".
Examples
Input
2 2 4
2
1 0
0 1
3
0 1
0 1
0 0
Output
Ivan
2
Input
2 2 4
1
0 1
1
1 0
Output
Draw
Input
2 2 5
1
1 1
1
3 0
Output
Zmey
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
const int LIMIT = 1000000;
int R, n, m, h, t, dn;
int hg[MAXN][2], tg[MAXN][2];
int dp[MAXN][MAXN][2], d[MAXN][MAXN];
queue<pair<int, int> > q;
bool CheckMin() {
while (!q.empty()) q.pop();
q.push(make_pair(h, t));
while (!q.empty()) {
pair<int, int> p = q.front(), pnew;
q.pop();
if (p.first + p.second > R) continue;
for (int i = 1; i <= min(p.first, n); i++) {
pnew.first = p.first - i + hg[i][0];
pnew.second = p.second + hg[i][1];
if (pnew.first + pnew.second > R) continue;
if (dp[p.first][p.second][0] + 1 < dp[pnew.first][pnew.second][0]) {
dp[pnew.first][pnew.second][0] = dp[p.first][p.second][0] + 1;
q.push(pnew);
}
}
for (int i = 1; i <= min(p.second, m); i++) {
pnew.first = p.first + tg[i][0];
pnew.second = p.second - i + tg[i][1];
if (pnew.first + pnew.second > R) continue;
if (dp[p.first][p.second][0] + 1 < dp[pnew.first][pnew.second][0]) {
dp[pnew.first][pnew.second][0] = dp[p.first][p.second][0] + 1;
q.push(pnew);
}
}
if (dp[0][0][0] != INT_MAX) break;
}
return dp[0][0][0] != INT_MAX;
}
bool CheckMax() {
while (!q.empty()) q.pop();
q.push(make_pair(h, t));
while (!q.empty()) {
pair<int, int> p = q.front(), pnew;
q.pop();
if (p.first + p.second > R) continue;
for (int i = 1; i <= min(p.first, n); i++) {
pnew.first = p.first - i + hg[i][0];
pnew.second = p.second + hg[i][1];
if (pnew.first + pnew.second > R) pnew.first = pnew.second = R;
if (dp[p.first][p.second][1] + 1 > dp[pnew.first][pnew.second][1]) {
dp[pnew.first][pnew.second][1] = dp[p.first][p.second][1] + 1;
q.push(pnew);
}
}
for (int i = 1; i <= min(p.second, m); i++) {
pnew.first = p.first + tg[i][0];
pnew.second = p.second - i + tg[i][1];
if (pnew.first + pnew.second > R) pnew.first = pnew.second = R;
if (dp[p.first][p.second][1] + 1 > dp[pnew.first][pnew.second][1]) {
dp[pnew.first][pnew.second][1] = dp[p.first][p.second][1] + 1;
q.push(pnew);
}
}
}
return true;
}
bool CheckCycle(const pair<int, int> &p) {
pair<int, int> pnew;
d[p.first][p.second] = -1;
for (int i = 1; i <= min(p.first, n); i++) {
pnew.first = p.first - i + hg[i][0];
pnew.second = p.second + hg[i][1];
if (pnew.first + pnew.second > R) continue;
if (d[pnew.first][pnew.second] == -1 ||
d[pnew.first][pnew.second] == 0 && CheckCycle(pnew))
return true;
}
for (int i = 1; i <= min(p.second, m); i++) {
pnew.first = p.first + tg[i][0];
pnew.second = p.second - i + tg[i][1];
if (pnew.first + pnew.second > R) continue;
if (d[pnew.first][pnew.second] == -1 ||
d[pnew.first][pnew.second] == 0 && CheckCycle(pnew))
return true;
}
d[p.first][p.second] = 1;
return false;
}
int main() {
cin >> h >> t >> R >> n;
for (int i = 1; i <= n; i++) cin >> hg[i][0] >> hg[i][1];
cin >> m;
for (int i = 1; i <= m; i++) cin >> tg[i][0] >> tg[i][1];
for (int i = 0; i <= R; i++)
for (int j = 0; j <= R; j++) dp[i][j][0] = INT_MAX, dp[i][j][1] = INT_MIN;
dp[h][t][0] = dp[h][t][1] = 0;
if (CheckMin())
cout << "Ivan" << endl << dp[0][0][0] << endl;
else if (CheckCycle(make_pair(h, t)))
cout << "Draw" << endl;
else
CheckMax(), cout << "Zmey" << endl << dp[R][R][1] << endl;
return 0;
}
```
|
### Prompt
Your task is to create a cpp solution to the following problem:
We have N logs of lengths A_1,A_2,\cdots A_N.
We can cut these logs at most K times in total. When a log of length L is cut at a point whose distance from an end of the log is t (0<t<L), it becomes two logs of lengths t and L-t.
Find the shortest possible length of the longest log after at most K cuts, and print it after rounding up to an integer.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 0 \leq K \leq 10^9
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \cdots A_N
Output
Print an integer representing the answer.
Examples
Input
2 3
7 9
Output
4
Input
3 0
3 4 5
Output
5
Input
10 10
158260522 877914575 602436426 24979445 861648772 623690081 433933447 476190629 262703497 211047202
Output
292638192
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n, k, a[200004], ans;
int main(){
cin >> n >> k;
for (int i=0;i<n;i++) cin >> a[i];
int l=1, r=1e9;
while (l<=r){
int mid=(l+r)/2;
int cnt=0;
for (int i=0;i<n;i++) cnt+=(a[i]+mid-1)/mid-1;
// cout << "(length,cut)=(" << mid << "," << cnt << ")\n";
if (cnt<=k){
ans=mid;
r=mid-1;
}
else l=mid+1;
}
cout << ans << "\n";
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
Have you ever tasted Martian food? Well, you should.
Their signature dish is served on a completely black plate with the radius of R, flat as a pancake.
First, they put a perfectly circular portion of the Golden Honduras on the plate. It has the radius of r and is located as close to the edge of the plate as possible staying entirely within the plate. I. e. Golden Honduras touches the edge of the plate from the inside. It is believed that the proximity of the portion of the Golden Honduras to the edge of a plate demonstrates the neatness and exactness of the Martians.
Then a perfectly round portion of Pink Guadeloupe is put on the plate. The Guadeloupe should not overlap with Honduras, should not go beyond the border of the plate, but should have the maximum radius. I. e. Pink Guadeloupe should touch the edge of the plate from the inside, and touch Golden Honduras from the outside. For it is the size of the Rose Guadeloupe that shows the generosity and the hospitality of the Martians.
Further, the first portion (of the same perfectly round shape) of Green Bull Terrier is put on the plate. It should come in contact with Honduras and Guadeloupe, should not go beyond the border of the plate and should have maximum radius.
Each of the following portions of the Green Bull Terrier must necessarily touch the Golden Honduras, the previous portion of the Green Bull Terrier and touch the edge of a plate, but should not go beyond the border.
To determine whether a stranger is worthy to touch the food, the Martians ask him to find the radius of the k-th portion of the Green Bull Terrier knowing the radii of a plate and a portion of the Golden Honduras. And are you worthy?
Input
The first line contains integer t (1 ≤ t ≤ 104) — amount of testcases.
Each of the following t lines contain three positive integers: the radii of the plate and a portion of the Golden Honduras R and r (1 ≤ r < R ≤ 104) and the number k (1 ≤ k ≤ 104).
In the pretests 1 ≤ k ≤ 2.
Output
Print t lines — the radius of the k-th portion of the Green Bull Terrier for each test. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 3 1
4 2 2
Output
0.9230769231
0.6666666667
Note
Dish from the first sample looks like this:
<image>
Dish from the second sample looks like this:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(!cin.tie(0));
cout << setprecision(20) << fixed;
int t;
cin >> t;
while (t--) {
double d, c, i = 1;
cin >> d >> c;
double b = d - c;
b = i / b;
c = i / c;
d = -i / d;
b += c + d;
double cpd = c + d;
double cpd4 = cpd * 4;
double ctd4 = c * d * 4;
int k;
cin >> k;
while (--k) {
b = b + cpd + sqrt(b * cpd4 + ctd4);
}
cout << i / b << '\n';
}
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given an array a of length n, which initially is a permutation of numbers from 1 to n. In one operation, you can choose an index i (1 ≤ i < n) such that a_i < a_{i + 1}, and remove either a_i or a_{i + 1} from the array (after the removal, the remaining parts are concatenated).
For example, if you have the array [1, 3, 2], you can choose i = 1 (since a_1 = 1 < a_2 = 3), then either remove a_1 which gives the new array [3, 2], or remove a_2 which gives the new array [1, 2].
Is it possible to make the length of this array equal to 1 with these operations?
Input
The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n, a_i are pairwise distinct) — elements of the array.
It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
Output
For each test case, output on a single line the word "YES" if it is possible to reduce the array to a single element using the aforementioned operation, or "NO" if it is impossible to do so.
Example
Input
4
3
1 2 3
4
3 1 2 4
3
2 3 1
6
2 4 6 1 3 5
Output
YES
YES
NO
YES
Note
For the first two test cases and the fourth test case, we can operate as follow (the bolded elements are the pair chosen for that operation):
[1, 2, 3] → [1, 2] → [1]
[3, 1, 2, 4] → [3, 1, 4] → [3, 4] → [4]
[2, 4, 6, 1, 3, 5] → [4, 6, 1, 3, 5] → [4, 1, 3, 5] → [4, 1, 5] → [4, 5] → [4]
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, a[300005];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for ((i) = 1; (i) <= (n); (i)++) scanf("%d", &a[i]);
if (a[1] < a[n]) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
```
|
### Prompt
Please formulate a Cpp solution to the following problem:
The only difference between easy and hard versions is constraints.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 100, 1 ≤ M ≤ 100) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long M = 2e5 + 7, MOD = 1e9;
bool f_2, f = false;
string s, p, q, ok, ch;
vector<long long> v, v_1;
map<long long, long long> mp, mp_2;
set<long long> st;
long long arr[101], ar[2][M];
deque<long long> Q;
struct node {
long long pa, ran, visit;
};
node X[M];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, b, sum = 0, d = 0, a = 0, mx = MOD, m, l, x, y, c, i = 1, j = 0,
check = 0, k;
cin >> t >> b;
while (t--) {
cin >> a;
v.push_back(a);
}
for (i = 0; i < v.size(); i++) {
sum += v[i];
if (sum <= b) {
cout << "0"
<< " ";
} else {
long long need = sum;
c = 0;
for (j = 100; j >= 1; j--) {
if (need > b) {
need = need - (j * arr[j]);
c += arr[j];
k = j;
} else
break;
}
need = abs(need);
c = c - ((b - need) / k);
cout << c << " ";
}
arr[v[i]]++;
}
cout << endl;
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
For a string S consisting of the uppercase English letters `P` and `D`, let the doctoral and postdoctoral quotient of S be the total number of occurrences of `D` and `PD` in S as contiguous substrings. For example, if S = `PPDDP`, it contains two occurrences of `D` and one occurrence of `PD` as contiguous substrings, so the doctoral and postdoctoral quotient of S is 3.
We have a string T consisting of `P`, `D`, and `?`.
Among the strings that can be obtained by replacing each `?` in T with `P` or `D`, find one with the maximum possible doctoral and postdoctoral quotient.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `P`, `D`, and `?`.
Input
Input is given from Standard Input in the following format:
T
Output
Print one string with the maximum possible doctoral and postdoctoral quotient among the strings that can be obtained by replacing each `?` in T with `P` or `D`. If there are multiple such strings, you may print any of them.
Examples
Input
PD?D??P
Output
PDPDPDP
Input
P?P?
Output
PDPD
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;
int N=s.size();
for(int i=0;i<N;i++)
if(s.at(i)=='?')
s.at(i)='D';
cout<<s<<endl;
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int k,n,a[200005],cnt[200005];
int main() {
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) {
scanf("%d",a+i);
cnt[a[i]]++;
}
sort(cnt+1,cnt+1+n);
int i;
for(i=1;i<=n;i++) if (cnt[i]!=0) break;
// cerr<<i<<endl;
int ans=0;
for(;i<=n-k;i++) ans+=cnt[i];
printf("%d\n",ans);
return 0;
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
You are given two integer sequences S and T of length N and M, respectively, both consisting of integers between 1 and 10^5 (inclusive).
In how many pairs of a subsequence of S and a subsequence of T do the two subsequences are the same in content?
Here the subsequence of A is a sequence obtained by removing zero or more elements from A and concatenating the remaining elements without changing the order.
For both S and T, we distinguish two subsequences if the sets of the indices of the removed elements are different, even if the subsequences are the same in content.
Since the answer can be tremendous, print the number modulo 10^9+7.
Constraints
* 1 \leq N, M \leq 2 \times 10^3
* The length of S is N.
* The length of T is M.
* 1 \leq S_i, T_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
S_1 S_2 ... S_{N-1} S_{N}
T_1 T_2 ... T_{M-1} T_{M}
Output
Print the number of pairs of a subsequence of S and a subsequence of T such that the subsequences are the same in content, modulo 10^9+7.
Examples
Input
2 2
1 3
3 1
Output
3
Input
2 2
1 1
1 1
Output
6
Input
4 4
3 4 5 6
3 4 5 6
Output
16
Input
10 9
9 6 5 7 5 9 8 5 6 7
8 6 8 5 5 7 9 9 7
Output
191
Input
20 20
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
846527861
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define MAX 2010
const int MOD = 1e9 + 7;
int dp[MAX][MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> v(n + 1), w(m + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
dp[i][0] = 1;
}
for (int i = 1; i <= m; i++) {
cin >> w[i];
dp[0][i] = 1;
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD;
if (v[i] != w[j])
dp[i][j] = (MOD + dp[i][j] - dp[i - 1][j - 1]) % MOD;
}
}
cout << dp[n][m] << endl;
return 0;
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Yaroslav is playing a game called "Time". The game has a timer showing the lifespan he's got left. As soon as the timer shows 0, Yaroslav's character dies and the game ends. Also, the game has n clock stations, station number i is at point (xi, yi) of the plane. As the player visits station number i, he increases the current time on his timer by ai. The stations are for one-time use only, so if the player visits some station another time, the time on his timer won't grow.
A player spends d·dist time units to move between stations, where dist is the distance the player has covered and d is some constant. The distance between stations i and j is determined as |xi - xj| + |yi - yj|.
Initially, the player is at station number 1, and the player has strictly more than zero and strictly less than one units of time. At station number 1 one unit of money can increase the time on the timer by one time unit (you can buy only integer number of time units).
Now Yaroslav is wondering, how much money he needs to get to station n. Help Yaroslav. Consider the time to buy and to increase the timer value negligibly small.
Input
The first line contains integers n and d (3 ≤ n ≤ 100, 103 ≤ d ≤ 105) — the number of stations and the constant from the statement.
The second line contains n - 2 integers: a2, a3, ..., an - 1 (1 ≤ ai ≤ 103). The next n lines contain the coordinates of the stations. The i-th of them contains two integers xi, yi (-100 ≤ xi, yi ≤ 100).
It is guaranteed that no two stations are located at the same point.
Output
In a single line print an integer — the answer to the problem.
Examples
Input
3 1000
1000
0 0
0 1
0 3
Output
2000
Input
3 1000
1000
1 0
1 1
1 2
Output
1000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long n, dd, i, j, k, b[200] = {}, x[200] = {}, y[200] = {}, a[200][200] = {};
int main() {
cin >> n >> dd;
for (i = 2; i < n; i++) cin >> b[i];
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
for (j = 1; j < i; j++) {
a[j][i] = a[i][j] = fabs(x[i] - x[j]) + fabs(y[i] - y[j]);
a[i][j] *= dd;
a[i][j] -= b[i];
a[j][i] *= dd;
a[j][i] -= b[j];
}
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if ((i != j) && (i != k) && (j != k))
if (a[i][j] > a[i][k] + a[k][j]) a[i][j] = a[i][k] + a[k][j];
cout << a[1][n] << endl;
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
Iahub likes trees very much. Recently he discovered an interesting tree named propagating tree. The tree consists of n nodes numbered from 1 to n, each node i having an initial value ai. The root of the tree is node 1.
This tree has a special property: when a value val is added to a value of node i, the value -val is added to values of all the children of node i. Note that when you add value -val to a child of node i, you also add -(-val) to all children of the child of node i and so on. Look an example explanation to understand better how it works.
This tree supports two types of queries:
* "1 x val" — val is added to the value of node x;
* "2 x" — print the current value of node x.
In order to help Iahub understand the tree better, you must answer m queries of the preceding type.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 200000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000). Each of the next n–1 lines contains two integers vi and ui (1 ≤ vi, ui ≤ n), meaning that there is an edge between nodes vi and ui.
Each of the next m lines contains a query in the format described above. It is guaranteed that the following constraints hold for all queries: 1 ≤ x ≤ n, 1 ≤ val ≤ 1000.
Output
For each query of type two (print the value of node x) you must print the answer to the query on a separate line. The queries must be answered in the order given in the input.
Examples
Input
5 5
1 2 1 1 2
1 2
1 3
2 4
2 5
1 2 3
1 1 2
2 1
2 2
2 4
Output
3
3
0
Note
The values of the nodes are [1, 2, 1, 1, 2] at the beginning.
Then value 3 is added to node 2. It propagates and value -3 is added to it's sons, node 4 and node 5. Then it cannot propagate any more. So the values of the nodes are [1, 5, 1, - 2, - 1].
Then value 2 is added to node 1. It propagates and value -2 is added to it's sons, node 2 and node 3. From node 2 it propagates again, adding value 2 to it's sons, node 4 and node 5. Node 3 has no sons, so it cannot propagate from there. The values of the nodes are [3, 3, - 1, 0, 1].
You can see all the definitions about the tree at the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory)
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> adj[N];
int start[N] = {0}, finish[N] = {0}, vert[2 * N] = {0};
bool level[N] = {0};
int t = 1;
void dfs(int u, int p = -1, bool lvl = 0) {
start[u] = t;
vert[t] = u;
t++;
level[u] = lvl;
for (auto v : adj[u])
if (v - p) dfs(v, u, lvl ^ 1);
finish[u] = t;
vert[t] = u;
t++;
}
typedef struct BIT {
vector<int> bit;
int n;
void init(int n) {
this->n = n;
bit.assign(n, 0);
}
int sum(int i) {
int res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
res += bit[i];
}
return res;
}
void inc(int i, int delta) {
for (; i < n; i = i | (i + 1)) {
bit[i] += delta;
}
}
int getsum(int l, int r) { return sum(r) - sum(l - 1); }
void init(vector<int> &v) {
init(2 * v.size() + 10);
int n = 2 * v.size();
for (int i = 1; i <= n; i++) inc(i, 0);
}
} BIT;
int main() {
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
};
int n, q;
cin >> n >> q;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(0);
BIT bit1, bit2;
bit1.init(v);
bit2.init(v);
while (q--) {
int a;
cin >> a;
if (a == 1) {
int x, val;
cin >> x >> val;
x--;
if (level[x]) {
bit2.inc(start[x], val);
bit2.inc(finish[x] + 1, -1 * val);
bit1.inc(start[x], -1 * val);
bit1.inc(finish[x] + 1, val);
} else {
bit1.inc(start[x], val);
bit1.inc(finish[x] + 1, -1 * val);
bit2.inc(start[x], -1 * val);
bit2.inc(finish[x] + 1, val);
}
} else {
int x;
cin >> x;
x--;
if (level[x])
cout << bit2.sum(start[x]) + v[x] << endl;
else
cout << bit1.sum(start[x]) + v[x] << endl;
}
}
return 0;
}
```
|
### Prompt
Generate a cpp solution to the following problem:
Little girl Tanya is learning how to decrease a number by one, but she does it wrong with a number consisting of two or more digits. Tanya subtracts one from a number by the following algorithm:
* if the last digit of the number is non-zero, she decreases the number by one;
* if the last digit of the number is zero, she divides the number by 10 (i.e. removes the last digit).
You are given an integer number n. Tanya will subtract one from it k times. Your task is to print the result after all k subtractions.
It is guaranteed that the result will be positive integer number.
Input
The first line of the input contains two integer numbers n and k (2 ≤ n ≤ 10^9, 1 ≤ k ≤ 50) — the number from which Tanya will subtract and the number of subtractions correspondingly.
Output
Print one integer number — the result of the decreasing n by one k times.
It is guaranteed that the result will be positive integer number.
Examples
Input
512 4
Output
50
Input
1000000000 9
Output
1
Note
The first example corresponds to the following sequence: 512 → 511 → 510 → 51 → 50.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
for (int i = 0; i < k; i++) {
if (n % 10 == 0) {
n /= 10;
} else {
n--;
}
}
cout << n;
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
We'll call position i (1 ≤ i ≤ n) in permutation p1, p2, ..., pn good, if |p[i] - i| = 1. Count the number of permutations of size n with exactly k good positions. Print the answer modulo 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ n).
Output
Print the number of permutations of length n with exactly k good positions modulo 1000000007 (109 + 7).
Examples
Input
1 0
Output
1
Input
2 1
Output
0
Input
3 2
Output
4
Input
4 1
Output
6
Input
7 4
Output
328
Note
The only permutation of size 1 has 0 good positions.
Permutation (1, 2) has 0 good positions, and permutation (2, 1) has 2 positions.
Permutations of size 3:
1. (1, 2, 3) — 0 positions
2. <image> — 2 positions
3. <image> — 2 positions
4. <image> — 2 positions
5. <image> — 2 positions
6. (3, 2, 1) — 0 positions
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int N = 1011, K = 1011;
int S[N][K], dp[N][K][3][2];
void add(int &a, int x) { a = (a + x) % Mod; }
int main() {
int n, k;
cin >> n >> k;
S[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j][2][1] = 0;
dp[i][j][2][0] = S[i - 1][j];
for (int z = 0; z < 2; z++) {
if (j >= 1) add(dp[i][j][1][0], dp[i - 1][j - 1][z][0]);
add(dp[i][j][1][0], dp[i - 1][j][z][1]);
}
dp[i][j][1][1] = j >= 2 ? S[i - 2][j - 2] : 0;
add(dp[i][j][0][0], 1LL * dp[i - 1][j][2][0] * (i - 2 - j) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j + 1][2][0] * (j + 1) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j][1][0] * (i - 2 - j) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j][1][1] * (i - 2 - j + 1) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j + 1][1][0] * j % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j + 1][1][1] * (j - 1) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j][0][0] * (i - 2 - j - 1) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j][0][1] * (i - 2 - j) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j + 1][0][0] * (j + 1) % Mod);
add(dp[i][j][0][0], 1LL * dp[i - 1][j + 1][0][1] * j % Mod);
for (int z = 0; z < 2; z++) {
add(dp[i][j][0][1], dp[i - 1][j][1][z]);
if (j >= 1) add(dp[i][j][0][1], dp[i - 1][j - 1][0][z]);
}
for (int y = 0; y < 3; y++)
for (int z = 0; z < 2; z++) add(S[i][j], dp[i][j][y][z]);
}
}
cout << S[n][k] << endl;
}
```
|
### Prompt
Your task is to create a cpp solution to the following problem:
Right now she actually isn't. But she will be, if you don't solve this problem.
You are given integers n, k, A and B. There is a number x, which is initially equal to n. You are allowed to perform two types of operations:
1. Subtract 1 from x. This operation costs you A coins.
2. Divide x by k. Can be performed only if x is divisible by k. This operation costs you B coins.
What is the minimum amount of coins you have to pay to make x equal to 1?
Input
The first line contains a single integer n (1 ≤ n ≤ 2·109).
The second line contains a single integer k (1 ≤ k ≤ 2·109).
The third line contains a single integer A (1 ≤ A ≤ 2·109).
The fourth line contains a single integer B (1 ≤ B ≤ 2·109).
Output
Output a single integer — the minimum amount of coins you have to pay to make x equal to 1.
Examples
Input
9
2
3
1
Output
6
Input
5
5
2
20
Output
8
Input
19
3
4
2
Output
12
Note
In the first testcase, the optimal strategy is as follows:
* Subtract 1 from x (9 → 8) paying 3 coins.
* Divide x by 2 (8 → 4) paying 1 coin.
* Divide x by 2 (4 → 2) paying 1 coin.
* Divide x by 2 (2 → 1) paying 1 coin.
The total cost is 6 coins.
In the second test case the optimal strategy is to subtract 1 from x 4 times paying 8 coins in total.
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
const int mod = 1e9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int inf = 0x3f3f3f3f;
using namespace std;
int main() {
long long n, k, a, b;
cin >> n >> k >> a >> b;
long long ans = 0;
if (n < k) {
cout << (n - 1) * a << endl;
return 0;
}
while (n != 1) {
if (n % k != 0) {
ans += (n % k) * a;
n = n - (n % k);
}
if (b < (n - n / k) * a) {
ans += b;
n = n / k;
} else {
ans += (n - 1) * a;
n = 1;
}
}
cout << ans << endl;
return 0;
}
```
|
### Prompt
Please formulate a Cpp solution to the following problem:
Given is a positive integer N. How many tuples (A,B,C) of positive integers satisfy A \times B + C = N?
Constraints
* 2 \leq N \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
3
Output
3
Input
100
Output
473
Input
1000000
Output
13969985
### Response
```cpp
#include<iostream>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (n / i) - (n % i == 0);
}
cout << ans;
}
```
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long INF64 = 1e18;
const long long INF32 = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
long long n, q, x, y, r;
cin >> n >> q;
while (q--) {
cin >> x >> y;
r = (x + y) % 2;
cout << n * ((x - 1) / 2) + ((n + 1 - r) / 2) * ((x - 1) % 2) +
(y + 1) / 2 + ((n * n + 1) / 2) * r
<< endl;
}
}
return 0;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
A plane is flying at a constant height of h meters above the ground surface. Let's consider that it is flying from the point (-10^9, h) to the point (10^9, h) parallel with Ox axis.
A glider is inside the plane, ready to start his flight at any moment (for the sake of simplicity let's consider that he may start only when the plane's coordinates are integers). After jumping from the plane, he will fly in the same direction as the plane, parallel to Ox axis, covering a unit of distance every second. Naturally, he will also descend; thus his second coordinate will decrease by one unit every second.
There are ascending air flows on certain segments, each such segment is characterized by two numbers x_1 and x_2 (x_1 < x_2) representing its endpoints. No two segments share any common points. When the glider is inside one of such segments, he doesn't descend, so his second coordinate stays the same each second. The glider still flies along Ox axis, covering one unit of distance every second.
<image> If the glider jumps out at 1, he will stop at 10. Otherwise, if he jumps out at 2, he will stop at 12.
Determine the maximum distance along Ox axis from the point where the glider's flight starts to the point where his flight ends if the glider can choose any integer coordinate to jump from the plane and start his flight. After touching the ground the glider stops altogether, so he cannot glide through an ascending airflow segment if his second coordinate is 0.
Input
The first line contains two integers n and h (1 ≤ n ≤ 2⋅10^{5}, 1 ≤ h ≤ 10^{9}) — the number of ascending air flow segments and the altitude at which the plane is flying, respectively.
Each of the next n lines contains two integers x_{i1} and x_{i2} (1 ≤ x_{i1} < x_{i2} ≤ 10^{9}) — the endpoints of the i-th ascending air flow segment. No two segments intersect, and they are given in ascending order.
Output
Print one integer — the maximum distance along Ox axis that the glider can fly from the point where he jumps off the plane to the point where he lands if he can start his flight at any integer coordinate.
Examples
Input
3 4
2 5
7 9
10 11
Output
10
Input
5 10
5 7
11 12
16 20
25 26
30 33
Output
18
Input
1 1000000000
1 1000000000
Output
1999999999
Note
In the first example if the glider can jump out at (2, 4), then the landing point is (12, 0), so the distance is 12-2 = 10.
In the second example the glider can fly from (16,10) to (34,0), and the distance is 34-16=18.
In the third example the glider can fly from (-100,1000000000) to (1999999899,0), so the distance is 1999999899-(-100)=1999999999.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, h, i, j, sum, ans = 0, diff[200010];
pair<int, int> p[200010];
deque<pair<int, int> > q;
int main() {
scanf("%d%d", &n, &h);
for (i = 1; i <= n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
diff[i - 1] = p[i].first - p[i - 1].second;
}
for (i = j = 1; i <= n; i++) {
for (; j < n && (sum + diff[j] < h); j++) sum += diff[j];
ans = max(ans, p[j].second - p[i].first + h - sum);
sum -= diff[i];
}
printf("%d\n", ans);
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (<image>, where <image> denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)) and stores this encrypted message A. Alice is smart. Be like Alice.
For example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).
Alice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.
Bob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.
In the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).
One year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?
Bob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?
More precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation π such that <image> for every i.
Note that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that Si < Ti and for all j < i the condition Sj = Tj holds.
Input
The first line contains a single integer N (1 ≤ N ≤ 300000), the length of the message.
The second line contains N integers A1, A2, ..., AN (0 ≤ Ai < 230) representing the encrypted message.
The third line contains N integers P1, P2, ..., PN (0 ≤ Pi < 230) representing the permuted encryption key.
Output
Output a single line with N integers, the lexicographically smallest possible message O. Note that all its elements should be non-negative.
Examples
Input
3
8 4 13
17 2 7
Output
10 3 28
Input
5
12 7 87 22 11
18 39 9 12 16
Output
0 14 69 6 44
Input
10
331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951
226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667
Output
128965467 243912600 4281110 112029883 223689619 76924724 429589 119397893 613490433 362863284
Note
In the first case, the solution is (10, 3, 28), since <image>, <image> and <image>. Other possible permutations of key yield messages (25, 6, 10), (25, 3, 15), (10, 21, 10), (15, 21, 15) and (15, 6, 28), which are all lexicographically larger than the solution.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
double Double() {
double x;
scanf("%lf", &x);
return x;
}
const int N = 3 * (int)1e5 + 5;
const long long MOD = (int)1e9 + 7;
struct Trie {
Trie* path[2];
int mark;
Trie() {
path[0] = path[1] = NULL;
mark = 0;
}
} * root;
void insert(int x) {
Trie* cur = root;
for (int i = 30; i >= 0; i--) {
int id = (bool)(x & (1 << i));
if (cur->path[id] == NULL) cur->path[id] = new Trie();
cur = cur->path[id];
cur->mark++;
}
}
int search(int x) {
int ret = 0;
Trie* cur = root;
for (int i = 30; i >= 0; i--) {
int id = (bool)(x & (1 << i));
if (cur->path[id] != NULL and cur->path[id]->mark > 0) {
cur = cur->path[id];
cur->mark--;
} else {
ret |= (1 << i);
cur = cur->path[(bool)(id ^ 1)];
cur->mark--;
}
}
return ret;
}
int arr[N];
int main() {
root = new Trie();
int n = Int();
for (int i = 0; i < n; i++) arr[i] = Int();
for (int i = 0; i < n; i++) insert(Int());
for (int i = 0; i < n; i++) {
cout << search(arr[i]) << " ";
}
cout << '\n';
return 0;
}
```
|
### Prompt
In CPP, your task is to solve the following problem:
Calculate the number of ways to place n rooks on n × n chessboard so that both following conditions are met:
* each empty cell is under attack;
* exactly k pairs of rooks attack each other.
An empty cell is under attack if there is at least one rook in the same row or at least one rook in the same column. Two rooks attack each other if they share the same row or column, and there are no other rooks between them. For example, there are only two pairs of rooks that attack each other in the following picture:
<image> One of the ways to place the rooks for n = 3 and k = 2
Two ways to place the rooks are considered different if there exists at least one cell which is empty in one of the ways but contains a rook in another way.
The answer might be large, so print it modulo 998244353.
Input
The only line of the input contains two integers n and k (1 ≤ n ≤ 200000; 0 ≤ k ≤ (n(n - 1))/(2)).
Output
Print one integer — the number of ways to place the rooks, taken modulo 998244353.
Examples
Input
3 2
Output
6
Input
3 3
Output
0
Input
4 0
Output
24
Input
1337 42
Output
807905441
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
const int mod = 998244353;
long long quick(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
long long inv(long long a) { return quick(a, mod - 2); }
const int maxn = 2e5 + 7;
long long fac[maxn];
inline long long C(int n, int m) {
if (n < m) return 0;
return fac[n] * inv(fac[n - m]) % mod * inv(fac[m]) % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i < maxn; i++) fac[i] = fac[i - 1] * i % mod;
int n, k;
cin >> n >> k;
if (k == 0)
print(fac[n]);
else if (k > n)
print(0);
else {
long long ans = 0;
for (int i = 0; i <= n - k; i++) {
long long cur = C(n - k, i);
cur = cur * quick(n - k - i, n) % mod;
if (!(i & 1))
ans = (ans + cur) % mod;
else
ans = (ans - cur + mod) % mod;
}
print(ans * 2 % mod * C(n, n - k) % mod);
}
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... + (m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f.
Constraints
* All values in input are integers.
* 2 \leq N \leq 3000
* 2 \leq a_i \leq 10^5
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the maximum value of f.
Examples
Input
3
3 4 6
Output
10
Input
5
7 46 11 20 11
Output
90
Input
7
994 518 941 851 647 2 581
Output
4527
### Response
```cpp
#include<stdio.h>
int main(void)
{
int n,a[3000],i,s=0;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
s+=a[i];
}
printf("%d\n",s-n);
return 0;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
An old document says that a Ninja House in Kanazawa City was in fact a defensive fortress, which was designed like a maze. Its rooms were connected by hidden doors in a complicated manner, so that any invader would become lost. Each room has at least two doors.
The Ninja House can be modeled by a graph, as shown in Figure l. A circle represents a room. Each line connecting two circles represents a door between two rooms.
<image> Figure l. Graph Model of Ninja House. | Figure 2. Ninja House exploration.
---|---
I decided to draw a map, since no map was available. Your mission is to help me draw a map from the record of my exploration.
I started exploring by entering a single entrance that was open to the outside. The path I walked is schematically shown in Figure 2, by a line with arrows. The rules for moving between rooms are described below.
After entering a room, I first open the rightmost door and move to the next room. However, if the next room has already been visited, I close the door without entering, and open the next rightmost door, and so on. When I have inspected all the doors of a room, I go back through the door I used to enter the room.
I have a counter with me to memorize the distance from the first room. The counter is incremented when I enter a new room, and decremented when I go back from a room. In Figure 2, each number in parentheses is the value of the counter when I have entered the room, i.e., the distance from the first room. In contrast, the numbers not in parentheses represent the order of my visit.
I take a record of my exploration. Every time I open a door, I record a single number, according to the following rules.
1. If the opposite side of the door is a new room, I record the number of doors in that room, which is a positive number.
2. If it is an already visited room, say R, I record ``the distance of R from the first room'' minus ``the distance of the current room from the first room'', which is a negative number.
In the example shown in Figure 2, as the first room has three doors connecting other rooms, I initially record ``3''. Then when I move to the second, third, and fourth rooms, which all have three doors, I append ``3 3 3'' to the record. When I skip the entry from the fourth room to the first room, the distance difference ``-3'' (minus three) will be appended, and so on. So, when I finish this exploration, its record is a sequence of numbers ``3 3 3 3 -3 3 2 -5 3 2 -5 -3''.
There are several dozens of Ninja Houses in the city. Given a sequence of numbers for each of these houses, you should produce a graph for each house.
Input
The first line of the input is a single integer n, indicating the number of records of Ninja Houses I have visited. You can assume that n is less than 100. Each of the following n records consists of numbers recorded on one exploration and a zero as a terminator. Each record consists of one or more lines whose lengths are less than 1000 characters. Each number is delimited by a space or a newline. You can assume that the number of rooms for each Ninja House is less than 100, and the number of doors in each room is less than 40.
Output
For each Ninja House of m rooms, the output should consist of m lines. The j-th line of each such m lines should look as follows:
i r1 r2 ... rki
where r1, ... , rki should be rooms adjoining room i, and ki should be the number of doors in room i. Numbers should be separated by exactly one space character. The rooms should be numbered from 1 in visited order. r1, r2, ... , rki should be in ascending order. Note that the room i may be connected to another room through more than one door. In this case, that room number should appear in r1, ... , rki as many times as it is connected by different doors.
Example
Input
2
3 3 3 3 -3 3 2 -5 3 2 -5 -3 0
3 5 4 -2 4 -3 -2 -2 -1 0
Output
1 2 4 6
2 1 3 8
3 2 4 7
4 1 3 5
5 4 6 7
6 1 5
7 3 5 8
8 2 7
1 2 3 4
2 1 3 3 4 4
3 1 2 2 4
4 1 2 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace {
template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
if (vs.empty()) return os << "[]";
os << "[" << vs[0];
for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
return os << "]";
}
vector<int> R;
void input() {
R.clear();
while (true) {
int x; cin >> x;
if (x == 0) break;
R.push_back(x);
}
}
vector< vector<int> > G;
int N;
vector<int> Z;
void dfs(int v, int& c, int d, vector<int>& x, int& nv) {
if (c == R.size()) return;
//cout << v << " " << c << " " << d << " " << x << endl;
int p = x[d];
x[d] = v;
while (c < R.size() && Z[v] > 0) {
int r = R[c];
if (r > 0) {
G[v].push_back(nv);
G[nv].push_back(v);
Z[v]--; Z[nv]--;
c++;
int n = nv; nv++;
dfs(n, c, d + 1, x, nv);
} else {
int n = x[d + r];
//cout << "connect " << v << " " << n << endl;
G[v].push_back(n);
G[n].push_back(v);
Z[v]--; Z[n]--;
c++;
}
}
x[d] = p;
}
void solve() {
Z.clear();
for (int i = 0; i < R.size(); i++) {
int r = R[i];
if (r > 0) {
Z.push_back(r);
}
}
N = int(Z.size());
G.clear(); G.resize(N);
vector<int> x(N, -1);
int c = 1;
int nv = 1;
dfs(0, c, 0, x, nv);
for (int i = 0; i < N; i++) {
sort(G[i].begin(), G[i].end());
int M = G[i].size();
cout << i + 1;
for (int j = 0; j < M; j++) {
cout << " " << G[i][j] + 1;
}
cout << endl;
}
}
}
int main() {
int N; cin >> N;
for (int i = 0; i < N; i++) {
input(); solve();
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
Polycarpus is the director of a large corporation. There are n secretaries working for the corporation, each of them corresponds via the famous Spyke VoIP system during the day. We know that when two people call each other via Spyke, the Spyke network assigns a unique ID to this call, a positive integer session number.
One day Polycarpus wondered which secretaries are talking via the Spyke and which are not. For each secretary, he wrote out either the session number of his call or a 0 if this secretary wasn't talking via Spyke at that moment.
Help Polycarpus analyze these data and find out the number of pairs of secretaries that are talking. If Polycarpus has made a mistake in the data and the described situation could not have taken place, say so.
Note that the secretaries can correspond via Spyke not only with each other, but also with the people from other places. Also, Spyke conferences aren't permitted — that is, one call connects exactly two people.
Input
The first line contains integer n (1 ≤ n ≤ 103) — the number of secretaries in Polycarpus's corporation. The next line contains n space-separated integers: id1, id2, ..., idn (0 ≤ idi ≤ 109). Number idi equals the number of the call session of the i-th secretary, if the secretary is talking via Spyke, or zero otherwise.
Consider the secretaries indexed from 1 to n in some way.
Output
Print a single integer — the number of pairs of chatting secretaries, or -1 if Polycarpus's got a mistake in his records and the described situation could not have taken place.
Examples
Input
6
0 1 7 1 7 10
Output
2
Input
3
1 1 1
Output
-1
Input
1
0
Output
0
Note
In the first test sample there are two Spyke calls between secretaries: secretary 2 and secretary 4, secretary 3 and secretary 5.
In the second test sample the described situation is impossible as conferences aren't allowed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> S;
int x1, x2;
int main() {
int n, c, ans = 0, l;
long long a[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
c = 0;
for (int j = i; j < n; j++) {
if (a[i] == a[j]) c++;
}
if (c > 2) {
cout << "-1";
return 0;
}
if (c == 2) ans++;
}
}
cout << ans;
return 0;
return 0;
}
```
|
### Prompt
Your task is to create a Cpp solution to the following problem:
You are the gym teacher in the school.
There are n students in the row. And there are two rivalling students among them. The first one is in position a, the second in position b. Positions are numbered from 1 to n from left to right.
Since they are rivals, you want to maximize the distance between them. If students are in positions p and s respectively, then distance between them is |p - s|.
You can do the following operation at most x times: choose two adjacent (neighbouring) students and swap them.
Calculate the maximum distance between two rivalling students after at most x swaps.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of each test case contains four integers n, x, a and b (2 ≤ n ≤ 100, 0 ≤ x ≤ 100, 1 ≤ a, b ≤ n, a ≠ b) — the number of students in the row, the number of swaps which you can do, and positions of first and second rivaling students respectively.
Output
For each test case print one integer — the maximum distance between two rivaling students which you can obtain.
Example
Input
3
5 1 3 2
100 33 100 1
6 0 2 3
Output
2
99
1
Note
In the first test case you can swap students in positions 3 and 4. And then the distance between the rivals is equal to |4 - 2| = 2.
In the second test case you don't have to swap students.
In the third test case you can't swap students.
### Response
```cpp
#include <bits/stdc++.h>
const int len = 1e9 + 7;
using namespace std;
void solve() {
int n, x, a, b, d = 0;
cin >> n >> x >> a >> b;
int i = min(a, b), j = max(a, b);
if (x == 0) {
cout << abs(a - b) << "\n";
return;
}
while (x--) {
if (i > 1) {
i--;
} else if (j < n) {
j++;
}
d = max(d, abs(i - j));
}
cout << d << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
```
|
### Prompt
Generate a CPP solution to the following problem:
There are N towns on a plane. The i-th town is located at the coordinates (x_i,y_i). There may be more than one town at the same coordinates.
You can build a road between two towns at coordinates (a,b) and (c,d) for a cost of min(|a-c|,|b-d|) yen (the currency of Japan). It is not possible to build other types of roads.
Your objective is to build roads so that it will be possible to travel between every pair of towns by traversing roads. At least how much money is necessary to achieve this?
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ x_i,y_i ≤ 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the minimum necessary amount of money in order to build roads so that it will be possible to travel between every pair of towns by traversing roads.
Examples
Input
3
1 5
3 9
7 8
Output
3
Input
6
8 3
4 9
12 19
18 1
13 5
7 6
Output
8
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
constexpr int N = 100005;
struct Edege{
int u, v, w;
bool operator < (const Edege &b) const{
return w < b.w;
}
};
struct Node{
int id, x;
bool operator < (const Node &b) const {
return x < b.x;
}
};
int fa[N], cnt;
Node a[N], b[N];
Edege e[N * 3];
void add(int u, int v, int w){
e[cnt].u = u;
e[cnt].v = v;
e[cnt++].w = w;
}
int findFa(int u){
if(fa[u] != u){
fa[u] = findFa(fa[u]);
}
return fa[u];
}
int main(){
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i){
fa[i] = i;
}
cnt = 1;
for(int i = 1; i <= n; ++i){
a[i].id = b[i].id = i;
scanf("%d%d", &a[i].x, &b[i].x);
}
sort(a + 1, a + n + 1);
for(int i = 2; i <= n; ++i){
add(a[i].id, a[i - 1].id, a[i].x - a[i - 1].x);
}
sort(b + 1, b + n + 1);
for(int i = 2; i <= n; ++i){
add(b[i].id, b[i - 1].id, b[i].x - b[i - 1].x);
}
sort(e + 1, e + cnt + 1);
long long tempAns = 0;
for(int i = 1; i < cnt; ++i){
int u = e[i].u, v = e[i].v, w = e[i].w;
u = findFa(u);
v = findFa(v);
if(u != v){
tempAns += w;
fa[v] = u;
}
}
cout << tempAns << endl;
return 0;
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
<image>
At the request of a friend who started learning abacus, you decided to create a program to display the abacus beads. Create a program that takes a certain number as input and outputs a row of abacus beads. However, the number of digits of the abacus to be displayed is 5 digits, and the arrangement of beads from 0 to 9 is as follows using'*' (half-width asterisk),''(half-width blank), and'=' (half-width equal). It shall be expressed as.
<image>
Input
Multiple test cases are given. Up to 5 digits (integer) are given on one line for each test case.
The number of test cases does not exceed 1024.
Output
Output the abacus bead arrangement for each test case. Insert a blank line between the test cases.
Example
Input
2006
1111
Output
****
*
=====
* *
****
* ***
*****
*****
*****
=====
****
*
*****
*****
*****
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
int n;
bool first = true;
while (cin >> n) {
vector<string> ans(8, "");
for (int keta = 0; keta < 5; ++keta) {
int d = n % 10;
if (d >= 5) {
ans[0] = " " + ans[0];
ans[1] = "*" + ans[1];
} else {
ans[0] = "*" + ans[0];
ans[1] = " " + ans[1];
}
ans[2] += "=";
for (int i = 0; i < 5; ++i) {
if (i == d%5)
ans[i+3] = " " + ans[i+3];
else
ans[i+3] = "*" + ans[i+3];
}
n /= 10;
}
if (!first)
cout << endl;
for (unsigned int i = 0; i < ans.size(); ++i)
cout << ans[i] << endl;
first = false;
}
return 0;
}
```
|
### Prompt
Generate a CPP solution to the following problem:
There is an integer sequence of length 2^N: A_0, A_1, ..., A_{2^N-1}. (Note that the sequence is 0-indexed.)
For every integer K satisfying 1 \leq K \leq 2^N-1, solve the following problem:
* Let i and j be integers. Find the maximum value of A_i + A_j where 0 \leq i < j \leq 2^N-1 and (i or j) \leq K. Here, or denotes the bitwise OR.
Constraints
* 1 \leq N \leq 18
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 ... A_{2^N-1}
Output
Print 2^N-1 lines. In the i-th line, print the answer of the problem above for K=i.
Examples
Input
2
1 2 3 1
Output
3
4
5
Input
3
10 71 84 33 6 47 23 25
Output
81
94
155
155
155
155
155
Input
4
75 26 45 72 81 47 97 97 2 2 25 82 84 17 56 32
Output
101
120
147
156
156
178
194
194
194
194
194
194
194
194
194
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1 << 18;
using P = pair<int, int>;
P a[N];
P calc(P a, P b) {
vector<int> v{a.first, a.second, b.first, b.second};
sort(begin(v), end(v));
return P(v[3], v[2]);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n; cin >> n;
int m = 1 << n;
int mask = m - 1;
for(int i = 0; i < m; i++) {
int x; cin >> x;
a[i^mask] = P(x, -1e9);
}
for(int i = 0; i < n; i++) for(int b = 0; b < (1 << n); b++)
if(!(b & (1 << i))) a[b] = calc(a[b], a[b | (1 << i)]);
int ma = 0;
for(int i = 1; i < m; i++) cout << (ma = max(a[i^mask].first + a[i^mask].second, ma)) << endl;
return 0;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a robot staying at X=0 on the Ox axis. He has to walk to X=n. You are controlling this robot and controlling how he goes. The robot has a battery and an accumulator with a solar panel.
The i-th segment of the path (from X=i-1 to X=i) can be exposed to sunlight or not. The array s denotes which segments are exposed to sunlight: if segment i is exposed, then s_i = 1, otherwise s_i = 0.
The robot has one battery of capacity b and one accumulator of capacity a. For each segment, you should choose which type of energy storage robot will use to go to the next point (it can be either battery or accumulator). If the robot goes using the battery, the current charge of the battery is decreased by one (the robot can't use the battery if its charge is zero). And if the robot goes using the accumulator, the current charge of the accumulator is decreased by one (and the robot also can't use the accumulator if its charge is zero).
If the current segment is exposed to sunlight and the robot goes through it using the battery, the charge of the accumulator increases by one (of course, its charge can't become higher than it's maximum capacity).
If accumulator is used to pass some segment, its charge decreases by 1 no matter if the segment is exposed or not.
You understand that it is not always possible to walk to X=n. You want your robot to go as far as possible. Find the maximum number of segments of distance the robot can pass if you control him optimally.
Input
The first line of the input contains three integers n, b, a (1 ≤ n, b, a ≤ 2 ⋅ 10^5) — the robot's destination point, the battery capacity and the accumulator capacity, respectively.
The second line of the input contains n integers s_1, s_2, ..., s_n (0 ≤ s_i ≤ 1), where s_i is 1 if the i-th segment of distance is exposed to sunlight, and 0 otherwise.
Output
Print one integer — the maximum number of segments the robot can pass if you control him optimally.
Examples
Input
5 2 1
0 1 0 1 0
Output
5
Input
6 2 1
1 0 0 1 0 1
Output
3
Note
In the first example the robot can go through the first segment using the accumulator, and charge levels become b=2 and a=0. The second segment can be passed using the battery, and charge levels become b=1 and a=1. The third segment can be passed using the accumulator, and charge levels become b=1 and a=0. The fourth segment can be passed using the battery, and charge levels become b=0 and a=1. And the fifth segment can be passed using the accumulator.
In the second example the robot can go through the maximum number of segments using battery two times and accumulator one time in any order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, b, a;
cin >> n >> b >> a;
int full = a;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int ans = 0;
for (int i = 0; i < n; i++) {
if (a == 0 && b == 0) break;
if (a == 0) {
b--;
if (v[i] == 1 && a < full) a++;
} else if (b == 0) {
a--;
} else {
if (v[i] == 1) {
if (a == full) {
a--;
} else {
b--;
if (a < full) a++;
}
} else {
a--;
}
}
ans++;
}
cout << ans;
}
```
|
### Prompt
Generate a CPP solution to the following problem:
You are given a rooted tree with n vertices, the root of the tree is the vertex 1. Each vertex has some non-negative price. A leaf of the tree is a non-root vertex that has degree 1.
Arkady and Vasily play a strange game on the tree. The game consists of three stages. On the first stage Arkady buys some non-empty set of vertices of the tree. On the second stage Vasily puts some integers into all leaves of the tree. On the third stage Arkady can perform several (possibly none) operations of the following kind: choose some vertex v he bought on the first stage and some integer x, and then add x to all integers in the leaves in the subtree of v. The integer x can be positive, negative of zero.
A leaf a is in the subtree of a vertex b if and only if the simple path between a and the root goes through b.
Arkady's task is to make all integers in the leaves equal to zero. What is the minimum total cost s he has to pay on the first stage to guarantee his own win independently of the integers Vasily puts on the second stage? Also, we ask you to find all such vertices that there is an optimal (i.e. with cost s) set of vertices containing this one such that Arkady can guarantee his own win buying this set on the first stage.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the number of vertices in the tree.
The second line contains n integers c_1, c_2, …, c_n (0 ≤ c_i ≤ 10^9), where c_i is the price of the i-th vertex.
Each of the next n - 1 lines contains two integers a and b (1 ≤ a, b ≤ n), denoting an edge of the tree.
Output
In the first line print two integers: the minimum possible cost s Arkady has to pay to guarantee his own win, and the number of vertices k that belong to at least one optimal set.
In the second line print k distinct integers in increasing order the indices of the vertices that belong to at least one optimal set.
Examples
Input
5
5 1 3 2 1
1 2
2 3
2 4
1 5
Output
4 3
2 4 5
Input
3
1 1 1
1 2
1 3
Output
2 3
1 2 3
Note
In the second example all sets of two vertices are optimal. So, each vertex is in at least one optimal set.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, w[N];
vector<int> G[N];
int fa[N], l[N], r[N];
int fnd(int x) { return x == fa[x] ? x : fa[x] = fnd(fa[x]); }
struct E {
int u, v, c, w;
bool operator<(const E &z) const { return w < z.w; }
} e[N];
int k;
void dfs(int u, int f) {
l[u] = n, r[u] = 0;
for (int v : G[u])
if (v != f) dfs(v, u), l[u] = min(l[u], l[v]), r[u] = max(r[u], r[v]);
if (G[u].size() == 1 && f) l[u] = r[u] = ++k;
e[u] = (E){l[u], r[u] + 1, u, w[u]};
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1, u, v; i < n; i++)
scanf("%d%d", &u, &v), G[u].push_back(v), G[v].push_back(u);
dfs(1, 0);
long long ans = 0;
sort(e + 1, e + n + 1);
static bool ex[N];
int ct = 0;
for (int i = 1, j; i <= n; i = j) {
j = i;
while (e[j].w == e[i].w) ++j;
for (int k = i; k < j; k++) {
int u = fnd(e[k].u), v = fnd(e[k].v);
if (u != v) ex[e[k].c] = true, ++ct;
}
for (int k = i; k < j; k++) {
int u = fnd(e[k].u), v = fnd(e[k].v);
if (u != v) fa[u] = v, ans += e[k].w;
}
}
cout << ans << " " << ct << '\n';
for (int i = 1; i <= n; i++)
if (ex[i]) cout << i << " ";
return 0;
}
```
|
### Prompt
Your task is to create a CPP solution to the following problem:
Students love to celebrate their holidays. Especially if the holiday is the day of the end of exams!
Despite the fact that Igor K., unlike his groupmates, failed to pass a programming test, he decided to invite them to go to a cafe so that each of them could drink a bottle of... fresh cow milk. Having entered the cafe, the m friends found n different kinds of milk on the menu, that's why they ordered n bottles — one bottle of each kind. We know that the volume of milk in each bottle equals w.
When the bottles were brought in, they decided to pour all the milk evenly among the m cups, so that each got a cup. As a punishment for not passing the test Igor was appointed the person to pour the milk. He protested that he was afraid to mix something up and suggested to distribute the drink so that the milk from each bottle was in no more than two different cups. His friends agreed but they suddenly faced the following problem — and what is actually the way to do it?
Help them and write the program that will help to distribute the milk among the cups and drink it as quickly as possible!
Note that due to Igor K.'s perfectly accurate eye and unswerving hands, he can pour any fractional amount of milk from any bottle to any cup.
Input
The only input data file contains three integers n, w and m (1 ≤ n ≤ 50, 100 ≤ w ≤ 1000, 2 ≤ m ≤ 50), where n stands for the number of ordered bottles, w stands for the volume of each of them and m stands for the number of friends in the company.
Output
Print on the first line "YES" if it is possible to pour the milk so that the milk from each bottle was in no more than two different cups. If there's no solution, print "NO".
If there is a solution, then print m more lines, where the i-th of them describes the content of the i-th student's cup. The line should consist of one or more pairs that would look like "b v". Each such pair means that v (v > 0) units of milk were poured into the i-th cup from bottle b (1 ≤ b ≤ n). All numbers b on each line should be different.
If there are several variants to solve the problem, print any of them. Print the real numbers with no less than 6 digits after the decimal point.
Examples
Input
2 500 3
Output
YES
1 333.333333
2 333.333333
2 166.666667 1 166.666667
Input
4 100 5
Output
YES
3 20.000000 4 60.000000
1 80.000000
4 40.000000 2 40.000000
3 80.000000
2 60.000000 1 20.000000
Input
4 100 7
Output
NO
Input
5 500 2
Output
YES
4 250.000000 5 500.000000 2 500.000000
3 500.000000 1 500.000000 4 250.000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int nbottles, ncups;
double bvolume, cvolume;
cin >> nbottles >> bvolume >> ncups;
cvolume = double(nbottles) * bvolume / ncups;
if (nbottles < ncups && nbottles % (ncups - nbottles) != 0) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
cout.precision(6);
int poured = 0, left;
for (int i = 1; i <= nbottles; i++) {
left = nbottles - poured;
poured += ncups;
if (poured < nbottles)
cout << i << ' ' << fixed << bvolume << ' ';
else {
cout << i << ' ' << fixed << (left * bvolume) / ncups << '\n';
poured -= nbottles;
for (; poured >= nbottles; poured -= nbottles)
cout << i << ' ' << cvolume << '\n';
if (poured > 0)
cout << i << ' ' << fixed << (poured * bvolume) / ncups << ' ';
}
}
return 0;
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
There are n castles in the Lannister's Kingdom and some walls connect two castles, no two castles are connected by more than one wall, no wall connects a castle to itself.
Sir Jaime Lannister has discovered that Daenerys Targaryen is going to attack his kingdom soon. Therefore he wants to defend his kingdom. He has k liters of a strange liquid. He wants to distribute that liquid among the castles, so each castle may contain some liquid (possibly zero or non-integer number of liters). After that the stability of a wall is defined as follows: if the wall connects two castles a and b, and they contain x and y liters of that liquid, respectively, then the strength of that wall is x·y.
Your task is to print the maximum possible sum of stabilities of the walls that Sir Jaime Lannister can achieve.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 40, 1 ≤ k ≤ 1000).
Then n lines follows. The i-th of these lines contains n integers ai, 1, ai, 2, ..., ai, n (<image>). If castles i and j are connected by a wall, then ai, j = 1. Otherwise it is equal to 0.
It is guaranteed that ai, j = aj, i and ai, i = 0 for all 1 ≤ i, j ≤ n.
Output
Print the maximum possible sum of stabilities of the walls that Sir Jaime Lannister can achieve.
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
3 1
0 1 0
1 0 0
0 0 0
Output
0.250000000000
Input
4 4
0 1 0 1
1 0 1 0
0 1 0 1
1 0 1 0
Output
4.000000000000
Note
In the first sample, we can assign 0.5, 0.5, 0 liters of liquid to castles 1, 2, 3, respectively, to get the maximum sum (0.25).
In the second sample, we can assign 1.0, 1.0, 1.0, 1.0 liters of liquid to castles 1, 2, 3, 4, respectively, to get the maximum sum (4.0)
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n, m, k, Max[1 << 20];
bitset<N> go[N], now;
void dfs(int p, int cnt, bitset<N> now) {
if (p == n) {
int S = 0;
for (int i = 0; i < m; i++)
if (now[i]) S |= (1 << i);
Max[S] = max(Max[S], cnt);
return;
}
dfs(p + 1, cnt, now);
if (now[p]) dfs(p + 1, cnt + 1, now & go[p]);
}
int ans;
void solve(int p, int cnt, int S, bitset<N> now) {
if (p == m) return void(ans = max(ans, cnt + Max[S]));
solve(p + 1, cnt, S, now);
if (now[p]) solve(p + 1, cnt + 1, S | (1 << p), now & go[p]);
}
int main() {
scanf("%d%d", &n, &k);
if (n == 0) return printf("%.12lf\n", 0.0), 0;
for (int i = 0; i < n; i++) {
int x;
for (int j = 0; j < n; j++) scanf("%d", &x), go[i][j] = x;
}
m = n >> 1;
for (int i = 0; i < n; i++) now[i] = 1;
dfs(m, 0, now);
for (int i = 0; i < m; i++)
for (int S = 0; S < (1 << m); S++)
if (S >> i & 1) Max[S ^ (1 << i)] = max(Max[S ^ (1 << i)], Max[S]);
solve(0, 0, 0, now);
printf("%.12lf\n", 0.5 * k * k * (ans - 1) / ans);
return 0;
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Ivan has an array consisting of n different integers. He decided to reorder all elements in increasing order. Ivan loves merge sort so he decided to represent his array with one or several increasing sequences which he then plans to merge into one sorted array.
Ivan represent his array with increasing sequences with help of the following algorithm.
While there is at least one unused number in array Ivan repeats the following procedure:
* iterate through array from the left to the right;
* Ivan only looks at unused numbers on current iteration;
* if current number is the first unused number on this iteration or this number is greater than previous unused number on current iteration, then Ivan marks the number as used and writes it down.
For example, if Ivan's array looks like [1, 3, 2, 5, 4] then he will perform two iterations. On first iteration Ivan will use and write numbers [1, 3, 5], and on second one — [2, 4].
Write a program which helps Ivan and finds representation of the given array with one or several increasing sequences in accordance with algorithm described above.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the number of elements in Ivan's array.
The second line contains a sequence consisting of distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — Ivan's array.
Output
Print representation of the given array in the form of one or more increasing sequences in accordance with the algorithm described above. Each sequence must be printed on a new line.
Examples
Input
5
1 3 2 5 4
Output
1 3 5
2 4
Input
4
4 3 2 1
Output
4
3
2
1
Input
4
10 30 50 101
Output
10 30 50 101
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long> z_function(string s) {
long long n = (long long)s.length();
vector<long long> z(n);
for (long long i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
vector<long long> adj[200005];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, d = 0;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
adj[d++].push_back(a[0]);
set<long long> s;
s.insert(a[0]);
map<long long, long long> p;
p[a[0]] = 0;
for (long long i = 1; i < n; i++) {
auto it = s.lower_bound(a[i]);
if (it == s.begin()) {
s.insert(a[i]);
adj[d].push_back(a[i]);
p[a[i]] = d++;
} else {
it--;
adj[p[*it]].push_back(a[i]);
p[a[i]] = p[*it];
s.erase(it);
s.insert(a[i]);
}
}
for (long long i = 0; i < d; i++) {
for (long long j = 0; j < adj[i].size(); j++) {
cout << adj[i][j] << ' ';
}
cout << '\n';
}
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
The legendary Farmer John is throwing a huge party, and animals from all over the world are hanging out at his house. His guests are hungry, so he instructs his cow Bessie to bring out the snacks! Moo!
There are n snacks flavors, numbered with integers 1, 2, …, n. Bessie has n snacks, one snack of each flavor. Every guest has exactly two favorite flavors. The procedure for eating snacks will go as follows:
* First, Bessie will line up the guests in some way.
* Then in this order, guests will approach the snacks one by one.
* Each guest in their turn will eat all remaining snacks of their favorite flavor. In case no favorite flavors are present when a guest goes up, they become very sad.
Help Bessie to minimize the number of sad guests by lining the guests in an optimal way.
Input
The first line contains integers n and k (2 ≤ n ≤ 10^5, 1 ≤ k ≤ 10^5), the number of snacks and the number of guests.
The i-th of the following k lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), favorite snack flavors of the i-th guest.
Output
Output one integer, the smallest possible number of sad guests.
Examples
Input
5 4
1 2
4 3
1 4
3 4
Output
1
Input
6 5
2 3
2 1
3 4
6 5
4 5
Output
0
Note
In the first example, Bessie can order the guests like this: 3, 1, 2, 4. Guest 3 goes first and eats snacks 1 and 4. Then the guest 1 goes and eats the snack 2 only, because the snack 1 has already been eaten. Similarly, the guest 2 goes up and eats the snack 3 only. All the snacks are gone, so the guest 4 will be sad.
In the second example, one optimal ordering is 2, 1, 3, 5, 4. All the guests will be satisfied.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, b, n, m, parent[100005], ans;
int findpar(int x) {
if (parent[x] != x) parent[x] = findpar(parent[x]);
return parent[x];
}
bool disjoint(int x, int y) {
x = findpar(x);
y = findpar(y);
if (x == y)
return false;
else {
parent[y] = x;
return true;
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
if (!disjoint(a, b)) ans++;
}
cout << ans << endl;
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
During the archaeological research in the Middle East you found the traces of three ancient religions: First religion, Second religion and Third religion. You compiled the information on the evolution of each of these beliefs, and you now wonder if the followers of each religion could coexist in peace.
The Word of Universe is a long word containing the lowercase English characters only. At each moment of time, each of the religion beliefs could be described by a word consisting of lowercase English characters.
The three religions can coexist in peace if their descriptions form disjoint subsequences of the Word of Universe. More formally, one can paint some of the characters of the Word of Universe in three colors: 1, 2, 3, so that each character is painted in at most one color, and the description of the i-th religion can be constructed from the Word of Universe by removing all characters that aren't painted in color i.
The religions however evolve. In the beginning, each religion description is empty. Every once in a while, either a character is appended to the end of the description of a single religion, or the last character is dropped from the description. After each change, determine if the religions could coexist in peace.
Input
The first line of the input contains two integers n, q (1 ≤ n ≤ 100 000, 1 ≤ q ≤ 1000) — the length of the Word of Universe and the number of religion evolutions, respectively. The following line contains the Word of Universe — a string of length n consisting of lowercase English characters.
Each of the following line describes a single evolution and is in one of the following formats:
* + i c (i ∈ \{1, 2, 3\}, c ∈ \{a, b, ..., z\}: append the character c to the end of i-th religion description.
* - i (i ∈ \{1, 2, 3\}) – remove the last character from the i-th religion description. You can assume that the pattern is non-empty.
You can assume that no religion will have description longer than 250 characters.
Output
Write q lines. The i-th of them should be YES if the religions could coexist in peace after the i-th evolution, or NO otherwise.
You can print each character in any case (either upper or lower).
Examples
Input
6 8
abdabc
+ 1 a
+ 1 d
+ 2 b
+ 2 c
+ 3 a
+ 3 b
+ 1 c
- 2
Output
YES
YES
YES
YES
YES
YES
NO
YES
Input
6 8
abbaab
+ 1 a
+ 2 a
+ 3 a
+ 1 b
+ 2 b
+ 3 b
- 1
+ 2 z
Output
YES
YES
YES
YES
YES
NO
YES
NO
Note
In the first example, after the 6th evolution the religion descriptions are: ad, bc, and ab. The following figure shows how these descriptions form three disjoint subsequences of the Word of Universe:
<image>
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxn = (long long)1e5 + 5;
const int inf = 0x3f3f3f3f;
char a[4][255], s[maxn];
int len[4];
int nxt[maxn][27];
int last[maxn];
int dp[255][255][255];
inline void f(int x, int y, int z) {
dp[x][y][z] = inf;
if (x && dp[x - 1][y][z] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x - 1][y][z]][a[1][x] - 'a']);
if (y && dp[x][y - 1][z] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y - 1][z]][a[2][y] - 'a']);
if (z && dp[x][y][z - 1] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y][z - 1]][a[3][z] - 'a']);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, q;
cin >> n >> q;
cin >> (s + 1);
memset(last, inf, sizeof(last));
for (int i = n; ~i; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = last[j];
if (i) last[s[i] - 'a'] = i;
}
while (q--) {
string opt;
cin >> opt;
if (opt == "+") {
int t;
cin >> t >> opt;
a[t][++len[t]] = opt[0];
if (t == 1)
for (int i = 0; i <= len[2]; ++i)
for (int j = 0; j <= len[3]; ++j) f(len[1], i, j);
if (t == 2)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[3]; ++j) f(i, len[2], j);
if (t == 3)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[2]; ++j) f(i, j, len[3]);
} else {
int t;
cin >> t;
--len[t];
}
cout << (dp[len[1]][len[2]][len[3]] <= n ? "YES" : "NO") << '\n';
}
return 0;
}
```
|
### Prompt
Please create a solution in cpp to the following problem:
E869120 is initially standing at the origin (0, 0) in a two-dimensional plane.
He has N engines, which can be used as follows:
* When E869120 uses the i-th engine, his X- and Y-coordinate change by x_i and y_i, respectively. In other words, if E869120 uses the i-th engine from coordinates (X, Y), he will move to the coordinates (X + x_i, Y + y_i).
* E869120 can use these engines in any order, but each engine can be used at most once. He may also choose not to use some of the engines.
He wants to go as far as possible from the origin. Let (X, Y) be his final coordinates. Find the maximum possible value of \sqrt{X^2 + Y^2}, the distance from the origin.
Constraints
* 1 \leq N \leq 100
* -1 \ 000 \ 000 \leq x_i \leq 1 \ 000 \ 000
* -1 \ 000 \ 000 \leq y_i \leq 1 \ 000 \ 000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
: :
x_N y_N
Output
Print the maximum possible final distance from the origin, as a real value. Your output is considered correct when the relative or absolute error from the true answer is at most 10^{-10}.
Examples
Input
3
0 10
5 -5
-5 -5
Output
10.000000000000000000000000000000000000000000000000
Input
5
1 1
1 0
0 1
-1 0
0 -1
Output
2.828427124746190097603377448419396157139343750753
Input
5
1 1
2 2
3 3
4 4
5 5
Output
21.213203435596425732025330863145471178545078130654
Input
3
0 0
0 1
1 0
Output
1.414213562373095048801688724209698078569671875376
Input
1
90447 91000
Output
128303.000000000000000000000000000000000000000000000000
Input
2
96000 -72000
-72000 54000
Output
120000.000000000000000000000000000000000000000000000000
Input
10
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
17 18
19 20
Output
148.660687473185055226120082139313966514489855137208
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
typedef long double ld;
ld x[110],y[110],ans = 0;
vector<pair<ld,pair<ld,ld>>> p;
ld pi = 3.1415926535;
int main(){
cout.precision(30);
int i,j,k,n;
cin >> n;
for(i=0;i<n;i++){
cin >> x[i] >> y[i];
p.push_back({atan2(x[i],y[i]),{x[i],y[i]}});
}
sort(p.begin(),p.end());
for(i=0;i<n;i++){
for(j=i;j<i + n;j++){
ld xx = 0,yy = 0;
for(k=i;k<=j;k++){
xx += p[k%n].second.first;
yy += p[k%n].second.second;
}
ans = max(ans,xx*xx + yy*yy);
}
}
cout << sqrt(ans) << endl;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
Fox Ciel is playing a card game with her friend Jiro.
Jiro has n cards, each one has two attributes: position (Attack or Defense) and strength. Fox Ciel has m cards, each one has these two attributes too. It's known that position of all Ciel's cards is Attack.
Now is Ciel's battle phase, Ciel can do the following operation many times:
1. Choose one of her cards X. This card mustn't be chosen before.
2. If Jiro has no alive cards at that moment, he gets the damage equal to (X's strength). Otherwise, Ciel needs to choose one Jiro's alive card Y, then:
* If Y's position is Attack, then (X's strength) ≥ (Y's strength) must hold. After this attack, card Y dies, and Jiro gets the damage equal to (X's strength) - (Y's strength).
* If Y's position is Defense, then (X's strength) > (Y's strength) must hold. After this attack, card Y dies, but Jiro gets no damage.
Ciel can end her battle phase at any moment (so, she can use not all her cards). Help the Fox to calculate the maximal sum of damage Jiro can get.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100) — the number of cards Jiro and Ciel have.
Each of the next n lines contains a string position and an integer strength (0 ≤ strength ≤ 8000) — the position and strength of Jiro's current card. Position is the string "ATK" for attack, and the string "DEF" for defense.
Each of the next m lines contains an integer strength (0 ≤ strength ≤ 8000) — the strength of Ciel's current card.
Output
Output an integer: the maximal damage Jiro can get.
Examples
Input
2 3
ATK 2000
DEF 1700
2500
2500
2500
Output
3000
Input
3 4
ATK 10
ATK 100
ATK 1000
1
11
101
1001
Output
992
Input
2 4
DEF 0
ATK 0
0
0
1
1
Output
1
Note
In the first test case, Ciel has 3 cards with same strength. The best strategy is as follows. First she uses one of these 3 cards to attack "ATK 2000" card first, this attack destroys that card and Jiro gets 2500 - 2000 = 500 damage. Then she uses the second card to destroy the "DEF 1700" card. Jiro doesn't get damage that time. Now Jiro has no cards so she can use the third card to attack and Jiro gets 2500 damage. So the answer is 500 + 2500 = 3000.
In the second test case, she should use the "1001" card to attack the "ATK 100" card, then use the "101" card to attack the "ATK 10" card. Now Ciel still has cards but she can choose to end her battle phase. The total damage equals (1001 - 100) + (101 - 10) = 992.
In the third test case note that she can destroy the "ATK 0" card by a card with strength equal to 0, but she can't destroy a "DEF 0" card with that card.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int best_attack(vector<int> attacker, vector<int> attacked) {
int ans = 0;
int attacker_n = attacker.size();
int card_n = attacked.size();
sort(attacker.begin(), attacker.end());
sort(attacked.begin(), attacked.end());
for (int n = 1; n <= card_n; ++n) {
int lost = 0;
for (int i = 1; i <= n; ++i) {
if (attacker_n - i >= 0 && attacker[attacker_n - i] >= attacked[n - i]) {
lost += attacker[attacker_n - i] - attacked[n - i];
}
}
if (lost > ans) {
ans = lost;
}
}
return ans;
}
int best_over_attack(vector<int> attacker, vector<int> attacked) {
int ans = 0;
int attacker_n = attacker.size();
int card_n = attacked.size();
sort(attacker.begin(), attacker.end());
sort(attacked.begin(), attacked.end());
for (int i = 1; i <= card_n; ++i) {
if (attacker[attacker_n - i] >= attacked[card_n - i]) {
ans += attacker[attacker_n - i] - attacked[card_n - i];
} else {
return -1;
}
}
for (int i = 0; i < attacker_n - card_n; ++i) {
ans += attacker[i];
}
return ans;
}
int main() {
int an, bn;
scanf("%d%d", &an, &bn);
vector<int> attacked_atk;
vector<int> attacked_def;
vector<int> attacker(bn);
for (int i = 0; i < an; ++i) {
char type[4];
int str;
scanf("%s%d", type, &str);
if (type[0] == 'A') {
attacked_atk.push_back(str);
} else {
attacked_def.push_back(str);
}
}
for (int i = 0; i < bn; ++i) {
scanf("%d", &attacker[i]);
}
int ans = best_attack(attacker, attacked_atk);
if (bn > an) {
sort(attacker.begin(), attacker.end());
bool destroyable = true;
for (auto def : attacked_def) {
auto finded = lower_bound(attacker.begin(), attacker.end(), def + 1);
if (finded != attacker.end()) {
attacker.erase(finded);
} else {
destroyable = false;
break;
}
}
if (destroyable) {
int ans2 = best_over_attack(attacker, attacked_atk);
if (ans2 >= 0 && ans2 > ans) {
ans = ans2;
}
}
}
printf("%d\n", ans);
return 0;
}
```
|
### Prompt
Develop a solution in CPP to the problem described below:
Another dull quarantine day was going by when BThero decided to start researching matrices of size n × m. The rows are numerated 1 through n from top to bottom, and the columns are numerated 1 through m from left to right. The cell in the i-th row and j-th column is denoted as (i, j).
For each cell (i, j) BThero had two values:
1. The cost of the cell, which is a single positive integer.
2. The direction of the cell, which is one of characters L, R, D, U. Those characters correspond to transitions to adjacent cells (i, j - 1), (i, j + 1), (i + 1, j) or (i - 1, j), respectively. No transition pointed outside of the matrix.
Let us call a cell (i_2, j_2) reachable from (i_1, j_1), if, starting from (i_1, j_1) and repeatedly moving to the adjacent cell according to our current direction, we will, sooner or later, visit (i_2, j_2).
BThero decided to create another matrix from the existing two. For a cell (i, j), let us denote S_{i, j} as a set of all reachable cells from it (including (i, j) itself). Then, the value at the cell (i, j) in the new matrix will be equal to the sum of costs of all cells in S_{i, j}.
After quickly computing the new matrix, BThero immediately sent it to his friends. However, he did not save any of the initial matrices! Help him to restore any two valid matrices, which produce the current one.
Input
The first line of input file contains a single integer T (1 ≤ T ≤ 100) denoting the number of test cases. The description of T test cases follows.
First line of a test case contains two integers n and m (1 ≤ n ⋅ m ≤ 10^5).
Each of the following n lines contain exactly m integers — the elements of the produced matrix. Each element belongs to the segment [2, 10^9].
It is guaranteed that ∑{(n ⋅ m)} over all test cases does not exceed 10^5.
Output
For each test case, if an answer does not exist, print a single word NO. Otherwise, print YES and both matrices in the same format as in the input.
* The first matrix should be the cost matrix and the second matrix should be the direction matrix.
* All integers in the cost matrix should be positive.
* All characters in the direction matrix should be valid. No direction should point outside of the matrix.
Example
Input
2
3 4
7 6 7 8
5 5 4 4
5 7 4 4
1 1
5
Output
YES
1 1 1 1
2 1 1 1
3 2 1 1
R D L L
D R D L
U L R U
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int maxn = 1e5 + 10;
char dir[4] = {'R', 'L', 'D', 'U'};
vector<vector<int> > a, ind, nxt;
pair<int, int> rh[maxn];
vector<int> vect[maxn], pos_undo;
int nxt2[maxn], pos[maxn], n, m, mt[maxn], cnt, r;
bool outside(int x, int y) {
if (x > n || x < 1 || y > m || y < 1) return true;
return false;
}
void add_edge(int x, int y) {
vect[x].push_back(y);
vect[y].push_back(x);
}
bool srt(int x, int y) { return nxt2[x] < nxt2[y]; }
int kuhn(int x, int tip) {
if (pos[x]) return 0;
pos[x] = 1;
pos_undo.push_back(x);
for (int i = 0; i < vect[x].size(); i++) {
int id = vect[x][i];
if (tip == 1 && nxt2[id] == 1) break;
if (mt[id] == -1 || kuhn(mt[id], tip)) {
mt[id] = x;
mt[x] = id;
return 1;
}
}
return 0;
}
void random_matching() {
for (int i = 1; i <= cnt; i++) {
if (mt[i] != -1) continue;
if (nxt2[i] != 0) continue;
for (int j = 0; j < vect[i].size(); j++) {
int id = vect[i][j];
if (mt[id] != -1) continue;
if (nxt2[id] != 0) continue;
mt[i] = id;
mt[id] = i;
r -= 2;
break;
}
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &m);
a.clear();
nxt.clear();
ind.clear();
a.resize(n + 2, vector<int>(m + 2));
nxt.resize(n + 2, vector<int>(m + 2));
ind.resize(n + 2, vector<int>(m + 2));
cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
nxt[i][j] = -1;
nxt2[cnt] = 0;
ind[i][j] = ++cnt;
rh[cnt] = {i, j};
mt[cnt] = -1;
vect[cnt].clear();
}
int fucked = 0;
r = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int e = 0;
for (int k = 0; k < 4; k++) {
int idx = i + dx[k];
int idy = j + dy[k];
if (outside(idx, idy)) continue;
if (a[idx][idy] < a[i][j]) {
nxt[i][j] = k;
nxt2[ind[i][j]] = 1;
} else if (a[idx][idy] == a[i][j]) {
e = 1;
if ((i + j) % 2) add_edge(ind[i][j], ind[idx][idy]);
}
}
if (e == 0 && nxt[i][j] == -1) fucked = 1;
if (nxt[i][j] == -1) r++;
}
if (fucked) {
printf("NO\n");
continue;
}
for (int i = 1; i <= cnt; i++) sort(vect[i].begin(), vect[i].end(), srt);
random_matching();
for (int i = 1; i <= cnt; i++) {
if (nxt[rh[i].first][rh[i].second] != -1 || mt[i] != -1) continue;
if (kuhn(i, 1)) r -= 2;
for (int j = 0; j < pos_undo.size(); j++) pos[pos_undo[j]] = 0;
pos_undo.clear();
}
for (int i = 1; i <= cnt; i++) {
if (nxt[rh[i].first][rh[i].second] != -1 || mt[i] != -1) continue;
if (kuhn(i, 0)) r -= 1;
for (int j = 0; j < pos_undo.size(); j++) pos[pos_undo[j]] = 0;
pos_undo.clear();
}
if (r > 0) {
printf("NO\n");
continue;
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mt[ind[i][j]] != -1) {
if ((i + j) % 2)
printf("%d ", a[i][j] / 2 + (a[i][j] % 2));
else
printf("%d ", a[i][j] / 2);
} else {
printf("%d ", a[i][j] - a[i + dx[nxt[i][j]]][j + dy[nxt[i][j]]]);
}
}
printf("\n");
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mt[ind[i][j]] != -1) {
for (int k = 0; k < 4; k++) {
int idx = i + dx[k];
int idy = j + dy[k];
if (ind[idx][idy] == mt[ind[i][j]]) {
printf("%c ", dir[k]);
break;
}
}
} else {
printf("%c ", dir[nxt[i][j]]);
}
}
printf("\n");
}
}
return 0;
}
```
|
### Prompt
Your task is to create a CPP solution to the following problem:
The Resistance is trying to take control over as many planets of a particular solar system as possible. Princess Heidi is in charge of the fleet, and she must send ships to some planets in order to maximize the number of controlled planets.
The Galaxy contains N planets, connected by bidirectional hyperspace tunnels in such a way that there is a unique path between every pair of the planets.
A planet is controlled by the Resistance if there is a Resistance ship in its orbit, or if the planet lies on the shortest path between some two planets that have Resistance ships in their orbits.
Heidi has not yet made up her mind as to how many ships to use. Therefore, she is asking you to compute, for every K = 1, 2, 3, ..., N, the maximum number of planets that can be controlled with a fleet consisting of K ships.
Input
The first line of the input contains an integer N (1 ≤ N ≤ 105) – the number of planets in the galaxy.
The next N - 1 lines describe the hyperspace tunnels between the planets. Each of the N - 1 lines contains two space-separated integers u and v (1 ≤ u, v ≤ N) indicating that there is a bidirectional hyperspace tunnel between the planets u and v. It is guaranteed that every two planets are connected by a path of tunnels, and that each tunnel connects a different pair of planets.
Output
On a single line, print N space-separated integers. The K-th number should correspond to the maximum number of planets that can be controlled by the Resistance using a fleet of K ships.
Examples
Input
3
1 2
2 3
Output
1 3 3
Input
4
1 2
3 2
4 2
Output
1 3 4 4
Note
Consider the first example. If K = 1, then Heidi can only send one ship to some planet and control it. However, for K ≥ 2, sending ships to planets 1 and 3 will allow the Resistance to control all planets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char ch = getchar();
bool f = false;
while (!isdigit(ch)) {
if (ch == '-') {
f = true;
}
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x = f ? -x : x;
return;
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
return;
}
const int N = 1e5 + 5;
int n, ans;
int head[N], nex[N << 1], to[N << 1], idx;
int root, dep[N], len[N], son[N];
int edge[N], cnt;
void add(int u, int v) {
nex[++idx] = head[u];
to[idx] = v;
head[u] = idx;
return;
}
void dfs1(int x, int fa) {
dep[x] = dep[fa] + 1;
if (dep[x] > dep[root]) root = x;
for (int i = head[x]; i; i = nex[i]) {
int y = to[i];
if (y == fa) continue;
dfs1(y, x);
}
return;
}
void dfs2(int x, int fa) {
for (int i = head[x]; i; i = nex[i]) {
int y = to[i];
if (y == fa) continue;
dfs2(y, x);
if (len[y] > len[son[x]]) son[x] = y;
}
len[x] = len[son[x]] + 1;
for (int i = head[x]; i; i = nex[i]) {
int y = to[i];
if (y == fa || y == son[x]) continue;
edge[++cnt] = len[y];
}
return;
}
int main() {
read(n);
for (int i = 1; i < n; i++) {
int u, v;
read(u), read(v);
add(u, v);
add(v, u);
}
dfs1(1, 0);
dfs2(root, 0);
sort(edge + 1, edge + cnt + 1);
write(1), putchar(' ');
ans = len[root];
for (int i = cnt; i >= 1; i--) {
write(ans), putchar(' ');
ans += edge[i];
}
for (int i = 1; i <= n - cnt - 1; i++) write(ans), putchar(' ');
return 0;
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
string cur;
string go;
void solve() {
getline(cin, s);
s = s.substr(4, 123123);
cur = "1988";
for (int i = 1; i <= (int)s.size(); i++) {
go = cur;
for (int j = 0; j < i; j++) {
if ((int)go.size() - 1 - j < 0) {
go = s[(int)s.size() - 1 - j] + go;
} else {
go[(int)go.size() - 1 - j] = s[(int)s.size() - 1 - j];
}
}
if (go[0] == '0') {
go = "1" + go;
}
if ((int)go.size() > (int)cur.size()) {
cur = go;
continue;
}
bool bigger = false;
for (int j = 0; j < (int)go.size(); j++) {
if (go[j] > cur[j]) {
bigger = true;
break;
}
if (go[j] < cur[j]) {
break;
}
}
if (bigger) {
cur = go;
continue;
}
int f = (int)go.size() - i;
int can = -1;
for (int j = f - 1; j >= 0; j--) {
if (cur[j] < '9') {
can = j;
break;
}
}
if (can == -1) {
for (int j = 0; j < f; j++) {
go[j] = '0';
}
go = "1" + go;
} else {
go[can] = cur[can] + 1;
for (int j = can + 1; j < f; j++) {
go[j] = '0';
}
}
cur = go;
}
cout << cur << endl;
}
int main() {
int tn;
scanf("%d\n", &tn);
while (tn--) {
solve();
}
return 0;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int base = 1000000007;
int n, k, res = 0;
pair<int, int> a[103];
map<int, int> b, c;
map<int, int>::iterator it;
int main() {
int i, j;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i].first;
for (i = 1; i <= n; i++) {
cin >> a[i].second;
a[i].second = a[i].first - k * a[i].second;
}
b[0] = 0;
for (i = 1; i <= n; i++)
for (it = (c = b).begin(); it != c.end(); it++)
b[it->first + a[i].second] =
max(b[it->first + a[i].second], a[i].first + it->second);
if (b[0])
cout << b[0];
else
cout << -1;
return 0;
}
```
|
### Prompt
Please provide a CPP coded solution to the problem described below:
On the Literature lesson Sergei noticed an awful injustice, it seems that some students are asked more often than others.
Seating in the class looks like a rectangle, where n rows with m pupils in each.
The teacher asks pupils in the following order: at first, she asks all pupils from the first row in the order of their seating, then she continues to ask pupils from the next row. If the teacher asked the last row, then the direction of the poll changes, it means that she asks the previous row. The order of asking the rows looks as follows: the 1-st row, the 2-nd row, ..., the n - 1-st row, the n-th row, the n - 1-st row, ..., the 2-nd row, the 1-st row, the 2-nd row, ...
The order of asking of pupils on the same row is always the same: the 1-st pupil, the 2-nd pupil, ..., the m-th pupil.
During the lesson the teacher managed to ask exactly k questions from pupils in order described above. Sergei seats on the x-th row, on the y-th place in the row. Sergei decided to prove to the teacher that pupils are asked irregularly, help him count three values:
1. the maximum number of questions a particular pupil is asked,
2. the minimum number of questions a particular pupil is asked,
3. how many times the teacher asked Sergei.
If there is only one row in the class, then the teacher always asks children from this row.
Input
The first and the only line contains five integers n, m, k, x and y (1 ≤ n, m ≤ 100, 1 ≤ k ≤ 1018, 1 ≤ x ≤ n, 1 ≤ y ≤ m).
Output
Print three integers:
1. the maximum number of questions a particular pupil is asked,
2. the minimum number of questions a particular pupil is asked,
3. how many times the teacher asked Sergei.
Examples
Input
1 3 8 1 1
Output
3 2 3
Input
4 2 9 4 2
Output
2 1 1
Input
5 5 25 4 3
Output
1 1 1
Input
100 100 1000000000000000000 100 100
Output
101010101010101 50505050505051 50505050505051
Note
The order of asking pupils in the first test:
1. the pupil from the first row who seats at the first table, it means it is Sergei;
2. the pupil from the first row who seats at the second table;
3. the pupil from the first row who seats at the third table;
4. the pupil from the first row who seats at the first table, it means it is Sergei;
5. the pupil from the first row who seats at the second table;
6. the pupil from the first row who seats at the third table;
7. the pupil from the first row who seats at the first table, it means it is Sergei;
8. the pupil from the first row who seats at the second table;
The order of asking pupils in the second test:
1. the pupil from the first row who seats at the first table;
2. the pupil from the first row who seats at the second table;
3. the pupil from the second row who seats at the first table;
4. the pupil from the second row who seats at the second table;
5. the pupil from the third row who seats at the first table;
6. the pupil from the third row who seats at the second table;
7. the pupil from the fourth row who seats at the first table;
8. the pupil from the fourth row who seats at the second table, it means it is Sergei;
9. the pupil from the third row who seats at the first table;
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long vis[220][220], k;
const long long INF = 2e18;
int n, m, nn, mod, rest, x, y;
long long mx, mn, q;
int main() {
cin >> n >> m >> k >> x >> y;
if (n == 1) {
q = k / m;
rest = k % m;
for (int i = 1; i <= m; i++) vis[1][i] = q;
for (int i = 1; i <= rest; i++) vis[1][i]++;
mx = 0, mn = INF;
for (int i = 1; i <= m; i++) {
mx = max(vis[1][i], mx);
mn = min(vis[1][i], mn);
}
cout << mx << " " << mn << " " << vis[x][y] << endl;
} else {
nn = n * 2 - 2;
mod = nn * m;
q = k / (1ll * mod);
rest = k % mod;
for (int i = 1; i <= mod; i++) {
int jj = ((i - 1) % m) + 1;
int ii = (i - 1) / m + 1;
if (ii > n) ii = 2 * n - ii;
assert(ii <= n);
assert(jj <= m);
vis[ii][jj] += q;
}
for (int i = 1; i <= rest; i++) {
int jj = ((i - 1) % m) + 1;
int ii = (i - 1) / m + 1;
if (ii > n) ii = 2 * n - ii;
assert(ii <= n);
assert(jj <= m);
vis[ii][jj] += 1;
}
mx = 0, mn = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mx = max(vis[i][j], mx);
mn = min(vis[i][j], mn);
}
}
cout << mx << " " << mn << " " << vis[x][y] << endl;
}
}
```
|
### Prompt
Develop a solution in cpp to the problem described below:
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
int dp[maxn][maxn], a[maxn], ans;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
double fake;
cin >> a[i] >> fake;
}
for (int i = 1; i <= n; i++) {
for (int type = 1; type <= k; type++) dp[i][type] = dp[i - 1][type];
for (int type = 1; type <= a[i]; type++)
dp[i][a[i]] = max(dp[i][a[i]], dp[i - 1][type] + 1);
ans = max(ans, dp[i][a[i]]);
}
cout << n - ans << endl;
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
You have a description of a lever as string s. We'll represent the string length as record |s|, then the lever looks as a horizontal bar with weights of length |s| - 1 with exactly one pivot. We will assume that the bar is a segment on the Ox axis between points 0 and |s| - 1.
The decoding of the lever description is given below.
* If the i-th character of the string equals "^", that means that at coordinate i there is the pivot under the bar.
* If the i-th character of the string equals "=", that means that at coordinate i there is nothing lying on the bar.
* If the i-th character of the string equals digit c (1-9), that means that at coordinate i there is a weight of mass c on the bar.
Your task is, given the lever description, print if it will be in balance or not. Assume that the bar doesn't weight anything. Assume that the bar initially is in balance then all weights are simultaneously put on it. After that the bar either tilts to the left, or tilts to the right, or is in balance.
Input
The first line contains the lever description as a non-empty string s (3 ≤ |s| ≤ 106), consisting of digits (1-9) and characters "^" and "=". It is guaranteed that the line contains exactly one character "^". It is guaranteed that the pivot of the lever isn't located in any end of the lever bar.
To solve the problem you may need 64-bit integer numbers. Please, do not forget to use them in your programs.
Output
Print "left" if the given lever tilts to the left, "right" if it tilts to the right and "balance", if it is in balance.
Examples
Input
=^==
Output
balance
Input
9===^==1
Output
left
Input
2==^7==
Output
right
Input
41^52==
Output
balance
Note
As you solve the problem, you may find the following link useful to better understand how a lever functions: http://en.wikipedia.org/wiki/Lever.
The pictures to the examples:
<image> <image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int bas = 0;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '^') bas = i;
long long cnt1 = 0, cnt2 = 0;
for (int i = 0; i < bas; ++i)
if (s[i] != '=') cnt1 = cnt1 + (bas - i) * (s[i] - '0');
for (int i = bas; i < s.size(); ++i)
if (s[i] != '=' && s[i] != '^') cnt2 = cnt2 + (i - bas) * (s[i] - '0');
if (cnt1 > cnt2) {
cout << "left" << endl;
return 0;
}
if (cnt2 > cnt1) {
cout << "right" << endl;
return 0;
}
cout << "balance" << endl;
return 0;
}
```
|
### Prompt
Your task is to create a cpp solution to the following problem:
Tax Rate Changed
VAT (value-added tax) is a tax imposed at a certain rate proportional to the sale price.
Our store uses the following rules to calculate the after-tax prices.
* When the VAT rate is x%, for an item with the before-tax price of p yen, its after-tax price of the item is p (100+x) / 100 yen, fractions rounded off.
* The total after-tax price of multiple items paid at once is the sum of after-tax prices of the items.
The VAT rate is changed quite often. Our accountant has become aware that "different pairs of items that had the same total after-tax price may have different total after-tax prices after VAT rate changes." For example, when the VAT rate rises from 5% to 8%, a pair of items that had the total after-tax prices of 105 yen before can now have after-tax prices either of 107, 108, or 109 yen, as shown in the table below.
Before-tax prices of two items| After-tax price with 5% VAT| After-tax price with 8% VAT
---|---|---
20, 80| 21 + 84 = 105| 21 + 86 = 107
2, 99| 2 + 103 = 105| 2 + 106 = 108
13, 88| 13 + 92 = 105| 14 + 95 = 109
Our accountant is examining effects of VAT-rate changes on after-tax prices. You are asked to write a program that calculates the possible maximum total after-tax price of two items with the new VAT rate, knowing their total after-tax price before the VAT rate change.
Input
The input consists of multiple datasets. Each dataset is in one line, which consists of three integers x, y, and s separated by a space. x is the VAT rate in percent before the VAT-rate change, y is the VAT rate in percent after the VAT-rate change, and s is the sum of after-tax prices of two items before the VAT-rate change. For these integers, 0 < x < 100, 0 < y < 100, 10 < s < 1000, and x ≠ y hold. For before-tax prices of items, all possibilities of 1 yen through s-1 yen should be considered.
The end of the input is specified by three zeros separated by a space.
Output
For each dataset, output in a line the possible maximum total after-tax price when the VAT rate is changed to y%.
Sample Input
5 8 105
8 5 105
1 2 24
99 98 24
12 13 26
1 22 23
1 13 201
13 16 112
2 24 50
1 82 61
1 84 125
1 99 999
99 1 999
98 99 999
1 99 11
99 1 12
0 0 0
Output for the Sample Input
109
103
24
24
26
27
225
116
62
111
230
1972
508
1004
20
7
Hints
In the following table, an instance of a before-tax price pair that has the maximum after-tax price after the VAT-rate change is given for each dataset of the sample input.
Dataset| Before-tax prices| After-tax price with y% VAT
---|---|---
5 8 105 | 13, 88| 14 + 95 = 109
8 5 105 | 12, 87| 12 + 91 = 103
1 2 24 | 1, 23| 1 + 23 = 24
99 98 24 | 1, 12| 1 + 23 = 24
12 13 26 | 1, 23| 1 + 25 = 26
1 22 23 | 1, 22| 1 + 26 = 27
1 13 201 | 1,199| 1 +224 = 225
13 16 112| 25, 75| 29 + 87 = 116
2 24 50 | 25, 25| 31 + 31 = 62
1 82 61 | 11, 50| 20 + 91 = 111
1 84 125 | 50, 75| 92 +138 = 230
1 99 999 | 92,899| 183+1789 =1972
99 1 999 | 1,502| 1 +507 = 508
98 99 999| 5,500| 9 +995 =1004
1 99 11 | 1, 10| 1 + 19 = 20
99 1 12 | 1, 6| 1 + 6 = 7
Example
Input
5 8 105
8 5 105
1 2 24
99 98 24
12 13 26
1 22 23
1 13 201
13 16 112
2 24 50
1 82 61
1 84 125
1 99 999
99 1 999
98 99 999
1 99 11
99 1 12
0 0 0
Output
109
103
24
24
26
27
225
116
62
111
230
1972
508
1004
20
7
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
while(1){
int x,y,s,ans=0,a,b,m;
cin>>x>>y>>s;
if(x==0)break;
for(a=1;a<s;a++)
for(b=a;a+b<=s;b++){
m=a*(100+y)/100+b*(100+y)/100;
if(a*(100+x)/100+b*(100+x)/100==s&&ans<m)ans=m;
}
cout<<ans<<endl;
}
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
A tree is a connected graph that doesn't contain any cycles.
The distance between two vertices of a tree is the length (in edges) of the shortest path between these vertices.
You are given a tree with n vertices and a positive number k. Find the number of distinct pairs of the vertices which have a distance of exactly k between them. Note that pairs (v, u) and (u, v) are considered to be the same pair.
Input
The first line contains two integers n and k (1 ≤ n ≤ 50000, 1 ≤ k ≤ 500) — the number of vertices and the required distance between the vertices.
Next n - 1 lines describe the edges as "ai bi" (without the quotes) (1 ≤ ai, bi ≤ n, ai ≠ bi), where ai and bi are the vertices connected by the i-th edge. All given edges are different.
Output
Print a single integer — the number of distinct pairs of the tree's vertices which have a distance of exactly k between them.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5 2
1 2
2 3
3 4
2 5
Output
4
Input
5 3
1 2
2 3
3 4
4 5
Output
2
Note
In the first sample the pairs of vertexes at distance 2 from each other are (1, 3), (1, 5), (3, 5) and (2, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 500 * 100 + 10;
vector<int> adj[MAXN];
int p[MAXN], dp[MAXN][500 + 10], h[MAXN], n, k;
long long ans;
bool vis[MAXN];
void dfs(int i) {
dp[i][0] = 1;
vis[i] = true;
for (int j = 0; j < adj[i].size(); j++) {
if (!vis[adj[i][j]]) {
h[adj[i][j]] = h[i] + 1;
p[adj[i][j]] = i;
dfs(adj[i][j]);
for (int l = 1; l < k; l++) {
dp[i][l] += dp[adj[i][j]][l - 1];
}
}
}
return;
}
int main() {
cin >> n >> k;
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j < k; j++) {
for (int l = 0; l < adj[i].size(); l++) {
if (p[i] != adj[i][l]) {
ans += 1ll * dp[adj[i][l]][j - 1] *
(dp[i][k - j] - dp[adj[i][l]][k - j - 1]);
}
}
}
}
ans /= 2;
for (int i = 1; i <= n; i++) {
if (h[i] >= k) ans++;
}
cout << ans;
return 0;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
The goal of the 15 puzzle problem is to complete pieces on $4 \times 4$ cells where one of the cells is empty space.
In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 15 as shown below.
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.
Constraints
* The given puzzle is solvable in at most 45 steps.
Input
The $4 \times 4$ integers denoting the pieces or space are given.
Output
Print the fewest steps in a line.
Example
Input
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
Output
8
### Response
```cpp
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
#define N 4
int dy[4] = {1, 0, -1, 0};
int dx[4] = {0, 1, 0, -1};
int MDT[N*N][N*N];
struct Puzzle {
vector<int> f;
int space;
int cost;
int MD;
int estimated;
bool operator < (const Puzzle &s) const {
return estimated > s.estimated;
}
};
int getAllMD(Puzzle pz){
int sum = 0;
for(int i = 0; i < N * N; i++) {
if(pz.f[i]==0) continue;
sum += MDT[i][pz.f[i]-1];
}
return sum;
}
map<vector<int>, bool> checked;
priority_queue<Puzzle> que;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
// A* -> estimated = cost(これまでのコスト) + MD(今の状態と最終状態の差(ここではマンハッタン距離の総和))
// マンハッタン距離計算
for(int i = 0; i < N * N; i++) {
for(int j = 0; j < N * N; j++) {
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
Puzzle start;
start.f.resize(N*N);
FOR(i,0,N*N){
cin >> start.f[i];
if(start.f[i] == 0) {
start.space = i;
}
}
start.cost = 0;
start.MD = getAllMD(start);
start.estimated = start.cost + start.MD;
que.push(start);
checked[start.f] = true;
while(!que.empty()){
Puzzle now = que.top();
que.pop();
if(now.MD == 0) {
cout << now.cost << endl;
return 0;
}
checked[now.f] = true;
int x = now.space % N;
int y = now.space / N;
FOR(i,0,4){
int ny = y + dy[i];
int nx = x + dx[i];
if(ny < 0 || ny >= N || nx < 0 || nx >= N) continue;
Puzzle next = now;
next.space = ny * N + nx;
next.cost++;
next.MD -= MDT[ny * N + nx][next.f[ny * N + nx]-1]; // 空白になったので
next.MD += MDT[y * N + x][next.f[ny * N + nx]-1];
swap(next.f[ny * N + nx], next.f[y * N + x]);
next.estimated = next.cost + next.MD;
if(!checked[next.f] && next.estimated <= 45){
que.push(next);
}
}
}
return 0;
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
Om Nom really likes candies and doesn't like spiders as they frequently steal candies. One day Om Nom fancied a walk in a park. Unfortunately, the park has some spiders and Om Nom doesn't want to see them at all.
<image>
The park can be represented as a rectangular n × m field. The park has k spiders, each spider at time 0 is at some cell of the field. The spiders move all the time, and each spider always moves in one of the four directions (left, right, down, up). In a unit of time, a spider crawls from his cell to the side-adjacent cell in the corresponding direction. If there is no cell in the given direction, then the spider leaves the park. The spiders do not interfere with each other as they move. Specifically, one cell can have multiple spiders at the same time.
Om Nom isn't yet sure where to start his walk from but he definitely wants:
* to start walking at time 0 at an upper row cell of the field (it is guaranteed that the cells in this row do not contain any spiders);
* to walk by moving down the field towards the lowest row (the walk ends when Om Nom leaves the boundaries of the park).
We know that Om Nom moves by jumping. One jump takes one time unit and transports the little monster from his cell to either a side-adjacent cell on the lower row or outside the park boundaries.
Each time Om Nom lands in a cell he sees all the spiders that have come to that cell at this moment of time. Om Nom wants to choose the optimal cell to start the walk from. That's why he wonders: for each possible starting cell, how many spiders will he see during the walk if he starts from this cell? Help him and calculate the required value for each possible starting cell.
Input
The first line contains three integers n, m, k (2 ≤ n, m ≤ 2000; 0 ≤ k ≤ m(n - 1)).
Each of the next n lines contains m characters — the description of the park. The characters in the i-th line describe the i-th row of the park field. If the character in the line equals ".", that means that the corresponding cell of the field is empty; otherwise, the character in the line will equal one of the four characters: "L" (meaning that this cell has a spider at time 0, moving left), "R" (a spider moving right), "U" (a spider moving up), "D" (a spider moving down).
It is guaranteed that the first row doesn't contain any spiders. It is guaranteed that the description of the field contains no extra characters. It is guaranteed that at time 0 the field contains exactly k spiders.
Output
Print m integers: the j-th integer must show the number of spiders Om Nom will see if he starts his walk from the j-th cell of the first row. The cells in any row of the field are numbered from left to right.
Examples
Input
3 3 4
...
R.L
R.U
Output
0 2 2
Input
2 2 2
..
RL
Output
1 1
Input
2 2 2
..
LR
Output
0 0
Input
3 4 8
....
RRLL
UUUU
Output
1 3 3 1
Input
2 2 2
..
UU
Output
0 0
Note
Consider the first sample. The notes below show how the spider arrangement changes on the field over time:
... ... ..U ...
R.L -> .*U -> L.R -> ...
R.U .R. ..R ...
Character "*" represents a cell that contains two spiders at the same time.
* If Om Nom starts from the first cell of the first row, he won't see any spiders.
* If he starts from the second cell, he will see two spiders at time 1.
* If he starts from the third cell, he will see two spiders: one at time 1, the other one at time 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long n, m, k;
string s[2222];
long long a[2222];
int main(void) {
cin >> n >> m >> k;
for (long long i = 0; i < (long long)(n); i++) {
cin >> s[i];
}
for (long long i = 0; i < (long long)(n); i++) {
for (long long j = 0; j < (long long)(m); j++) {
if (s[i][j] == 'L') {
if (j >= i) a[j - i]++;
} else if (s[i][j] == 'R') {
if (j + i < m) a[j + i]++;
} else if (s[i][j] == 'U') {
if (i % 2 == 0) a[j]++;
}
}
}
for (long long i = 0; i < (long long)(m); i++) {
cout << a[i] << " ";
}
cout << '\n';
return 0;
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Arya has n opponents in the school. Each day he will fight with all opponents who are present this day. His opponents have some fighting plan that guarantees they will win, but implementing this plan requires presence of them all. That means if one day at least one of Arya's opponents is absent at the school, then Arya will beat all present opponents. Otherwise, if all opponents are present, then they will beat Arya.
For each opponent Arya knows his schedule — whether or not he is going to present on each particular day. Tell him the maximum number of consecutive days that he will beat all present opponents.
Note, that if some day there are no opponents present, Arya still considers he beats all the present opponents.
Input
The first line of the input contains two integers n and d (1 ≤ n, d ≤ 100) — the number of opponents and the number of days, respectively.
The i-th of the following d lines contains a string of length n consisting of characters '0' and '1'. The j-th character of this string is '0' if the j-th opponent is going to be absent on the i-th day.
Output
Print the only integer — the maximum number of consecutive days that Arya will beat all present opponents.
Examples
Input
2 2
10
00
Output
2
Input
4 1
0100
Output
1
Input
4 5
1101
1111
0110
1011
1111
Output
2
Note
In the first and the second samples, Arya will beat all present opponents each of the d days.
In the third sample, Arya will beat his opponents on days 1, 3 and 4 and his opponents will beat him on days 2 and 5. Thus, the maximum number of consecutive winning days is 2, which happens on days 3 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, k = 0, x = 0, sum = 0;
string s;
while ((scanf("%d%d", &n, &d)) != EOF) {
k = 0;
x = 0;
sum = 0;
while (d--) {
cin >> s;
sum = 0;
int l = s.size();
for (int j = 0; j < l; j++) {
sum += (s[j] - '0');
}
if (sum == n) {
x = max(x, k);
k = 0;
} else
k++;
}
x = max(x, k);
printf("%d\n", x);
}
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Print all subsets of a set $S$, which contains $0, 1, ... n-1$ as elements. Note that we represent $0, 1, ... n-1$ as 00...0001, 00...0010, 00...0100, ..., 10...0000 in binary respectively and the integer representation of a subset is calculated by bitwise OR of existing elements.
Constraints
* $1 \leq n \leq 18$
Input
The input is given in the following format.
$n$
Output
Print subsets ordered by their decimal integers. Print a subset in a line in the following format.
$d$: $e_0$ $e_1$ ...
Print ':' after the integer value $d$, then print elements $e_i$ in the subset in ascending order. Seprate two adjacency elements by a space character.
Example
Input
4
Output
0:
1: 0
2: 1
3: 0 1
4: 2
5: 0 2
6: 1 2
7: 0 1 2
8: 3
9: 0 3
10: 1 3
11: 0 1 3
12: 2 3
13: 0 2 3
14: 1 2 3
15: 0 1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll) 1e15;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
REP(i, pow(2LL, N)) {
cout << i << ":";
REP(j, N) {
if ((i >> j) & 1)
cout << " " << j;
}
cout << endl;
}
return 0;
}
```
|
### Prompt
Construct a cpp code solution to the problem outlined:
One day student Vasya was sitting on a lecture and mentioned a string s1s2... sn, consisting of letters "a", "b" and "c" that was written on his desk. As the lecture was boring, Vasya decided to complete the picture by composing a graph G with the following properties:
* G has exactly n vertices, numbered from 1 to n.
* For all pairs of vertices i and j, where i ≠ j, there is an edge connecting them if and only if characters si and sj are either equal or neighbouring in the alphabet. That is, letters in pairs "a"-"b" and "b"-"c" are neighbouring, while letters "a"-"c" are not.
Vasya painted the resulting graph near the string and then erased the string. Next day Vasya's friend Petya came to a lecture and found some graph at his desk. He had heard of Vasya's adventure and now he wants to find out whether it could be the original graph G, painted by Vasya. In order to verify this, Petya needs to know whether there exists a string s, such that if Vasya used this s he would produce the given graph G.
Input
The first line of the input contains two integers n and m <image> — the number of vertices and edges in the graph found by Petya, respectively.
Each of the next m lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the edges of the graph G. It is guaranteed, that there are no multiple edges, that is any pair of vertexes appear in this list no more than once.
Output
In the first line print "Yes" (without the quotes), if the string s Petya is interested in really exists and "No" (without the quotes) otherwise.
If the string s exists, then print it on the second line of the output. The length of s must be exactly n, it must consist of only letters "a", "b" and "c" only, and the graph built using this string must coincide with G. If there are multiple possible answers, you may print any of them.
Examples
Input
2 1
1 2
Output
Yes
aa
Input
4 3
1 2
1 3
1 4
Output
No
Note
In the first sample you are given a graph made of two vertices with an edge between them. So, these vertices can correspond to both the same and adjacent letters. Any of the following strings "aa", "ab", "ba", "bb", "bc", "cb", "cc" meets the graph's conditions.
In the second sample the first vertex is connected to all three other vertices, but these three vertices are not connected with each other. That means that they must correspond to distinct letters that are not adjacent, but that is impossible as there are only two such letters: a and c.
### Response
```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 505;
int n, m;
int vis[maxn], flag;
int con[maxn][maxn];
vector<int> edge[maxn];
void input() {
memset(con, 0, sizeof(con));
memset(vis, -1, sizeof(vis));
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &j, &k);
con[k][j] = con[j][k] = 1;
}
}
void dfs(int x, int f) {
if (flag == 0) return;
int i, sz = edge[x].size();
if (sz == 0) return;
if (f != -1) {
if (vis[x] == -1)
vis[x] = f;
else if (vis[x] != f) {
flag = 0;
return;
} else {
return;
}
} else {
if (vis[x] == -1) vis[x] = 1;
}
for (i = 0; i < sz; i++) {
dfs(edge[x][i], 1 - vis[x]);
}
}
void solve() {
int i, j, k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
if (con[i][j] == 0) {
edge[i].push_back(j);
}
}
}
flag = 1;
for (i = 1; i <= n; i++) {
if (vis[i] != -1) continue;
dfs(i, -1);
if (flag == 0) {
puts("No");
return;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
if (con[i][j] == 1) {
if (vis[i] == -1 || vis[j] == -1) continue;
if (abs(vis[i] - vis[j]) == 1) {
puts("No");
return;
}
}
}
}
puts("Yes");
for (i = 1; i <= n; i++) {
if (vis[i] == -1) {
cout << "b";
} else if (vis[i] == 0) {
cout << "a";
} else {
cout << "c";
}
}
return;
}
int main() {
input();
solve();
return 0;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
You are given a string s consisting of n lowercase Latin letters. Polycarp wants to remove exactly k characters (k ≤ n) from the string s. Polycarp uses the following algorithm k times:
* if there is at least one letter 'a', remove the leftmost occurrence and stop the algorithm, otherwise go to next item;
* if there is at least one letter 'b', remove the leftmost occurrence and stop the algorithm, otherwise go to next item;
* ...
* remove the leftmost occurrence of the letter 'z' and stop the algorithm.
This algorithm removes a single letter from the string. Polycarp performs this algorithm exactly k times, thus removing exactly k characters.
Help Polycarp find the resulting string.
Input
The first line of input contains two integers n and k (1 ≤ k ≤ n ≤ 4 ⋅ 10^5) — the length of the string and the number of letters Polycarp will remove.
The second line contains the string s consisting of n lowercase Latin letters.
Output
Print the string that will be obtained from s after Polycarp removes exactly k letters using the above algorithm k times.
If the resulting string is empty, print nothing. It is allowed to print nothing or an empty line (line break).
Examples
Input
15 3
cccaabababaccbc
Output
cccbbabaccbc
Input
15 9
cccaabababaccbc
Output
cccccc
Input
1 1
u
Output
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int len, k;
void sw(string &str, int k) {
string ss = str.substr(0, k + 1);
reverse(ss.begin(), ss.end());
for (int i = 0; i <= k; i++) str[i] = ss[i];
}
int main() {
string str;
scanf("%d", &len);
scanf("%d", &k);
cin >> str;
map<char, int> make_pair;
for (int i = 0; i < len; ++i) {
make_pair[str[i]] += 1;
}
char lim;
bool flag = true;
int del = 0;
long long int sum = 0;
char i;
for (i = 'a'; i <= 'z'; ++i) {
sum += make_pair[i];
if (sum == k) {
lim = i;
del = 0;
break;
}
if (sum > k) {
lim = i - 1;
sum -= make_pair[i];
del = k - sum;
break;
}
}
if (i > 'z' && sum <= k) {
cout << "\n";
return 0;
}
for (int i = 0; i < len; ++i) {
if (str[i] >= 'a' && str[i] <= lim) str[i] = '?';
}
int p = 0;
for (int i = 0; p < del && i < len; ++i) {
if (str[i] == lim + 1) {
str[i] = '?';
++p;
}
}
for (int i = 0; i < len; ++i) {
if (str[i] != '?') cout << str[i];
}
cout << "\n";
return 0;
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
There are n distinct points on a coordinate line, the coordinate of i-th point equals to x_i. Choose a subset of the given set of points such that the distance between each pair of points in a subset is an integral power of two. It is necessary to consider each pair of points, not only adjacent. Note that any subset containing one element satisfies the condition above. Among all these subsets, choose a subset with maximum possible size.
In other words, you have to choose the maximum possible number of points x_{i_1}, x_{i_2}, ..., x_{i_m} such that for each pair x_{i_j}, x_{i_k} it is true that |x_{i_j} - x_{i_k}| = 2^d where d is some non-negative integer number (not necessarily the same for each pair of points).
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line contains n pairwise distinct integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9) — the coordinates of points.
Output
In the first line print m — the maximum possible number of points in a subset that satisfies the conditions described above.
In the second line print m integers — the coordinates of points in the subset you have chosen.
If there are multiple answers, print any of them.
Examples
Input
6
3 5 4 7 10 12
Output
3
7 3 5
Input
5
-1 2 5 8 11
Output
1
8
Note
In the first example the answer is [7, 3, 5]. Note, that |7-3|=4=2^2, |7-5|=2=2^1 and |3-5|=2=2^1. You can't find a subset having more points satisfying the required property.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 34;
const int N = (int)1e6 + 34;
struct K {
int sum, ni, nx;
K(int s, int i, int x) {
sum = s;
ni = i;
nx = x;
}
bool operator<(const K &a) const {
return (sum == a.sum ? ni < a.ni : sum < a.sum);
}
};
void solve() {
set<long long> s;
int n;
cin >> n;
vector<long long> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
s.insert(x);
}
vector<long long> ans = {a[0]};
for (int deg = 0; deg < 31; deg++) {
long long len = (1 << deg);
for (int i = 0; i < n; i++) {
if (s.find(a[i] + len) != s.end() && (int)ans.size() < 2) {
ans = {a[i], a[i] + len};
}
if (s.find(a[i] + len) != s.end() && s.find(a[i] + len * 2) != s.end() &&
(int)ans.size() < 3) {
ans = {a[i], a[i] + len, a[i] + len * 2};
}
}
}
cout << ans.size() << "\n";
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
solve();
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Mr. A is planning to travel alone on a highway bus (hereinafter referred to as "bus") during his high school holidays. First, Mr. A chose the town he wanted to visit the most and made it his destination. Next, you have to decide the route to transfer the bus from the departure point to the destination. When connecting, you will need a ticket for each bus as you will need to get off the bus and then transfer to another bus.
Mr. A got some discount tickets for the bus from his relatives' uncle. If you use one ticket, you can buy one ticket at half price. For example, when going from the departure point 5 in Fig. 1 to the destination 1, there are two possible routes: 5 → 4 → 6 → 2 → 1 and 5 → 3 → 1. Assuming that there are two discount tickets, the cheapest way to travel is to follow the route 5 → 4 → 6 → 2 → 1, and use the discount on the routes 4 → 6 and 6 → 2 for the total price. Will be 4600 yen. On the other hand, if you follow the route 5 → 3 → 1, you will get a discount on the routes 5 → 3 and 3 → 1, and the total charge will be 3750 yen.
Mr. A wants to spend money on sightseeing, so he wants to keep transportation costs as low as possible. Therefore, Mr. A decided to create a program to find the cheapest transportation cost from the starting point to the destination.
<image>
Figure 1
Enter the number of discount tickets, the number of towns connected by buses, the number of bus routes, and the route information of each bus, and create a program that outputs the cheapest transportation cost from the departure point to the destination. Each bus runs in both directions at the same rate. Also, assuming that the number of towns is n, each town is numbered differently from 1 to n. There must always be a route from the origin to the destination.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by five lines of zeros. Each dataset is given in the following format:
c n m s d
a1 b1 f1
a2 b2 f2
::
am bm fm
Number of discount tickets on the first line c (1 ≤ c ≤ 10), number of towns connected by buses n (2 ≤ n ≤ 100), number of bus routes m (1 ≤ m ≤ 500), town number of departure Given s and the destination town number d (s ≠ d).
The following m lines are given the route information ai, bi, fi (1 ≤ ai, bi ≤ n, 1000 ≤ fi ≤ 10000) for the i-th bus. ai and bi are the town numbers of the start and end points of the bus route, and fi is an integer in increments of 100 that represents the fare for this route.
The number of datasets does not exceed 100.
Output
Outputs the cheapest transportation cost on one line for each input dataset.
Example
Input
1 3 3 1 3
1 3 2000
1 2 1000
2 3 1000
2 3 3 1 3
1 3 2300
1 2 1000
2 3 1200
2 6 6 5 1
1 2 1500
1 3 4500
2 6 2000
5 4 1000
6 4 2200
3 5 3000
0 0 0 0 0
Output
1000
1100
3750
### Response
```cpp
#include<bits/stdc++.h>
#define P pair<int,int>
using namespace std;
struct K {
int basho, nokori, mincost;
};
bool operator<(K a, K b) {
return a.mincost > b.mincost;
}
int main() {
int cost[100][11];//n???????????°????????§m????????????????°????
int B, c, d, e, f;
while (scanf("%d%d%d%d%d", &B, &c, &d, &e, &f), B || c || d || e || f) {
vector<P>a[100]{};
memset(cost, 0x3f, sizeof(cost));
e--; f--; cost[e][B] = 0;
priority_queue<K>Q;
K g;
g.basho = e; g.nokori = B; g.mincost = 0;
Q.push(g);
for (int h = 0; h < d; h++) {
int i, j, k;
scanf("%d%d%d", &i, &j, &k);
i--; j--;
a[i].push_back(P(k, j));
a[j].push_back(P(k, i));
}
while (Q.size()) {
K l = Q.top(); Q.pop();
int m = l.mincost, n = l.nokori, b = l.basho;
if (cost[b][n] < m)continue;
for (P o : a[b]) {
if (cost[o.second][n] > cost[b][n] + o.first) {
cost[o.second][n] = cost[b][n] + o.first;
K xx;
xx.basho = o.second;
xx.mincost = cost[o.second][n];
xx.nokori = n;
Q.push(xx);
}
if (n&&cost[o.second][n-1] > cost[b][n] + o.first / 2) {
cost[o.second][n - 1] = cost[b][n] + o.first / 2;
K yy;
yy.basho = o.second;
yy.nokori = n - 1;
yy.mincost = cost[o.second][n - 1];
Q.push(yy);
}
}
}
int MINCOST = 1 << 29;
for (int sss = 0; sss < 11; sss++) {
MINCOST = min(MINCOST, cost[f][sss]);
}
cout << MINCOST << endl;
}
}
```
|
### Prompt
Create a solution in CPP for the following problem:
In Berland it is the holiday of equality. In honor of the holiday the king decided to equalize the welfare of all citizens in Berland by the expense of the state treasury.
Totally in Berland there are n citizens, the welfare of each of them is estimated as the integer in ai burles (burle is the currency in Berland).
You are the royal treasurer, which needs to count the minimum charges of the kingdom on the king's present. The king can only give money, he hasn't a power to take away them.
Input
The first line contains the integer n (1 ≤ n ≤ 100) — the number of citizens in the kingdom.
The second line contains n integers a1, a2, ..., an, where ai (0 ≤ ai ≤ 106) — the welfare of the i-th citizen.
Output
In the only line print the integer S — the minimum number of burles which are had to spend.
Examples
Input
5
0 1 2 3 4
Output
10
Input
5
1 1 0 1 1
Output
1
Input
3
1 3 1
Output
4
Input
1
12
Output
0
Note
In the first example if we add to the first citizen 4 burles, to the second 3, to the third 2 and to the fourth 1, then the welfare of all citizens will equal 4.
In the second example it is enough to give one burle to the third citizen.
In the third example it is necessary to give two burles to the first and the third citizens to make the welfare of citizens equal 3.
In the fourth example it is possible to give nothing to everyone because all citizens have 12 burles.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
short n;
long long suma = 0;
int maksimum = 0;
int a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
maksimum = max(maksimum, a);
suma += a;
}
cout << maksimum * n - suma;
return 0;
}
```
|
### Prompt
Construct a Cpp code solution to the problem outlined:
A football league has recently begun in Beautiful land. There are n teams participating in the league. Let's enumerate them with integers from 1 to n.
There will be played exactly (n(n-1))/(2) matches: each team will play against all other teams exactly once. In each match, there is always a winner and loser and there is no draw.
After all matches are played, the organizers will count the number of beautiful triples. Let's call a triple of three teams (A, B, C) beautiful if a team A win against a team B, a team B win against a team C and a team C win against a team A. We look only to a triples of different teams and the order of teams in the triple is important.
The beauty of the league is the number of beautiful triples.
At the moment, m matches were played and their results are known.
What is the maximum beauty of the league that can be, after playing all remaining matches? Also find a possible results for all remaining (n(n-1))/(2) - m matches, so that the league has this maximum beauty.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 0 ≤ m ≤ (n(n-1))/(2)) — the number of teams in the football league and the number of matches that were played.
Each of m following lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting that the u-th team won against the v-th team. It is guaranteed that each unordered pair of teams appears at most once.
Output
Print n lines, each line having a string of exactly n characters. Each character must be either 0 or 1.
Let a_{ij} be the j-th number in the i-th line. For all 1 ≤ i ≤ n it should be true, that a_{ii} = 0. For all pairs of teams i ≠ j the number a_{ij} indicates the result of the match between the i-th team and the j-th team:
* If a_{ij} is 1, the i-th team wins against the j-th team;
* Otherwise the j-th team wins against the i-th team;
* Also, it should be true, that a_{ij} + a_{ji} = 1.
Also note that the results of the m matches that were already played cannot be changed in your league.
The beauty of the league in the output should be maximum possible. If there are multiple possible answers with maximum beauty, you can print any of them.
Examples
Input
3 1
1 2
Output
010
001
100
Input
4 2
1 2
1 3
Output
0110
0001
0100
1010
Note
The beauty of league in the first test case is equal to 3 because there exists three beautiful triples: (1, 2, 3), (2, 3, 1), (3, 1, 2).
The beauty of league in the second test is equal to 6 because there exists six beautiful triples: (1, 2, 4), (2, 4, 1), (4, 1, 2), (2, 4, 3), (4, 3, 2), (3, 2, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct MinCostMaxFlow {
struct Edge {
int to, cap;
int flow;
int cost;
};
static const int MAX_V = 3003;
static const int MAX_E = 2 * 333 * 333;
static const int INF = 1e9 + 7;
static const int MAX_COST = 1e9 + 7;
int sz = 0;
Edge e[MAX_E];
vector<int> g[MAX_V];
int dp[MAX_V];
pair<int, int> prev[MAX_V];
int phi[MAX_V];
void addEdge(int v, int to, int cap, int cost) {
g[v].push_back(sz);
e[sz++] = {to, cap, 0, cost};
g[to].push_back(sz);
e[sz++] = {v, 0, 0, -cost};
}
void calcPhi(int start) {
for (int i = 0; i < MAX_V; ++i) phi[i] = MAX_COST;
phi[start] = 0;
for (int k = 0; k < MAX_V; k++) {
for (int v = 0; v < MAX_V; v++) {
for (int to : g[v]) {
Edge &ed = e[to];
if (ed.cap == ed.flow) continue;
phi[ed.to] = min(phi[ed.to], phi[v] + ed.cost);
}
}
}
}
long long find(int start, int finish, int required_flow) {
calcPhi(start);
long long ans = 0;
while (required_flow) {
for (int i = 0; i < MAX_V; i++) dp[i] = INF, prev[i] = {-1, -1};
dp[start] = 0;
set<pair<int, int> > se;
se.insert({0, start});
while (!se.empty()) {
auto aux = *se.begin();
int dist = aux.first, v = aux.second;
se.erase(se.begin());
for (int to : g[v]) {
auto ed = e[to];
if (ed.flow < ed.cap &&
dp[ed.to] > dp[v] + ed.cost - phi[ed.to] + phi[v]) {
prev[ed.to] = {v, to};
se.erase({dp[ed.to], ed.to});
dp[ed.to] = dp[v] + ed.cost - phi[ed.to] + phi[v];
se.insert({dp[ed.to], ed.to});
}
}
}
if (dp[finish] == INF) {
return -1;
}
int max_flow = required_flow;
int v = finish;
while (1) {
auto now = prev[v];
if (now.first == -1) break;
max_flow = min(max_flow, e[now.second].cap - e[now.second].flow);
v = now.first;
}
ans += (dp[finish] + phi[finish]) * (long long)max_flow;
v = finish;
while (1) {
auto now = prev[v];
if (now.first == -1) break;
e[now.second].flow += max_flow;
e[now.second ^ 1].flow -= max_flow;
v = now.first;
}
required_flow -= max_flow;
int min_phi = 0;
for (int i = 0; i < MAX_V; ++i) {
if (dp[i] == INF) {
min_phi = min(min_phi, phi[i]);
} else {
phi[i] += dp[i];
}
}
for (int i = 0; i < MAX_V; ++i) {
if (dp[i] == INF) {
phi[i] -= min_phi;
}
}
}
return ans;
}
} mcmf;
int sursa, dest, ans[55][55], grad[55];
pair<int, int> what[1255];
int main() {
int n, m, x, y, nodes = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
ans[x][y] = 1;
grad[x]++;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (ans[i][j] + ans[j][i] == 0) {
nodes++;
mcmf.addEdge(sursa, nodes, 1, 0);
what[nodes] = {i, j};
}
for (int i = 1; i <= nodes; i++) {
mcmf.addEdge(i, nodes + what[i].first, 1, 0);
mcmf.addEdge(i, nodes + what[i].second, 1, 0);
}
dest = nodes + n + 1;
int nr = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - 1 - grad[i]; j++)
mcmf.addEdge(i + nodes, dest, 1, 2 * grad[i] + 2 * j - 1);
int flow = mcmf.find(0, nodes + n + 1, nodes);
for (int i = 1; i <= nodes; i++) {
x = what[i].first;
y = what[i].second;
if (mcmf.e[2 * nodes + (i - 1) * 4].flow == 1)
ans[x][y] = 1;
else
ans[y][x] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d", ans[i][j]);
printf("\n");
}
return 0;
}
```
|
### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string s consisting of exactly n characters, and each character is either '0', '1' or '2'. Such strings are called ternary strings.
Your task is to replace minimum number of characters in this string with other characters to obtain a balanced ternary string (balanced ternary string is a ternary string such that the number of characters '0' in this string is equal to the number of characters '1', and the number of characters '1' (and '0' obviously) is equal to the number of characters '2').
Among all possible balanced ternary strings you have to obtain the lexicographically (alphabetically) smallest.
Note that you can neither remove characters from the string nor add characters to the string. Also note that you can replace the given characters only with characters '0', '1' and '2'.
It is guaranteed that the answer exists.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 3 ⋅ 10^5, n is divisible by 3) — the number of characters in s.
The second line contains the string s consisting of exactly n characters '0', '1' and '2'.
Output
Print one string — the lexicographically (alphabetically) smallest balanced ternary string which can be obtained from the given one with minimum number of replacements.
Because n is divisible by 3 it is obvious that the answer exists. And it is obvious that there is only one possible answer.
Examples
Input
3
121
Output
021
Input
6
000000
Output
001122
Input
6
211200
Output
211200
Input
6
120110
Output
120120
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
inline void smax(int &x, int y) { x = max(x, y); }
inline void smin(int &x, int y) { x = min(x, y); }
ll gcd(ll a, ll b) { return ((b == 0) ? a : gcd(b, a % b)); }
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int ca = 0, cb = 0, cc = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (s[i] == '0')
ca++;
else if (s[i] == '1')
cb++;
else
cc++;
}
if (ca < n / 3) {
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (s[i] == '1' && cb > n / 3) {
cb--;
ca++;
s[i] = '0';
} else if (s[i] == '2' && cc > n / 3) {
cc--;
ca++;
s[i] = '0';
}
if (ca == n / 3) break;
}
}
if (cc < n / 3) {
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '0' && ca > n / 3) {
ca--;
cc++;
s[i] = '2';
} else if (s[i] == '1' && cb > n / 3) {
cb--;
cc++;
s[i] = '2';
}
if (cc == n / 3) break;
}
}
if (cb < n / 3) {
int cnt = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (s[i] == '2' && cc > n / 3) {
s[i] = '1';
cb++;
cc--;
} else if (s[i] == '0' && cnt == n / 3) {
s[i] = '1';
cb++;
ca--;
}
if (s[i] == '0') cnt++;
if (cb == n / 3) break;
}
}
cout << s;
}
```
|
### Prompt
Please formulate a Cpp solution to the following problem:
There's a famous museum in the city where Kleofáš lives. In the museum, n exhibits (numbered 1 through n) had been displayed for a long time; the i-th of those exhibits has value vi and mass wi.
Then, the museum was bought by a large financial group and started to vary the exhibits. At about the same time, Kleofáš... gained interest in the museum, so to say.
You should process q events of three types:
* type 1 — the museum displays an exhibit with value v and mass w; the exhibit displayed in the i-th event of this type is numbered n + i (see sample explanation for more details)
* type 2 — the museum removes the exhibit with number x and stores it safely in its vault
* type 3 — Kleofáš visits the museum and wonders (for no important reason at all, of course): if there was a robbery and exhibits with total mass at most m were stolen, what would their maximum possible total value be?
For each event of type 3, let s(m) be the maximum possible total value of stolen exhibits with total mass ≤ m.
Formally, let D be the set of numbers of all exhibits that are currently displayed (so initially D = {1, ..., n}). Let P(D) be the set of all subsets of D and let
<image>
Then, s(m) is defined as
<image>
Compute s(m) for each <image>. Note that the output follows a special format.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 5000, 1 ≤ k ≤ 1000) — the initial number of exhibits in the museum and the maximum interesting mass of stolen exhibits.
Then, n lines follow. The i-th of them contains two space-separated positive integers vi and wi (1 ≤ vi ≤ 1 000 000, 1 ≤ wi ≤ 1000) — the value and mass of the i-th exhibit.
The next line contains a single integer q (1 ≤ q ≤ 30 000) — the number of events.
Each of the next q lines contains the description of one event in the following format:
* 1 v w — an event of type 1, a new exhibit with value v and mass w has been added (1 ≤ v ≤ 1 000 000, 1 ≤ w ≤ 1000)
* 2 x — an event of type 2, the exhibit with number x has been removed; it's guaranteed that the removed exhibit had been displayed at that time
* 3 — an event of type 3, Kleofáš visits the museum and asks his question
There will be at most 10 000 events of type 1 and at least one event of type 3.
Output
As the number of values s(m) can get large, output the answers to events of type 3 in a special format.
For each event of type 3, consider the values s(m) computed for the question that Kleofáš asked in this event; print one line containing a single number
<image>
where p = 107 + 19 and q = 109 + 7.
Print the answers to events of type 3 in the order in which they appear in the input.
Examples
Input
3 10
30 4
60 6
5 1
9
3
1 42 5
1 20 3
3
2 2
2 4
3
1 40 6
3
Output
556674384
168191145
947033915
181541912
Input
3 1000
100 42
100 47
400 15
4
2 2
2 1
2 3
3
Output
0
Note
In the first sample, the numbers of displayed exhibits and values s(1), ..., s(10) for individual events of type 3 are, in order:
<image> <image> <image> <image>
The values of individual exhibits are v1 = 30, v2 = 60, v3 = 5, v4 = 42, v5 = 20, v6 = 40 and their masses are w1 = 4, w2 = 6, w3 = 1, w4 = 5, w5 = 3, w6 = 6.
In the second sample, the only question is asked after removing all exhibits, so s(m) = 0 for any m.
### Response
```cpp
#include <bits/stdc++.h>
template <typename T>
inline T abs(T a) {
return a < 0 ? -a : a;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline void swap(T &a, T &b) {
T t = a;
a = b, b = t;
}
template <typename T>
inline bool umin(T &mn, T u) {
return u < mn ? mn = u, true : false;
}
template <typename T>
inline bool umax(T &mx, T u) {
return u > mx ? mx = u, true : false;
}
template <typename T>
inline void read(T &r) {
char c;
r = 0;
bool flag = false;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') flag = true, c = getchar();
do r = r * 10 + c - '0', c = getchar();
while (c >= '0' && c <= '9');
if (flag) r *= -1;
}
template <typename T1, typename T2>
inline void read(T1 &r, T2 &s) {
read(r), read(s);
}
template <typename T1, typename T2, typename T3>
inline void read(T1 &r, T2 &s, T3 &t) {
read(r), read(s), read(t);
}
template <typename T1, typename T2, typename T3, typename T4>
inline void read(T1 &r, T2 &s, T3 &t, T4 &u) {
read(r), read(s), read(t), read(u);
}
template <typename T>
inline void write(T w, const char *c = "") {
if (w == 0)
putchar('0');
else {
if (w < 0) putchar('-'), w *= -1;
static int s[21], top;
top = 0;
while (w) s[top++] = w % 10, w /= 10;
while (top--) putchar(s[top] + '0');
}
for (int i = 0; c[i]; i++) putchar(c[i]);
}
int n, k, qn, en;
long long p[1000];
const long long P = 1e7 + 19, mod = 1e9 + 7;
void init() {
for (int i = p[0] = 1; i < k; i++) p[i] = p[i - 1] * P % mod;
}
struct knapsack {
int dp[1001];
void add(std::pair<int, int> o) {
int v = o.first, w = o.second;
for (int i = k - w; i >= 0; i--) umax(dp[i + w], dp[i] + v);
}
int getans() {
long long ans = 0;
for (int i = 1; i <= k; i++) (ans += dp[i] * p[i - 1]) %= mod;
return (int)ans;
}
} st[20];
struct perfect_binary_tree {
struct ac {
std::pair<int, int> to;
int nx;
} e[450000];
int L, first[65536];
perfect_binary_tree() : L(1) {}
inline void addedge(int u, std::pair<int, int> v) {
e[L].to = v, e[L].nx = first[u], first[u] = L++;
}
void add(int L, int R, std::pair<int, int> c, int now = 1, int l = 1,
int r = qn) {
if (L <= l && r <= R) {
addedge(now, c);
return;
}
int m = (l + r) >> 1;
if (L <= m) add(L, R, c, now << 1, l, m);
if (m < R) add(L, R, c, now << 1 | 1, m + 1, r);
}
void getans(int depth = 1, int now = 1, int l = 1, int r = qn) {
knapsack &xs = st[depth] = st[depth - 1];
for (int j = first[now]; j; j = e[j].nx) xs.add(e[j].to);
if (l == r) {
write(xs.getans(), "\n");
return;
}
int m = (l + r) >> 1;
getans(depth + 1, now << 1, l, m);
getans(depth + 1, now << 1 | 1, m + 1, r);
}
} T;
std::pair<int, int> exhibit[15000], show[15000];
void solve() {
init();
for (int i = 0; i < n; i++)
if (show[i].first <= qn && show[i].second >= 1)
T.add(show[i].first, show[i].second, exhibit[i]);
T.getans();
}
void input() {
qn = 0, n = 0;
int m, o;
read(m, k);
while (m--)
read(exhibit[n].first, exhibit[n].second),
show[n++] = std::pair<int, int>(0, -1);
read(m);
while (m--) {
read(o);
switch (o) {
case 1:
read(exhibit[n].first, exhibit[n].second),
show[n++] = std::pair<int, int>(qn + 1, -1);
break;
case 2:
read(o), show[--o].second = qn;
break;
case 3:
++qn;
break;
}
}
for (int i = 0; i < n; i++)
if (show[i].second == -1) show[i].second = qn;
}
int main() {
input();
solve();
return 0;
}
```
|
### Prompt
Create a solution in CPP for the following problem:
According to the regulations of Berland's army, a reconnaissance unit should consist of exactly two soldiers. Since these two soldiers shouldn't differ much, their heights can differ by at most d centimeters. Captain Bob has n soldiers in his detachment. Their heights are a1, a2, ..., an centimeters. Some soldiers are of the same height. Bob wants to know, how many ways exist to form a reconnaissance unit of two soldiers from his detachment.
Ways (1, 2) and (2, 1) should be regarded as different.
Input
The first line contains two integers n and d (1 ≤ n ≤ 1000, 1 ≤ d ≤ 109) — amount of soldiers in Bob's detachment and the maximum allowed height difference respectively. The second line contains n space-separated integers — heights of all the soldiers in Bob's detachment. These numbers don't exceed 109.
Output
Output one number — amount of ways to form a reconnaissance unit of two soldiers, whose height difference doesn't exceed d.
Examples
Input
5 10
10 20 50 60 65
Output
6
Input
5 1
55 30 29 31 55
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool myfunction(int i, int j) { return (i > j); }
int main() {
int n, i = 0, j = 0;
long int d, count = 0;
cin >> n;
cin >> d;
vector<long int> numbers(n);
for (i = 0; i < n; i++) {
cin >> numbers.at(i);
}
sort(numbers.begin(), numbers.end(), myfunction);
for (i = 0; i < (n - 1); i++) {
for (j = i + 1; j < n; j++) {
if (numbers.at(i) - numbers.at(j) <= d) {
count++;
} else {
break;
}
}
}
cout << count * 2 << endl;
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
There are two main kinds of events in the life of top-model: fashion shows and photo shoots. Participating in any of these events affects the rating of appropriate top-model. After each photo shoot model's rating increases by a and after each fashion show decreases by b (designers do too many experiments nowadays). Moreover, sometimes top-models participates in talk shows. After participating in talk show model becomes more popular and increasing of her rating after photo shoots become c and decreasing of her rating after fashion show becomes d.
Izabella wants to participate in a talk show, but she wants to do it in such a way that her rating will never become negative. Help her to find a suitable moment for participating in the talk show.
Let's assume that model's career begins in moment 0. At that moment Izabella's rating was equal to start. If talk show happens in moment t if will affect all events in model's life in interval of time [t..t + len) (including t and not including t + len), where len is duration of influence.
Izabella wants to participate in a talk show, but she wants to do it in such a way that her rating will not become become negative before talk show or during period of influence of talk show. Help her to find a suitable moment for participating in the talk show.
Input
In first line there are 7 positive integers n, a, b, c, d, start, len (1 ≤ n ≤ 3·105, 0 ≤ start ≤ 109, 1 ≤ a, b, c, d, len ≤ 109), where n is a number of fashion shows and photo shoots, a, b, c and d are rating changes described above, start is an initial rating of model and len is a duration of influence of talk show.
In next n lines descriptions of events are given. Each of those lines contains two integers ti and qi (1 ≤ ti ≤ 109, 0 ≤ q ≤ 1) — moment, in which event happens and type of this event. Type 0 corresponds to the fashion show and type 1 — to photo shoot.
Events are given in order of increasing ti, all ti are different.
Output
Print one non-negative integer t — the moment of time in which talk show should happen to make Izabella's rating non-negative before talk show and during period of influence of talk show. If there are multiple answers print smallest of them. If there are no such moments, print - 1.
Examples
Input
5 1 1 1 4 0 5
1 1
2 1
3 1
4 0
5 0
Output
6
Input
1 1 2 1 2 1 2
1 0
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, pair<long long, long long> > > vt;
vector<pair<int, int> > v;
int main() {
int n, a, b, c, d, start, len;
scanf("%d%d%d%d%d%d%d", &n, &a, &b, &c, &d, &start, &len);
int i, t, q;
v.push_back({-1, -1});
for (i = 0; i < n; i++) {
scanf("%d%d", &t, &q);
v.push_back({t, q});
}
vector<long long> sum, ats;
sum.push_back(start);
ats.push_back(start);
for (i = 1; i <= n; i++) {
if (v[i].second == 0) {
sum.push_back(sum[i - 1] - b);
ats.push_back(ats[i - 1] - d);
} else {
sum.push_back(sum[i - 1] + a);
ats.push_back(ats[i - 1] + c);
}
}
multiset<long long> ms;
int j = 1;
for (i = 0; i < sum.size(); i++) {
if (sum[i] < 0) {
printf("-1");
return 0;
}
if (i != 0) {
ms.erase(ms.find(ats[i]));
}
while (j < sum.size() && v[j].first - v[i].first - 1 < len) {
ms.insert(ats[j++]);
}
if (ms.size() == 0 || (*ms.begin() + sum[i] - ats[i] >= 0)) {
printf("%d", v[i].first + 1);
return 0;
}
}
return 0;
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
You are given three integers k, pa and pb.
You will construct a sequence with the following algorithm: Initially, start with the empty sequence. Each second, you do the following. With probability pa / (pa + pb), add 'a' to the end of the sequence. Otherwise (with probability pb / (pa + pb)), add 'b' to the end of the sequence.
You stop once there are at least k subsequences that form 'ab'. Determine the expected number of times 'ab' is a subsequence in the resulting sequence. It can be shown that this can be represented by P / Q, where P and Q are coprime integers, and <image>. Print the value of <image>.
Input
The first line will contain three integers integer k, pa, pb (1 ≤ k ≤ 1 000, 1 ≤ pa, pb ≤ 1 000 000).
Output
Print a single integer, the answer to the problem.
Examples
Input
1 1 1
Output
2
Input
3 1 4
Output
370000006
Note
The first sample, we will keep appending to our sequence until we get the subsequence 'ab' at least once. For instance, we get the sequence 'ab' with probability 1/4, 'bbab' with probability 1/16, and 'aab' with probability 1/8. Note, it's impossible for us to end with a sequence like 'aabab', since we would have stopped our algorithm once we had the prefix 'aab'.
The expected amount of times that 'ab' will occur across all valid sequences is 2.
For the second sample, the answer is equal to <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7ll;
const long long int INF = 3e18;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
long long int bitc(long long int n, long long int x) { return ((n >> x) & 1); }
long long int __gcd(long long int a, long long int b) {
return b == 0 ? a : __gcd(b, a % b);
}
long long int fsub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int fmult(long long int a, long long int b, long long int p = MOD) {
return ((((a % p) * (b % p)) % p) + p) % p;
}
long long int fadd(long long int a, long long int b, long long int p = MOD) {
return ((a % p + b % p) % p + p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ((ans) % p + p) % p;
}
long long int ceil(long long int a, long long int b) {
return ceil((long double)a / b);
}
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
template <typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, T val = T()) : vector<T>(n, val) {}
};
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
std::vector<long long int> p2;
void power_2(long long int n, long long int m = MOD) {
long long int i;
p2.emplace_back(1);
for (i = 0; i < n; i++) {
p2.emplace_back(fmult(p2.back(), 2));
}
}
long long int ncr(long long int n, long long int r) {
if (r > n) return 0;
return fdiv(fact_vec[n], fmult(fact_vec[r], fact_vec[n - r]));
}
std::vector<long long int> spf;
void sieve2(long long int MAXN) {
MAXN += 10;
spf.resize(MAXN, 0);
spf[1] = 1;
for (long long int i = 2; i < MAXN; i++) spf[i] = i;
for (long long int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (long long int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (long long int j = i * i; j < MAXN; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
const int mi[4] = {-1, 0, 1, 0}, mj[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};
map<long long int, long long int> getFactorization(long long int x) {
map<long long int, long long int> ret;
while (x != 1) {
ret[spf[x]]++;
x = x / spf[x];
}
return ret;
}
class Sol {
public:
Sol() { long long int i, j; }
};
long long int k, a, b;
Vec<2, long long int> dp(2e3, 2e3, -1);
long long int solve(long long int i, long long int j) {
auto &res = dp[i][j];
if (res != -1) {
return res;
}
if (i + j >= k) {
return res = fadd(i + j, fdiv(a, b));
}
return res = fdiv(fadd(fmult(a, solve(i + 1, j)), fmult(b, solve(i, j + i))),
a + b);
}
int main() {
long long int i, j;
cout << fixed;
ios::sync_with_stdio(false);
cin.tie(0);
long long int ti;
ti = 1;
while (ti--) {
cin >> k >> a >> b;
cout << solve(1, 0) << "\n";
}
return 0;
}
```
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n seats in the train's car and there is exactly one passenger occupying every seat. The seats are numbered from 1 to n from left to right. The trip is long, so each passenger will become hungry at some moment of time and will go to take boiled water for his noodles. The person at seat i (1 ≤ i ≤ n) will decide to go for boiled water at minute t_i.
Tank with a boiled water is located to the left of the 1-st seat. In case too many passengers will go for boiled water simultaneously, they will form a queue, since there can be only one passenger using the tank at each particular moment of time. Each passenger uses the tank for exactly p minutes. We assume that the time it takes passengers to go from their seat to the tank is negligibly small.
Nobody likes to stand in a queue. So when the passenger occupying the i-th seat wants to go for a boiled water, he will first take a look on all seats from 1 to i - 1. In case at least one of those seats is empty, he assumes that those people are standing in a queue right now, so he would be better seating for the time being. However, at the very first moment he observes that all seats with numbers smaller than i are busy, he will go to the tank.
There is an unspoken rule, that in case at some moment several people can go to the tank, than only the leftmost of them (that is, seating on the seat with smallest number) will go to the tank, while all others will wait for the next moment.
Your goal is to find for each passenger, when he will receive the boiled water for his noodles.
Input
The first line contains integers n and p (1 ≤ n ≤ 100 000, 1 ≤ p ≤ 10^9) — the number of people and the amount of time one person uses the tank.
The second line contains n integers t_1, t_2, ..., t_n (0 ≤ t_i ≤ 10^9) — the moments when the corresponding passenger will go for the boiled water.
Output
Print n integers, where i-th of them is the time moment the passenger on i-th seat will receive his boiled water.
Example
Input
5 314
0 310 942 628 0
Output
314 628 1256 942 1570
Note
Consider the example.
At the 0-th minute there were two passengers willing to go for a water, passenger 1 and 5, so the first passenger has gone first, and returned at the 314-th minute. At this moment the passenger 2 was already willing to go for the water, so the passenger 2 has gone next, and so on. In the end, 5-th passenger was last to receive the boiled water.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 100005;
int n, p, tmr[N], seq[N], que[N], fr = 1, tl = 0, T[N];
long long ans[N];
using namespace std;
priority_queue<int> Q;
int cmp(int a, int b) {
if (tmr[a] == tmr[b]) return a < b;
return tmr[a] < tmr[b];
}
int qry(int x) {
int res = 0;
while (x) res += T[x], x -= x & (-x);
return res;
}
void ins(int x, int v) {
while (x <= n) T[x] += v, x += x & (-x);
}
int main() {
scanf("%d %d", &n, &p);
for (int i = 1; i <= n; i++) scanf("%d", &tmr[i]), seq[i] = i;
sort(seq + 1, seq + 1 + n, cmp);
long long ntmr = 0;
int pos = 1;
while (pos <= n || !Q.empty() || fr <= tl) {
if (fr <= tl) {
while (pos <= n && ntmr + p > tmr[seq[pos]]) {
if (!qry(seq[pos]))
que[++tl] = seq[pos], ins(seq[pos], 1);
else
Q.push(-seq[pos]);
pos++;
}
ntmr += p, ans[que[fr]] = ntmr, ins(que[fr], -1), fr++;
while (pos <= n && ntmr == tmr[seq[pos]]) Q.push(-seq[pos]), pos++;
if (!Q.empty()) {
int now = -Q.top();
if (!qry(now)) Q.pop(), que[++tl] = now, ins(now, 1);
}
} else {
if (Q.empty() && ntmr < tmr[seq[pos]]) ntmr = tmr[seq[pos]];
while (pos <= n && ntmr >= tmr[seq[pos]]) Q.push(-seq[pos]), pos++;
int now = -Q.top();
Q.pop(), que[++tl] = now, ins(now, 1);
}
}
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
You are given an undirected graph consisting of N vertices and M edges. The vertices are numbered 1 to N, and the edges are numbered 1 to M. In addition, each vertex has a label, `A` or `B`. The label of Vertex i is s_i. Edge i bidirectionally connects vertex a_i and b_i.
The phantom thief Nusook likes to choose some vertex as the startpoint and traverse an edge zero or more times. Today, he will make a string after traveling as above, by placing the labels of the visited vertices in the order visited, beginning from the startpoint.
For example, in a graph where Vertex 1 has the label `A` and Vertex 2 has the label `B`, if Nusook travels along the path 1 \rightarrow 2 \rightarrow 1 \rightarrow 2 \rightarrow 2, the resulting string is `ABABB`.
Determine if Nusook can make all strings consisting of `A` and `B`.
Constraints
* 2 \leq N \leq 2 \times 10^{5}
* 1 \leq M \leq 2 \times 10^{5}
* |s| = N
* s_i is `A` or `B`.
* 1 \leq a_i, b_i \leq N
* The given graph may NOT be simple or connected.
Input
Input is given from Standard Input in the following format:
N M
s
a_1 b_1
:
a_{M} b_{M}
Output
If Nusook can make all strings consisting of `A` and `B`, print `Yes`; otherwise, print `No`.
Examples
Input
2 3
AB
1 1
1 2
2 2
Output
Yes
Input
4 3
ABAB
1 2
2 3
3 1
Output
No
Input
13 23
ABAAAABBBBAAB
7 1
10 6
1 11
2 10
2 8
2 11
11 12
8 3
7 12
11 2
13 13
11 9
4 1
9 7
9 6
8 13
8 6
4 10
8 7
4 3
2 1
8 12
6 9
Output
Yes
Input
13 17
BBABBBAABABBA
7 1
7 9
11 12
3 9
11 9
2 1
11 5
12 11
10 8
1 11
1 8
7 7
9 10
8 8
8 12
6 2
13 11
Output
No
### Response
```cpp
#include<bits/stdc++.h>
#define reg register
typedef long long ll;
using namespace std;
const int MN=2e5+5;
int deg[MN][2];
int n,m;
char ch[MN];
int to[MN<<1],nxt[MN<<1],h[MN],cnt;
inline void ins(int s,int t){
to[++cnt]=t;nxt[cnt]=h[s];h[s]=cnt;
to[++cnt]=s;nxt[cnt]=h[t];h[t]=cnt;
}
int que[MN],ta;
int main(){
scanf("%d%d",&n,&m);scanf("%s",ch+1);
for(reg int i=1,s,t;i<=m;i++){
scanf("%d%d",&s,&t);ins(s,t);
deg[s][ch[t]-'A']++;deg[t][ch[s]-'A']++;
}
for(reg int i=1;i<=n;i++)
if(!deg[i][0]||!deg[i][1])que[++ta]=i;
for(reg int i=1;i<=ta;i++)
for(reg int j=h[que[i]];j;j=nxt[j])
if(deg[to[j]][0]&°[to[j]][1]&&!(--deg[to[j]][ch[que[i]]-'A']))
que[++ta]=to[j];
puts(ta<n?"Yes":"No");
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Given are integers A, B, and N.
Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non-negative integer x not greater than N.
Here floor(t) denotes the greatest integer not greater than the real number t.
Constraints
* 1 ≤ A ≤ 10^{6}
* 1 ≤ B ≤ 10^{12}
* 1 ≤ N ≤ 10^{12}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B N
Output
Print the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non-negative integer x not greater than N, as an integer.
Examples
Input
5 7 4
Output
2
Input
11 10 9
Output
9
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll a,b,n;
int main()
{
cin>>a>>b>>n;
cout<<a*min(n,b-1)/b;
return 0;
}
```
|
### Prompt
Create a solution in cpp for the following problem:
Petya and Vasya decided to play a game. They have n cards (n is an even number). A single integer is written on each card.
Before the game Petya will choose an integer and after that Vasya will choose another integer (different from the number that Petya chose). During the game each player takes all the cards with number he chose. For example, if Petya chose number 5 before the game he will take all cards on which 5 is written and if Vasya chose number 10 before the game he will take all cards on which 10 is written.
The game is considered fair if Petya and Vasya can take all n cards, and the number of cards each player gets is the same.
Determine whether Petya and Vasya can choose integer numbers before the game so that the game is fair.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — number of cards. It is guaranteed that n is an even number.
The following n lines contain a sequence of integers a1, a2, ..., an (one integer per line, 1 ≤ ai ≤ 100) — numbers written on the n cards.
Output
If it is impossible for Petya and Vasya to choose numbers in such a way that the game will be fair, print "NO" (without quotes) in the first line. In this case you should not print anything more.
In the other case print "YES" (without quotes) in the first line. In the second line print two distinct integers — number that Petya should choose and the number that Vasya should choose to make the game fair. If there are several solutions, print any of them.
Examples
Input
4
11
27
27
11
Output
YES
11 27
Input
2
6
6
Output
NO
Input
6
10
20
30
20
10
20
Output
NO
Input
6
1
1
2
2
3
3
Output
NO
Note
In the first example the game will be fair if, for example, Petya chooses number 11, and Vasya chooses number 27. Then the will take all cards — Petya will take cards 1 and 4, and Vasya will take cards 2 and 3. Thus, each of them will take exactly two cards.
In the second example fair game is impossible because the numbers written on the cards are equal, but the numbers that Petya and Vasya should choose should be distinct.
In the third example it is impossible to take all cards. Petya and Vasya can take at most five cards — for example, Petya can choose number 10 and Vasya can choose number 20. But for the game to be fair it is necessary to take 6 cards.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int num[105];
int main() {
int n;
cin >> n;
set<int> s;
while (n--) {
int a;
cin >> a;
s.insert(a);
num[a]++;
}
if (s.size() == 2 && num[*s.begin()] == num[*s.rbegin()]) {
cout << "YES\n";
cout << *s.begin() << " " << *s.rbegin() << endl;
} else {
cout << "NO\n";
}
return 0;
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
There is a very secret base in Potatoland where potato mash is made according to a special recipe. The neighbours from Porridgia decided to seize this recipe and to sell it to Pilauland. For this mission they have been preparing special agent Pearlo for many years. When, finally, Pearlo learned all secrets of espionage, he penetrated into the Potatoland territory and reached the secret base.
Now he is standing at the entrance, but to get inside he need to pass combination lock. Minute ago one of the workers entered the password on the terminal and opened the door. The terminal is a square digital keyboard 3 × 3 with digits from 1 to 9.
Pearlo knows that the password consists from distinct digits and is probably symmetric with respect to the central button of the terminal. He has heat sensor which allowed him to detect the digits which the worker pressed. Now he wants to check whether the password entered by the worker is symmetric with respect to the central button of the terminal. This fact can Help Pearlo to reduce the number of different possible password combinations.
Input
Input contains the matrix of three rows of three symbols each. Symbol «X» means that the corresponding button was pressed, and «.» means that is was not pressed. The matrix may contain no «X», also it may contain no «.».
Output
Print YES if the password is symmetric with respect to the central button of the terminal and NO otherwise.
Examples
Input
XX.
...
.XX
Output
YES
Input
X.X
X..
...
Output
NO
Note
If you are not familiar with the term «central symmetry», you may look into http://en.wikipedia.org/wiki/Central_symmetry
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[4][4];
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> arr[i][j];
}
}
if (arr[1][1] == arr[3][3] && arr[1][3] == arr[3][1] &&
arr[1][2] == arr[3][2] && arr[2][1] == arr[2][3]) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Princess Twilight went to Celestia and Luna's old castle to research the chest from the Elements of Harmony.
<image>
A sequence of positive integers bi is harmony if and only if for every two elements of the sequence their greatest common divisor equals 1. According to an ancient book, the key of the chest is a harmony sequence bi which minimizes the following expression:
<image>
You are given sequence ai, help Princess Twilight to find the key.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of elements of the sequences a and b. The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 30).
Output
Output the key — sequence bi that minimizes the sum described above. If there are multiple optimal sequences, you can output any of them.
Examples
Input
5
1 1 1 1 1
Output
1 1 1 1 1
Input
5
1 6 4 2 8
Output
1 5 3 1 8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59};
const int P = 17, MAX_N = 110, MAX_A = 30, MAX_MASK = 1 << P;
int n, a[MAX_N], fact[MAX_A * 2], memo[MAX_N][MAX_MASK];
pair<int, int> mov[MAX_N][MAX_MASK];
void print(int id = 0, int mask = 0) {
while (id != n) {
if (id) cout << ' ';
cout << mov[id][mask].first;
mask = mov[id][mask].second;
id++;
}
cout << endl;
}
int dp(int id = 0, int mask = 0) {
if (id == n) return 0;
if (~memo[id][mask]) return memo[id][mask];
int ret = abs(a[id] - 1) + dp(id + 1, mask);
mov[id][mask] = {1, mask};
for (int b = 2; b < 2 * a[id]; b++) {
int new_mask = mask ^ fact[b];
if ((new_mask bitand fact[b]) == fact[b]) {
int res = abs(a[id] - b) + dp(id + 1, new_mask);
if (res < ret) {
ret = res;
mov[id][mask] = {b, new_mask};
}
}
}
return memo[id][mask] = ret;
}
void precal() {
for (int i = 2; i <= MAX_A * 2; i++) {
int mask = 0;
for (int j = 0; j < P; j++)
if (i % prime[j] == 0) mask |= 1 << j;
fact[i] = mask;
}
}
int main() {
precal();
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(memo, -1, sizeof memo);
dp();
print();
return (0);
}
```
|
### Prompt
Develop a solution in Cpp to the problem described below:
One warm and sunny day king Copa decided to visit the shooting gallery, located at the Central Park, and try to win the main prize — big pink plush panda. The king is not good at shooting, so he invited you to help him.
The shooting gallery is an infinite vertical plane with Cartesian coordinate system on it. The targets are points on this plane. Each target is described by it's coordinates xi, and yi, by the time of it's appearance ti and by the number pi, which gives the probability that Copa hits this target if he aims at it.
A target appears and disappears instantly, so Copa can hit the target only if at the moment ti his gun sight aimed at (xi, yi). Speed of movement of the gun sight on the plane is equal to 1. Copa knows all the information about the targets beforehand (remember, he is a king!). He wants to play in the optimal way, which maximizes the expected value of the amount of hit targets. He can aim at any target at the moment 0.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — amount of targets in the shooting gallery. Then n lines follow, each describing one target. Each description consists of four numbers xi, yi, ti, pi (where xi, yi, ti — integers, - 1000 ≤ xi, yi ≤ 1000, 0 ≤ ti ≤ 109, real number pi is given with no more than 6 digits after the decimal point, 0 ≤ pi ≤ 1). No two targets may be at the same point.
Output
Output the maximum expected value of the amount of targets that was shot by the king. Your answer will be accepted if it differs from the correct answer by not more than 10 - 6.
Examples
Input
1
0 0 0 0.5
Output
0.5000000000
Input
2
0 0 0 0.6
5 0 5 0.7
Output
1.3000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct _node {
int t, x, y;
double p;
bool operator<(const _node &b) const { return t < b.t; }
} no[100010];
double dp[100010];
inline double cal(const _node &a, const _node &b) {
return sqrt(1.0 * (a.x - b.x) * (a.x - b.x) +
1.0 * (a.y - b.y) * (a.y - b.y));
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 1; i <= n; ++i)
scanf("%d%d%d%lf", &no[i].x, &no[i].y, &no[i].t, &no[i].p);
for (int i = 0; i <= n; ++i) dp[i] = 0;
sort(no + 1, no + 1 + n);
no[0].t = 0, no[0].x = 0, no[0].y = 0, no[0].p = 0;
for (int i = 0; i <= n; ++i) {
dp[i] = max(dp[i], no[i].p);
for (int j = i + 1; j <= n; ++j)
if (no[j].t - no[i].t > cal(no[i], no[j]) - 1e-7)
dp[j] = max(dp[j], dp[i] + no[j].p);
}
printf("%.10f\n", *max_element(dp, dp + 1 + n));
}
return 0;
}
```
|
### Prompt
In Cpp, your task is to solve the following problem:
problem
Mobiles are widely known as moving works of art. The IOI Japan Committee has decided to create mobiles to publicize JOI. JOI public relations mobiles are sticks, strings, and weights. It is constructed as follows using the three types of elements of.
* One end of the bar is painted blue and the other end is painted red.
* The rod is hung with a string with one point other than both ends as a fulcrum.
* Both the length from the fulcrum to the red end and the length from the fulcrum to the blue end are positive integers.
* At both ends of the rod, hang a weight or another rod with a string.
* The weight is hung on one end of one of the rods using a string.
* Nothing hangs on the weight.
* The weight of the weight is a positive integer.
* Only one of the strings is tied at one end to the fulcrum of that bar to hang one bar, the other end is not tied to any other component. Meet one or the other.
* Connect the end of a bar to the fulcrum of a bar.
* Connect the end of a rod to a weight.
However, all rods need to be balanced. The weights of the rods and strings are negligibly light, so consider that the weights of the rods and strings are all 0. About the stick,
(Total weight of weights suspended below the red end of the rod) × (Length from the fulcrum of the rod to the red end) = (Hung below the blue end of the rod) Total weight of the weight) × (length from the fulcrum of the rod to the end of the blue)
If, then the bar is balanced.
<image>
The length and how to tie the rods to make up the mobile has already been decided, but the weight of the weight has not been decided yet. The lighter the mobile, the easier it is to hang, so I want to make the mobile as light as possible. As mentioned above, while balancing all the rods, find a way to attach a weight that minimizes the total weight of the mobile, and create a program that outputs the total weight of the mobile at that time. Information about the configuration is given.
* Number of bars n
* Information for each bar (bar numbers 1 to n)
* Ratio of the length from the fulcrum to the red end to the length from the fulcrum to the blue end
* Number of rods to hang on the red end (0 for hanging weights)
* Number of rods to hang on the blue edge (0 for hanging weights)
<image>
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
The first line contains the number of bars n used in the mobile. The following n lines (1 ≤ n ≤ 100) contain the data for each bar. I + 1st line In (1 ≤ i ≤ n), four integers p, q, r, b are written with a blank as a delimiter, and on the bar i, the length from the fulcrum to the red end and the length from the fulcrum to the blue end. The ratio is p: q, the number of the bar hanging at the red end is r, and the number of the bar hanging at the blue end is b, where bar number 0 is the weight. In any input, if the minimum value of the weight of the mobile is w and the maximum value of the positive integer used to express the ratio in the input is L, then wL <231 Meet.
The number of datasets does not exceed 15.
output
The weight of the mobile is output to one line for each data set.
Examples
Input
1
6 9 0 0
4
3 2 0 4
1 3 0 0
4 4 2 1
2 2 0 0
0
Output
5
40
Input
None
Output
None
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
const double EPS = 1e-10;
typedef long long ll;
typedef pair<int, int> pint;
int gcd(int a, int b)
{
if (a < b)
swap(a, b);
if (b == 0)
return a;
return gcd(b, a%b);
}
int lcm(int a, int b)
{
return a/gcd(a, b) * b;
}
int p[101], q[101], r[101], b[101];
int dfs(int s)
{
if (s == 0)
return 1;
int red = dfs(r[s]), blue = dfs(b[s]);
int t = lcm(red*p[s], blue*q[s]);
return t/p[s] + t/q[s];
}
int main()
{
int n;
while (~scanf("%d", &n) && n)
{
bool root[101];
fill(root, root+101, true);
for (int i = 1; i <= n; ++i)
{
scanf("%d%d%d%d", p+i, q+i, r+i, b+i);
root[r[i]] = root[b[i]] = false;
}
int res = 0;
for (int i = 1; i <= n; ++i)
if (root[i])
res = dfs(i);
printf("%d\n", res);
}
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
There are n casinos lined in a row. If Memory plays at casino i, he has probability pi to win and move to the casino on the right (i + 1) or exit the row (if i = n), and a probability 1 - pi to lose and move to the casino on the left (i - 1) or also exit the row (if i = 1).
We say that Memory dominates on the interval i... j if he completes a walk such that,
* He starts on casino i.
* He never looses in casino i.
* He finishes his walk by winning in casino j.
Note that Memory can still walk left of the 1-st casino and right of the casino n and that always finishes the process.
Now Memory has some requests, in one of the following forms:
* 1 i a b: Set <image>.
* 2 l r: Print the probability that Memory will dominate on the interval l... r, i.e. compute the probability that Memory will first leave the segment l... r after winning at casino r, if she starts in casino l.
It is guaranteed that at any moment of time p is a non-decreasing sequence, i.e. pi ≤ pi + 1 for all i from 1 to n - 1.
Please help Memory by answering all his requests!
Input
The first line of the input contains two integers n and q(1 ≤ n, q ≤ 100 000), — number of casinos and number of requests respectively.
The next n lines each contain integers ai and bi (1 ≤ ai < bi ≤ 109) — <image> is the probability pi of winning in casino i.
The next q lines each contain queries of one of the types specified above (1 ≤ a < b ≤ 109, 1 ≤ i ≤ n, 1 ≤ l ≤ r ≤ n).
It's guaranteed that there will be at least one query of type 2, i.e. the output will be non-empty. Additionally, it is guaranteed that p forms a non-decreasing sequence at all times.
Output
Print a real number for every request of type 2 — the probability that boy will "dominate" on that interval. Your answer will be considered correct if its absolute error does not exceed 10 - 4.
Namely: let's assume that one of your answers is a, and the corresponding answer of the jury is b. The checker program will consider your answer correct if |a - b| ≤ 10 - 4.
Example
Input
3 13
1 3
1 2
2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
1 2 2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
Output
0.3333333333
0.2000000000
0.1666666667
0.5000000000
0.4000000000
0.6666666667
0.3333333333
0.2500000000
0.2222222222
0.6666666667
0.5714285714
0.6666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
struct node {
double l, r;
node(double lr = 0.0, double rr = 0.0) : l(lr), r(rr) {}
} st[100034 << 2];
int n, q;
double readDouble() {
int a, b;
scanf("%d%d", &a, &b);
return (double)a / (double)b;
}
node merge(const node l, const node r) {
node ret;
double D = 1.0 - (1.0 - r.l) * l.r;
if (D < eps) {
ret.l = 0.0;
ret.r = r.r;
} else {
ret.l = l.l * r.l / D;
ret.r = r.r + l.r * r.l * (1.0 - r.r) / D;
}
return ret;
}
void build(int id, int L, int R) {
if (L == R) {
double p = readDouble();
st[id] = node(p, p);
return;
}
int M = (L + R - 1) >> 1, lc = id << 1, rc = lc | 1;
build(lc, L, M);
build(rc, M + 1, R);
st[id] = merge(st[lc], st[rc]);
}
void adj(int id, int L, int R, int h, double v) {
if (L == R) {
st[id] = node(v, v);
return;
}
int M = (L + R - 1) >> 1, lc = id << 1, rc = lc | 1;
h <= M ? adj(lc, L, M, h, v) : adj(rc, M + 1, R, h, v);
st[id] = merge(st[lc], st[rc]);
}
node range(int id, int L, int R, int ql, int qr) {
if (ql <= L && R <= qr) return st[id];
int M = (L + R - 1) >> 1, lc = id << 1, rc = lc | 1;
node ret;
if (ql <= M) {
ret = range(lc, L, M, ql, min(qr, M));
if (qr > M) ret = merge(ret, range(rc, M + 1, R, max(ql, M + 1), qr));
} else if (qr > M)
ret = range(rc, M + 1, R, max(ql, M + 1), qr);
return ret;
}
int main() {
int op, u, v;
double p;
scanf("%d%d", &n, &q);
build(1, 1, n);
for (; q; --q)
if (scanf("%d", &op), op == 1) {
scanf("%d", &v);
p = readDouble();
adj(1, 1, n, v, p);
} else {
scanf("%d%d", &u, &v);
p = range(1, 1, n, u, v).l;
printf("%.10lf\n", p);
}
return 0;
}
```
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Two integer sequences existed initially — one of them was strictly increasing, and the other one — strictly decreasing.
Strictly increasing sequence is a sequence of integers [x_1 < x_2 < ... < x_k]. And strictly decreasing sequence is a sequence of integers [y_1 > y_2 > ... > y_l]. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
They were merged into one sequence a. After that sequence a got shuffled. For example, some of the possible resulting sequences a for an increasing sequence [1, 3, 4] and a decreasing sequence [10, 4, 2] are sequences [1, 2, 3, 4, 4, 10] or [4, 2, 1, 10, 4, 3].
This shuffled sequence a is given in the input.
Your task is to find any two suitable initial sequences. One of them should be strictly increasing and the other one — strictly decreasing. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO".
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO" in the first line.
Otherwise print "YES" in the first line and any two suitable sequences. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
In the second line print n_i — the number of elements in the strictly increasing sequence. n_i can be zero, in this case the increasing sequence is empty.
In the third line print n_i integers inc_1, inc_2, ..., inc_{n_i} in the increasing order of its values (inc_1 < inc_2 < ... < inc_{n_i}) — the strictly increasing sequence itself. You can keep this line empty if n_i = 0 (or just print the empty line).
In the fourth line print n_d — the number of elements in the strictly decreasing sequence. n_d can be zero, in this case the decreasing sequence is empty.
In the fifth line print n_d integers dec_1, dec_2, ..., dec_{n_d} in the decreasing order of its values (dec_1 > dec_2 > ... > dec_{n_d}) — the strictly decreasing sequence itself. You can keep this line empty if n_d = 0 (or just print the empty line).
n_i + n_d should be equal to n and the union of printed sequences should be a permutation of the given sequence (in case of "YES" answer).
Examples
Input
7
7 2 7 3 3 1 4
Output
YES
2
3 7
5
7 4 3 2 1
Input
5
4 3 1 5 3
Output
YES
1
3
4
5 4 3 1
Input
5
1 1 2 1 2
Output
NO
Input
5
0 1 2 3 4
Output
YES
0
5
4 3 2 1 0
### Response
```cpp
#include <bits/stdc++.h>
const int N = 2e5 + 5;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
int f[2][N], g[2][N], n, a[N], vis[2][N], tag, pos, Ans[N];
inline void solve() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
a[n + 1] = (2000001);
a[n + 2] = -1;
tag = 1;
for (int i = 2; i <= n; i++)
if (a[i] > a[i - 1]) tag = 0;
if (tag) {
puts("YES");
printf("0");
for (int i = 2; i <= n; i++) printf(" 1");
return;
}
tag = 1;
for (int i = 2; i <= n; i++)
if (a[i] < a[i - 1]) tag = 0;
if (tag) {
puts("YES");
printf("1");
for (int i = 2; i <= n; i++) printf(" 0");
return;
}
f[0][1] = (n + 1);
f[1][1] = (n + 2);
vis[0][1] = 1;
vis[1][1] = 1;
for (int i = 1; i <= n - 1; i++) {
if (!vis[0][i] && !vis[1][i]) continue;
if (vis[0][i]) {
if (a[i + 1] > a[i])
f[0][i + 1] = f[0][i], g[0][i + 1] = i, vis[0][i + 1] = 1;
if (a[i + 1] < a[f[0][i]])
f[1][i + 1] = i, g[1][i + 1] = f[0][i], vis[1][i + 1] = 1;
}
if (vis[1][i]) {
if (a[i + 1] < a[i]) {
if (vis[1][i + 1] && a[f[1][i + 1]] < a[f[1][i]]) continue;
f[1][i + 1] = f[1][i];
g[1][i + 1] = i;
vis[1][i + 1] = 1;
}
if (a[i + 1] > a[f[1][i]]) {
if (vis[0][i + 1] && a[f[0][i]] > a[i]) continue;
f[0][i + 1] = i;
g[0][i + 1] = f[1][i];
vis[0][i + 1] = 1;
}
}
}
if (!vis[0][n] && !vis[1][n]) return (void)(puts("NO"));
puts("YES");
if (vis[1][n])
tag = 1;
else
tag = 0;
pos = n;
for (; pos <= n && pos; pos = g[tag][pos]) Ans[pos] = 1;
for (int i = 1; i <= n; i++)
if (Ans[i])
printf("%d ", tag);
else
printf("%d ", tag ^ 1);
}
int main() { solve(); }
```
|
### Prompt
Develop a solution in cpp to the problem described below:
Uncle Fyodor, Matroskin the Cat and Sharic the Dog live their simple but happy lives in Prostokvashino. Sometimes they receive parcels from Uncle Fyodor’s parents and sometimes from anonymous benefactors, in which case it is hard to determine to which one of them the package has been sent. A photographic rifle is obviously for Sharic who loves hunting and fish is for Matroskin, but for whom was a new video game console meant? Every one of the three friends claimed that the present is for him and nearly quarreled. Uncle Fyodor had an idea how to solve the problem justly: they should suppose that the console was sent to all three of them and play it in turns. Everybody got relieved but then yet another burning problem popped up — who will play first? This time Matroskin came up with a brilliant solution, suggesting the most fair way to find it out: play rock-paper-scissors together. The rules of the game are very simple. On the count of three every player shows a combination with his hand (or paw). The combination corresponds to one of three things: a rock, scissors or paper. Some of the gestures win over some other ones according to well-known rules: the rock breaks the scissors, the scissors cut the paper, and the paper gets wrapped over the stone. Usually there are two players. Yet there are three friends, that’s why they decided to choose the winner like that: If someone shows the gesture that wins over the other two players, then that player wins. Otherwise, another game round is required. Write a program that will determine the winner by the gestures they have shown.
Input
The first input line contains the name of the gesture that Uncle Fyodor showed, the second line shows which gesture Matroskin showed and the third line shows Sharic’s gesture.
Output
Print "F" (without quotes) if Uncle Fyodor wins. Print "M" if Matroskin wins and "S" if Sharic wins. If it is impossible to find the winner, print "?".
Examples
Input
rock
rock
rock
Output
?
Input
paper
rock
rock
Output
F
Input
scissors
rock
rock
Output
?
Input
scissors
paper
rock
Output
?
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string fyodor, matroskin, sharic;
cin >> fyodor >> matroskin >> sharic;
if ((fyodor == matroskin) && (fyodor == sharic)) {
cout << "?" << endl;
return 0;
}
if (fyodor == matroskin) {
if (fyodor == "rock" && sharic == "paper") {
cout << "S" << endl;
return 0;
}
if (fyodor == "paper" && sharic == "scissors") {
cout << "S" << endl;
return 0;
}
if (fyodor == "scissors" && sharic == "rock") {
cout << "S" << endl;
return 0;
}
}
if (fyodor == sharic) {
if (fyodor == "rock" && matroskin == "paper") {
cout << "M" << endl;
return 0;
}
if (fyodor == "paper" && matroskin == "scissors") {
cout << "M" << endl;
return 0;
}
if (fyodor == "scissors" && matroskin == "rock") {
cout << "M" << endl;
return 0;
}
}
if (matroskin == sharic) {
if (matroskin == "rock" && fyodor == "paper") {
cout << "F" << endl;
return 0;
}
if (matroskin == "paper" && fyodor == "scissors") {
cout << "F" << endl;
return 0;
}
if (matroskin == "scissors" && fyodor == "rock") {
cout << "F" << endl;
return 0;
}
}
cout << "?" << endl;
return 0;
}
```
|
### Prompt
Please formulate a CPP solution to the following problem:
There is an infinite board of square tiles. Initially all tiles are white.
Vova has a red marker and a blue marker. Red marker can color a tiles. Blue marker can color b tiles. If some tile isn't white then you can't use marker of any color on it. Each marker must be drained completely, so at the end there should be exactly a red tiles and exactly b blue tiles across the board.
Vova wants to color such a set of tiles that:
* they would form a rectangle, consisting of exactly a+b colored tiles;
* all tiles of at least one color would also form a rectangle.
Here are some examples of correct colorings:
<image>
Here are some examples of incorrect colorings:
<image>
Among all correct colorings Vova wants to choose the one with the minimal perimeter. What is the minimal perimeter Vova can obtain?
It is guaranteed that there exists at least one correct coloring.
Input
A single line contains two integers a and b (1 ≤ a, b ≤ 10^{14}) — the number of tiles red marker should color and the number of tiles blue marker should color, respectively.
Output
Print a single integer — the minimal perimeter of a colored rectangle Vova can obtain by coloring exactly a tiles red and exactly b tiles blue.
It is guaranteed that there exists at least one correct coloring.
Examples
Input
4 4
Output
12
Input
3 9
Output
14
Input
9 3
Output
14
Input
3 6
Output
12
Input
506 2708
Output
3218
Note
The first four examples correspond to the first picture of the statement.
Note that for there exist multiple correct colorings for all of the examples.
In the first example you can also make a rectangle with sides 1 and 8, though its perimeter will be 18 which is greater than 8.
In the second example you can make the same resulting rectangle with sides 3 and 4, but red tiles will form the rectangle with sides 1 and 3 and blue tiles will form the rectangle with sides 3 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long const N = 1e5 + 1;
void solve() {
long long a, b;
cin >> a >> b;
std::set<long long> s1, s2;
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) s1.insert(i);
}
for (long long i = 1; i * i <= b; i++) {
if (b % i == 0) s2.insert(i);
}
long long n = (a + b);
long long ans = 1e18;
long long i = floor(sqrt(n));
for (; i >= 1; i--) {
if (n % i == 0) {
bool done = 0;
auto itr = s1.lower_bound(i);
if (itr == s1.end()) {
itr--;
long long k = (*itr);
if ((a / k) <= (n / i)) {
done = 1;
}
} else if ((*itr) > i) {
if (itr != s1.begin()) {
itr--;
long long k = (*itr);
if ((a / k) <= (n / i)) {
done = 1;
}
}
} else {
long long k = (*itr);
if ((a / k) <= (n / i)) {
done = 1;
}
}
if (done) {
long long k = 2LL * (i + (n / i));
ans = min(ans, k);
break;
}
auto ptr = s2.lower_bound(i);
if (ptr == s2.end()) {
ptr--;
long long k = (*ptr);
if ((b / k) <= (n / i)) {
done = 1;
}
} else if ((*ptr) > i) {
if (ptr != s2.begin()) {
ptr--;
long long k = (*ptr);
if ((b / k) <= (n / i)) {
done = 1;
}
}
} else {
long long k = (*ptr);
if ((b / k) <= (n / i)) {
done = 1;
}
}
if (done) {
long long k = 2LL * (i + (n / i));
ans = min(ans, k);
break;
}
}
}
std::cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Appleman has a very big sheet of paper. This sheet has a form of rectangle with dimensions 1 × n. Your task is help Appleman with folding of such a sheet. Actually, you need to perform q queries. Each query will have one of the following types:
1. Fold the sheet of paper at position pi. After this query the leftmost part of the paper with dimensions 1 × pi must be above the rightmost part of the paper with dimensions 1 × ([current width of sheet] - pi).
2. Count what is the total width of the paper pieces, if we will make two described later cuts and consider only the pieces between the cuts. We will make one cut at distance li from the left border of the current sheet of paper and the other at distance ri from the left border of the current sheet of paper.
Please look at the explanation of the first test example for better understanding of the problem.
Input
The first line contains two integers: n and q (1 ≤ n ≤ 105; 1 ≤ q ≤ 105) — the width of the paper and the number of queries.
Each of the following q lines contains one of the described queries in the following format:
* "1 pi" (1 ≤ pi < [current width of sheet]) — the first type query.
* "2 li ri" (0 ≤ li < ri ≤ [current width of sheet]) — the second type query.
Output
For each query of the second type, output the answer.
Examples
Input
7 4
1 3
1 2
2 0 1
2 1 2
Output
4
3
Input
10 9
2 2 9
1 1
2 0 1
1 8
2 0 8
1 2
2 1 3
1 4
2 2 4
Output
7
2
10
4
5
Note
The pictures below show the shapes of the paper during the queries of the first example:
<image>
After the first fold operation the sheet has width equal to 4, after the second one the width of the sheet equals to 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int c[MAXN], s[MAXN], n;
void ADD(int p, int val) {
s[p] += val;
while (p <= n) {
c[p] += val;
p += ((p) & (-(p)));
}
}
int getsum(int p) {
int sum = 0;
while (p > 0) {
sum += c[p];
p -= ((p) & (-(p)));
}
return sum;
}
int main() {
int i, p;
scanf("%d%d", &n, &p);
memset(c, 0, sizeof(c));
memset(s, 0, sizeof(s));
for (i = 1; i <= n; ++i) ADD(i, 1);
int l = 1, r = n;
int x, y, z;
int flag = 0;
for (int k = 0; k < p; ++k) {
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
int fg = ((y * 2) > (r - l + 1));
int mid;
if (flag)
mid = r - y;
else
mid = l + y - 1;
int ll = mid - l + 1;
int rr = r - mid;
if (ll <= rr) {
for (i = l; i <= mid; ++i) ADD(2 * mid + 1 - i, s[i]);
l = mid + 1;
} else {
for (i = mid + 1; i <= r; ++i) ADD(2 * mid + 1 - i, s[i]);
r = mid;
}
flag ^= fg;
} else {
scanf("%d%d", &y, &z);
if (flag)
printf("%d\n", getsum(r - y) - getsum(r - z));
else
printf("%d\n", getsum(l + z - 1) - getsum(l + y - 1));
}
}
return 0;
}
```
|
### Prompt
Please formulate a CPP solution 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>
#pragma GCC target("avx2,fma")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const int INF = 2139062143;
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 5000005;
int n, tree[N][2], sz[N], cnt, ans;
void insert(int x) {
int u = 0;
for (int i = 29; i >= 0; i--) {
bool opt = (x & (1 << i));
if (!tree[u][opt]) tree[u][opt] = ++cnt;
u = tree[u][opt];
sz[u]++;
}
}
void dfs(int u, int cnt, int dep) {
if (!dep) {
ans = min(ans, cnt);
return;
}
if (tree[u][0]) dfs(tree[u][0], cnt + max(0, sz[tree[u][1]] - 1), dep - 1);
if (tree[u][1]) dfs(tree[u][1], cnt + max(0, sz[tree[u][0]] - 1), dep - 1);
}
int main() {
read(n);
ans = INF;
for (int i = 1, x; i <= n; i++) {
read(x);
insert(x);
}
dfs(0, 0, 30);
printf("%d\n", ans);
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
There is a bus stop near the university. The lessons are over, and n students come to the stop. The i-th student will appear at the bus stop at time ti (all ti's are distinct).
We shall assume that the stop is located on the coordinate axis Ox, at point x = 0, and the bus goes along the ray Ox, that is, towards the positive direction of the coordinate axis, and back. The i-th student needs to get to the point with coordinate xi (xi > 0).
The bus moves by the following algorithm. Initially it is at point 0. The students consistently come to the stop and get on it. The bus has a seating capacity which is equal to m passengers. At the moment when m students get on the bus, it starts moving in the positive direction of the coordinate axis. Also it starts moving when the last (n-th) student gets on the bus. The bus is moving at a speed of 1 unit of distance per 1 unit of time, i.e. it covers distance y in time y.
Every time the bus passes the point at which at least one student needs to get off, it stops and these students get off the bus. The students need 1 + [k / 2] units of time to get off the bus, where k is the number of students who leave at this point. Expression [k / 2] denotes rounded down k / 2. As soon as the last student leaves the bus, the bus turns around and goes back to the point x = 0. It doesn't make any stops until it reaches the point. At the given point the bus fills with students once more, and everything is repeated.
If students come to the stop when there's no bus, they form a line (queue) and get on the bus in the order in which they came. Any number of students get on the bus in negligible time, you should assume that it doesn't take any time. Any other actions also take no time. The bus has no other passengers apart from the students.
Write a program that will determine for each student the time when he got off the bus. The moment a student got off the bus is the moment the bus stopped at the student's destination stop (despite the fact that the group of students need some time to get off).
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of students and the number of passengers the bus can transport, correspondingly. Next n lines contain descriptions of the students, one per line. Each line contains a pair of integers ti, xi (1 ≤ ti ≤ 105, 1 ≤ xi ≤ 104). The lines are given in the order of strict increasing of ti. Values of xi can coincide.
Output
Print n numbers w1, w2, ..., wn, wi — the moment of time when the i-th student got off the bus. Print the numbers on one line and separate them with single spaces.
Examples
Input
1 10
3 5
Output
8
Input
2 1
3 5
4 5
Output
8 19
Input
5 4
3 5
4 5
5 5
6 5
7 1
Output
11 11 11 11 20
Input
20 4
28 13
31 13
35 6
36 4
52 6
53 4
83 2
84 4
87 1
93 6
108 4
113 6
116 1
125 2
130 2
136 13
162 2
166 4
184 1
192 2
Output
51 51 43 40 93 89 86 89 114 121 118 121 137 139 139 152 195 199 193 195
Note
In the first sample the bus waits for the first student for 3 units of time and drives him to his destination in additional 5 units of time. So the student leaves the bus at the moment of time 3 + 5 = 8.
In the second sample the capacity of the bus equals 1, that's why it will drive the first student alone. This student is the same as the student from the first sample. So the bus arrives to his destination at the moment of time 8, spends 1 + [1 / 2] = 1 units of time on getting him off, and returns back to 0 in additional 5 units of time. That is, the bus returns to the bus stop at the moment of time 14. By this moment the second student has already came to the bus stop. So he immediately gets in the bus, and is driven to his destination in additional 5 units of time. He gets there at the moment 14 + 5 = 19.
In the third sample the bus waits for the fourth student for 6 units of time, then drives for 5 units of time, then gets the passengers off for 1 + [4 / 2] = 3 units of time, then returns for 5 units of time, and then drives the fifth student for 1 unit of time.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int maxn = 100007;
int n, m, T;
int top, k[10004], ans[maxn];
struct student {
int t, x, i;
void get(int l) {
scanf("%d%d", &t, &x);
i = l;
}
bool operator<(const student &b) const {
if (t == b.t) return x < b.x;
return t < b.t;
}
} s[maxn], bus[maxn];
inline bool cmp(const student &a, const student &b) { return a.x < b.x; }
void geton(int &st) {
top = 0;
memset(k, 0, sizeof(k));
for (int rest = m; st <= n && rest; st++, rest--) {
bus[++top] = s[st];
k[s[st].x]++;
if (s[st].t > T) T = s[st].t;
}
}
void getoff() {
int t1 = 0, t2 = 0;
sort(bus + 1, bus + top + 1, cmp);
for (int i = 1; i <= top; i++) {
if (bus[i].x != bus[i - 1].x) {
T += t1;
t1 = k[bus[i].x] / 2 + 1;
}
ans[bus[i].i] = bus[i].x + T;
}
T += bus[top].x * 2 + t1;
}
int main() {
int st = 1, ti;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) s[i].get(i);
sort(s + 1, s + n + 1);
while (st <= n) {
geton(st);
getoff();
}
for (int i = 1; i <= n - 1; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
```
|
### Prompt
Please create a solution in cpp to the following problem:
You have a garland consisting of n lamps. Each lamp is colored red, green or blue. The color of the i-th lamp is s_i ('R', 'G' and 'B' — colors of lamps in the garland).
You have to recolor some lamps in this garland (recoloring a lamp means changing its initial color to another) in such a way that the obtained garland is nice.
A garland is called nice if any two lamps of the same color have distance divisible by three between them. I.e. if the obtained garland is t, then for each i, j such that t_i = t_j should be satisfied |i-j|~ mod~ 3 = 0. The value |x| means absolute value of x, the operation x~ mod~ y means remainder of x when divided by y.
For example, the following garlands are nice: "RGBRGBRG", "GB", "R", "GRBGRBG", "BRGBRGB". The following garlands are not nice: "RR", "RGBG".
Among all ways to recolor the initial garland to make it nice you have to choose one with the minimum number of recolored lamps. If there are multiple optimal solutions, print any of them.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line of the input contains the string s consisting of n characters 'R', 'G' and 'B' — colors of lamps in the garland.
Output
In the first line of the output print one integer r — the minimum number of recolors needed to obtain a nice garland from the given one.
In the second line of the output print one string t of length n — a nice garland obtained from the initial one with minimum number of recolors. If there are multiple optimal solutions, print any of them.
Examples
Input
3
BRB
Output
1
GRB
Input
7
RGBGRBB
Output
3
RGBRGBR
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int ans = 1e9;
string anss;
char p[] = {'B', 'G', 'R'};
do {
int cnt = 0;
string t = s;
for (int i = 0; i < n; i++)
if (i % 3 == 0 && t[i] != p[0])
cnt++, t[i] = p[0];
else if (i % 3 == 1 && t[i] != p[1])
cnt++, t[i] = p[1];
else if (i % 3 == 2 && t[i] != p[2])
cnt++, t[i] = p[2];
if (cnt < ans) {
ans = cnt;
anss = t;
}
} while (next_permutation(p, p + 3));
cout << ans << '\n' << anss;
}
```
|
### Prompt
Please formulate a cpp solution to the following problem:
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool has_bit(int mask, int bit) { return (mask >> bit) & 1; }
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> first(n / 2);
vector<int> second(n - n / 2);
for (int i = 0; i < n; ++i) {
if (i < n / 2)
cin >> first[i];
else
cin >> second[i - n / 2];
}
vector<int> first_sum;
vector<int> second_sum;
for (int i = 0; i < 1LL << (n / 2); ++i) {
long long cur_sum = 0;
for (int j = 0; j < n / 2; ++j) {
if (has_bit(i, j)) {
cur_sum += first[j];
}
}
first_sum.push_back(cur_sum % m);
}
for (int i = 0; i < (1LL << (n - n / 2)); ++i) {
long long cur_sum = 0;
for (int j = 0; j < n - n / 2; ++j) {
if (has_bit(i, j)) cur_sum += second[j];
}
second_sum.push_back(cur_sum % m);
}
sort(first_sum.begin(), first_sum.end());
sort(second_sum.begin(), second_sum.end());
int l = 0;
int r = (int)second_sum.size() - 1;
int max_sum = 0;
while (l < first_sum.size() && r >= 0) {
max_sum = max((first_sum[l] + second_sum[r]) % m, max_sum);
if (first_sum[l] + second_sum[r] >= m)
--r;
else
++l;
}
cout << max_sum << endl;
return 0;
}
```
|
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a sequence with N integers: A = \\{ A_1, A_2, \cdots, A_N \\}. For each of these N integers, we will choose a color and paint the integer with that color. Here the following condition must be satisfied:
* If A_i and A_j (i < j) are painted with the same color, A_i < A_j.
Find the minimum number of colors required to satisfy the condition.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the minimum number of colors required to satisfy the condition.
Examples
Input
5
2
1
4
5
3
Output
2
Input
4
0
0
0
0
Output
4
### Response
```cpp
#include <iostream>
#include <set>
using namespace std;
int main() {
int n;
cin >> n;
multiset<int> st;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
auto itr = st.lower_bound(a);
if (itr == st.begin()) {
st.insert(a);
} else {
itr--;
st.erase(itr);
st.insert(a);
}
}
int ans = st.size();
cout << ans << endl;
return 0;
}
```
|
### Prompt
Please formulate a Cpp solution to the following problem:
Appleman and Toastman play a game. Initially Appleman gives one group of n numbers to the Toastman, then they start to complete the following tasks:
* Each time Toastman gets a group of numbers, he sums up all the numbers and adds this sum to the score. Then he gives the group to the Appleman.
* Each time Appleman gets a group consisting of a single number, he throws this group out. Each time Appleman gets a group consisting of more than one number, he splits the group into two non-empty groups (he can do it in any way) and gives each of them to Toastman.
After guys complete all the tasks they look at the score value. What is the maximum possible value of score they can get?
Input
The first line contains a single integer n (1 ≤ n ≤ 3·105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial group that is given to Toastman.
Output
Print a single integer — the largest possible score.
Examples
Input
3
3 1 5
Output
26
Input
1
10
Output
10
Note
Consider the following situation in the first example. Initially Toastman gets group [3, 1, 5] and adds 9 to the score, then he give the group to Appleman. Appleman splits group [3, 1, 5] into two groups: [3, 5] and [1]. Both of them should be given to Toastman. When Toastman receives group [1], he adds 1 to score and gives the group to Appleman (he will throw it out). When Toastman receives group [3, 5], he adds 8 to the score and gives the group to Appleman. Appleman splits [3, 5] in the only possible way: [5] and [3]. Then he gives both groups to Toastman. When Toastman receives [5], he adds 5 to the score and gives the group to Appleman (he will throws it out). When Toastman receives [3], he adds 3 to the score and gives the group to Appleman (he will throws it out). Finally Toastman have added 9 + 1 + 8 + 5 + 3 = 26 to the score. This is the optimal sequence of actions.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, temp, score = 0, sum = 0, total = 0, singsum = 0;
cin >> n;
unsigned long long group[n], cumsum[n], ans[n];
for (int i = 0; i < n; i++) scanf("%lld", &group[i]);
if (n == 1)
cout << group[0] << endl;
else {
sort(group, group + n);
for (int i = 0; i < n; i++) singsum += group[i];
for (int i = 0; i < n; i++) {
sum += group[i];
cumsum[i] = sum;
}
for (int i = 0; i < n; i++) {
ans[i] = (singsum - cumsum[i]);
}
for (int i = 0; i < n; i++) {
total += ans[i];
}
for (int i = 0; i < n - 1; i++) {
total += group[i];
}
cout << total + singsum << endl;
}
return 0;
}
```
|
### Prompt
Create a solution in Cpp for the following problem:
Two players play a game.
Initially there are n integers a_1, a_2, …, a_n written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the board, i. e. n - 1 turns are made. The first player makes the first move, then players alternate turns.
The first player wants to minimize the last number that would be left on the board, while the second player wants to maximize it.
You want to know what number will be left on the board after n - 1 turns if both players make optimal moves.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of numbers on the board.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6).
Output
Print one number that will be left on the board.
Examples
Input
3
2 1 3
Output
2
Input
3
2 2 2
Output
2
Note
In the first sample, the first player erases 3 and the second erases 1. 2 is left on the board.
In the second sample, 2 is left on the board regardless of the actions of the players.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
int n;
long long p[MAXN];
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
sort(p + 1, p + 1 + n);
return !printf("%lld\n", p[(n + 1) / 2]);
}
```
|
### Prompt
Construct a CPP code solution to the problem outlined:
Petya and Vasya arranged a game. The game runs by the following rules. Players have a directed graph consisting of n vertices and m edges. One of the vertices contains a chip. Initially the chip is located at vertex s. Players take turns moving the chip along some edge of the graph. Petya goes first. Player who can't move the chip loses. If the game lasts for 106 turns the draw is announced.
Vasya was performing big laboratory work in "Spelling and parts of speech" at night before the game, so he fell asleep at the very beginning of the game. Petya decided to take the advantage of this situation and make both Petya's and Vasya's moves.
Your task is to help Petya find out if he can win the game or at least draw a tie.
Input
The first line of input contain two integers n and m — the number of vertices and the number of edges in the graph (2 ≤ n ≤ 105, 0 ≤ m ≤ 2·105).
The next n lines contain the information about edges of the graph. i-th line (1 ≤ i ≤ n) contains nonnegative integer ci — number of vertices such that there is an edge from i to these vertices and ci distinct integers ai, j — indices of these vertices (1 ≤ ai, j ≤ n, ai, j ≠ i).
It is guaranteed that the total sum of ci equals to m.
The next line contains index of vertex s — the initial position of the chip (1 ≤ s ≤ n).
Output
If Petya can win print «Win» in the first line. In the next line print numbers v1, v2, ..., vk (1 ≤ k ≤ 106) — the sequence of vertices Petya should visit for the winning. Vertex v1 should coincide with s. For i = 1... k - 1 there should be an edge from vi to vi + 1 in the graph. There must be no possible move from vertex vk. The sequence should be such that Petya wins the game.
If Petya can't win but can draw a tie, print «Draw» in the only line. Otherwise print «Lose».
Examples
Input
5 6
2 2 3
2 4 5
1 4
1 5
0
1
Output
Win
1 2 4 5
Input
3 2
1 3
1 1
0
2
Output
Lose
Input
2 2
1 2
1 1
1
Output
Draw
Note
In the first example the graph is the following:
<image>
Initially the chip is located at vertex 1. In the first move Petya moves the chip to vertex 2, after that he moves it to vertex 4 for Vasya. After that he moves to vertex 5. Now it is Vasya's turn and there is no possible move, so Petya wins.
In the second example the graph is the following:
<image>
Initially the chip is located at vertex 2. The only possible Petya's move is to go to vertex 1. After that he has to go to 3 for Vasya. Now it's Petya's turn but he has no possible move, so Petya loses.
In the third example the graph is the following:
<image>
Petya can't win, but he can move along the cycle, so the players will draw a tie.
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 2e7 + 7;
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) {
res = (res * x) % 1000000007;
}
x = (x * x) % 1000000007;
y = y >> 1;
}
return res;
}
std::vector<long long int> divi[1000004];
void divisor(int n) {
for (long long int i = 1; i <= n; i++) {
for (long long int j = i; j <= n; j += i) {
divi[i].push_back(j);
}
}
}
int deg[200004];
vector<int> v[200004];
int vis[200004][2];
int par[200004][2];
vector<int> temp;
int visit[200004];
void print(int x, int y, int start) {
temp.push_back(x);
if (x == start && y == 0) return;
print(par[x][y], 1 - y, start);
}
int dfs(int s) {
if (visit[s] == 1) {
return 1;
}
visit[s] = 1;
for (int i : v[s]) {
if (visit[i] != 2 && dfs(i)) return 1;
}
visit[s] = 2;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int start;
for (int i = 1; i <= n; i++) {
int len;
cin >> len;
for (int j = 0; j < len; j++) {
int x;
cin >> x;
v[i].push_back(x);
deg[i]++;
}
}
cin >> start;
queue<pair<int, int>> q;
q.push({start, 0});
vis[start][0] = 1;
while (!q.empty()) {
int x = q.front().second;
int u = q.front().first;
q.pop();
for (int i : v[u]) {
if (vis[i][1 - x] == 0) {
vis[i][1 - x] = 1;
par[i][1 - x] = u;
q.push({i, 1 - x});
}
}
}
for (int i = 1; i <= n; i++) {
if (deg[i] == 0) {
if (vis[i][1] == 1) {
cout << "Win" << endl;
print(i, 1, start);
for (int j = temp.size() - 1; j >= 0; j--) {
cout << temp[j] << " ";
}
return 0;
}
}
}
if (dfs(start) == 1) {
cout << "Draw" << endl;
} else {
cout << "Lose" << endl;
}
return 0;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
The only difference between easy and hard versions is the maximum value of n.
You are given a positive integer number n. You really love good numbers so you want to find the smallest good number greater than or equal to n.
The positive integer is called good if it can be represented as a sum of distinct powers of 3 (i.e. no duplicates of powers of 3 are allowed).
For example:
* 30 is a good number: 30 = 3^3 + 3^1,
* 1 is a good number: 1 = 3^0,
* 12 is a good number: 12 = 3^2 + 3^1,
* but 2 is not a good number: you can't represent it as a sum of distinct powers of 3 (2 = 3^0 + 3^0),
* 19 is not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representations 19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0 are invalid),
* 20 is also not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representation 20 = 3^2 + 3^2 + 3^0 + 3^0 is invalid).
Note, that there exist other representations of 19 and 20 as sums of powers of 3 but none of them consists of distinct powers of 3.
For the given positive integer n find such smallest m (n ≤ m) that m is a good number.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries. Then q queries follow.
The only line of the query contains one integer n (1 ≤ n ≤ 10^4).
Output
For each query, print such smallest integer m (where n ≤ m) that m is a good number.
Example
Input
7
1
2
6
13
14
3620
10000
Output
1
3
9
13
27
6561
19683
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
long long p = 0;
while (n > 2) {
p++;
n /= 3;
}
return p;
}
long long f1(long long n) {
long long a = 1, p = f(n);
for (long long i = 0; i < p; i++) a = a * 3;
if ((2 * n) > (3 * a))
return 3 * a;
else if (n == 0)
return 0;
return a + f1(n - a);
}
int main() {
int t;
cin >> t;
while (t--) {
long long a = 1, n, p;
cin >> n;
p = f1(n);
cout << p << endl;
}
return 0;
}
```
|
### Prompt
Generate a cpp solution to the following problem:
From beginning till end, this message has been waiting to be conveyed.
For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:
* Remove any two elements s and t from the set, and add their concatenation s + t to the set.
The cost of such operation is defined to be <image>, where f(s, c) denotes the number of times character c appears in string s.
Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input
The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output
Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.
Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.
Examples
Input
12
Output
abababab
Input
3
Output
codeforces
Note
For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:
* {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
* {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "ab", "a", "b"}, with a cost of 0;
* {"abab", "aba", "b"}, with a cost of 1;
* {"abab", "abab"}, with a cost of 1;
* {"abababab"}, with a cost of 8.
The total cost is 12, and it can be proved to be the minimum cost of the process.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e3 + 10;
const long long INF = 1e8;
const long long MOD = 1e9 + 7;
int main() {
int n, i, j, k, l, p, q, x, y;
vector<int> a, c;
for (i = 1; i <= 500; i++) {
a.push_back((i * (i + 1)) / 2);
c.push_back(i + 1);
}
cin >> n;
if (n == 0) {
cout << 'a';
return 0;
}
vector<char> b;
i = 0;
while (n) {
l = lower_bound(a.begin(), a.end(), n) - a.begin();
k = a[l];
if (n != k) {
p = c[l - 1];
k = a[l - 1];
for (j = 0; j < p; j++) b.push_back(char(97 + i));
n = n - k;
} else {
p = c[l];
for (j = 0; j < p; j++) b.push_back(char(97 + i));
n = n - k;
}
i++;
}
for (auto t : b) cout << t;
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Andrew and Eugene are playing a game. Initially, Andrew has string s, consisting of digits. Eugene sends Andrew multiple queries of type "di → ti", that means "replace all digits di in string s with substrings equal to ti". For example, if s = 123123, then query "2 → 00" transforms s to 10031003, and query "3 → " ("replace 3 by an empty string") transforms it to s = 1212. After all the queries Eugene asks Andrew to find the remainder after division of number with decimal representation equal to s by 1000000007 (109 + 7). When you represent s as a decimal number, please ignore the leading zeroes; also if s is an empty string, then it's assumed that the number equals to zero.
Andrew got tired of processing Eugene's requests manually and he asked you to write a program for that. Help him!
Input
The first line contains string s (1 ≤ |s| ≤ 105), consisting of digits — the string before processing all the requests.
The second line contains a single integer n (0 ≤ n ≤ 105) — the number of queries.
The next n lines contain the descriptions of the queries. The i-th query is described by string "di->ti", where di is exactly one digit (from 0 to 9), ti is a string consisting of digits (ti can be an empty string). The sum of lengths of ti for all queries doesn't exceed 105. The queries are written in the order in which they need to be performed.
Output
Print a single integer — remainder of division of the resulting number by 1000000007 (109 + 7).
Examples
Input
123123
1
2->00
Output
10031003
Input
123123
1
3->
Output
1212
Input
222
2
2->0
0->7
Output
777
Input
1000000008
0
Output
1
Note
Note that the leading zeroes are not removed from string s after the replacement (you can see it in the third sample).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char t;
int n, mod = 1e9 + 7;
pair<int, int> val[10];
string s;
pair<char, string> que[100005];
pair<int, int> calc(string x) {
int v = 0, p = 1;
for (int i = 0; i < x.size(); ++i) {
int y = x[i] - '0';
v = (1LL * val[y].second * v + val[y].first) % mod;
p = (1LL * p * val[y].second) % mod;
}
return make_pair(v, p);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s >> n;
for (int i = 0; i < n; ++i) {
cin >> que[i].first >> que[i].second;
que[i].second = que[i].second.substr(2, que[i].second.size() - 2);
}
for (int i = 0; i < 10; ++i) {
val[i].first = i;
val[i].second = 10;
}
for (int i = n - 1; i >= 0; --i)
val[que[i].first - '0'] = calc(que[i].second);
cout << calc(s).first << '\n';
}
```
|
### Prompt
Please create a solution in Cpp to the following problem:
We have a string S consisting of lowercase English letters.
If the length of S is at most K, print S without change.
If the length of S exceeds K, extract the first K characters in S, append `...` to the end of them, and print the result.
Constraints
* K is an integer between 1 and 100 (inclusive).
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
K
S
Output
Print a string as stated in Problem Statement.
Examples
Input
7
nikoandsolstice
Output
nikoand...
Input
40
ferelibenterhominesidquodvoluntcredunt
Output
ferelibenterhominesidquodvoluntcredunt
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
int k;
cin>>k>>s;
if(s.size()>k){
cout<<s.substr(0,k)<<"..."<<endl;
}else{
cout<<s<<endl;
}
}
```
|
### Prompt
Create a solution in CPP for the following problem:
You are given an integer N. Consider all possible segments on the coordinate axis with endpoints at integer points with coordinates between 0 and N, inclusive; there will be <image> of them.
You want to draw these segments in several layers so that in each layer the segments don't overlap (they might touch at the endpoints though). You can not move the segments to a different location on the coordinate axis.
Find the minimal number of layers you have to use for the given N.
Input
The only input line contains a single integer N (1 ≤ N ≤ 100).
Output
Output a single integer - the minimal number of layers required to draw the segments for the given N.
Examples
Input
2
Output
2
Input
3
Output
4
Input
4
Output
6
Note
As an example, here are the segments and their optimal arrangement into layers for N = 4.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n + 1) / 2 - (n * n) / 4 << endl;
return 0;
}
```
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Given is a string S consisting of `L` and `R`.
Let N be the length of S. There are N squares arranged from left to right, and the i-th character of S from the left is written on the i-th square from the left.
The character written on the leftmost square is always `R`, and the character written on the rightmost square is always `L`.
Initially, one child is standing on each square.
Each child will perform the move below 10^{100} times:
* Move one square in the direction specified by the character written in the square on which the child is standing. `L` denotes left, and `R` denotes right.
Find the number of children standing on each square after the children performed the moves.
Constraints
* S is a string of length between 2 and 10^5 (inclusive).
* Each character of S is `L` or `R`.
* The first and last characters of S are `R` and `L`, respectively.
Input
Input is given from Standard Input in the following format:
S
Output
Print the number of children standing on each square after the children performed the moves, in order from left to right.
Examples
Input
RRLRL
Output
0 1 2 1 1
Input
RRLLLLRLRRLL
Output
0 3 3 0 0 0 1 1 0 2 2 0
Input
RRRLLRLLRRRLLLLL
Output
0 0 3 2 0 2 1 0 0 0 4 4 0 0 0 0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define M 100005
char dr[M];
int ans[M];
int main(){
scanf("%s",dr+1);
int n=strlen(dr+1);
for(int i=n,pr;i>=1;--i){
if(dr[i]=='L')pr=i;
else ans[pr-((pr-i)&1)]++;
}
for(int i=1,pr;i<=n;++i){
if(dr[i]=='R')pr=i;
else ans[pr+((i-pr)&1)]++;
}
for(int i=1;i<=n;++i)printf("%d ",ans[i]);
}
```
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Find the least common multiple (LCM) of given n integers.
Constraints
* 2 ≤ n ≤ 10
* 1 ≤ ai ≤ 1000
* Product of given integers ai(i = 1, 2, ... n) does not exceed 231-1
Input
n
a1 a2 ... an
n is given in the first line. Then, n integers are given in the second line.
Output
Print the least common multiple of the given integers in a line.
Examples
Input
3
3 4 6
Output
12
Input
4
1 2 3 5
Output
30
### Response
```cpp
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
int LCM(int m, int n) {
int x = m*n;
while (m%n != 0) {
int temp = m%n;
m = n; n = temp;
}
return x / n;
}
int main() {
cin.tie(0); ios::sync_with_stdio(false);
int n; cin >> n;
vector<int> v(n);
for (int i = 0;i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<int>());
int Ans = v[0];
for (int i = 1; i < n; i++) {
Ans = LCM(Ans, v[i]);
}
cout << Ans << endl;
}
```
|
### Prompt
In cpp, your task is to solve the following problem:
Vasya has two arrays A and B of lengths n and m, respectively.
He can perform the following operation arbitrary number of times (possibly zero): he takes some consecutive subsegment of the array and replaces it with a single element, equal to the sum of all elements on this subsegment. For example, from the array [1, 10, 100, 1000, 10000] Vasya can obtain array [1, 1110, 10000], and from array [1, 2, 3] Vasya can obtain array [6].
Two arrays A and B are considered equal if and only if they have the same length and for each valid i A_i = B_i.
Vasya wants to perform some of these operations on array A, some on array B, in such a way that arrays A and B become equal. Moreover, the lengths of the resulting arrays should be maximal possible.
Help Vasya to determine the maximum length of the arrays that he can achieve or output that it is impossible to make arrays A and B equal.
Input
The first line contains a single integer n~(1 ≤ n ≤ 3 ⋅ 10^5) — the length of the first array.
The second line contains n integers a_1, a_2, ⋅⋅⋅, a_n~(1 ≤ a_i ≤ 10^9) — elements of the array A.
The third line contains a single integer m~(1 ≤ m ≤ 3 ⋅ 10^5) — the length of the second array.
The fourth line contains m integers b_1, b_2, ⋅⋅⋅, b_m~(1 ≤ b_i ≤ 10^9) - elements of the array B.
Output
Print a single integer — the maximum length of the resulting arrays after some operations were performed on arrays A and B in such a way that they became equal.
If there is no way to make array equal, print "-1".
Examples
Input
5
11 2 3 5 7
4
11 7 3 7
Output
3
Input
2
1 2
1
100
Output
-1
Input
3
1 2 3
3
1 2 3
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
vector<int> A(n);
vector<long long> Asum(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &A[i]);
if (i == 0)
Asum[i] = A[i];
else
Asum[i] = Asum[i - 1] + A[i];
}
cin >> m;
vector<int> B(m);
vector<long long> Bsum(m);
for (int i = 0; i < m; ++i) {
scanf("%d", &B[i]);
if (i == 0)
Bsum[i] = B[i];
else
Bsum[i] = Bsum[i - 1] + B[i];
}
if (Asum[n - 1] != Bsum[m - 1]) {
cout << "-1";
return 0;
}
int i = 0, j = 0;
int ans = 0;
while (i < n || j < m) {
if (Asum[i] < Bsum[j]) ++i;
if (Asum[i] > Bsum[j]) ++j;
if (Asum[i] == Bsum[j]) {
++ans;
++i;
++j;
}
}
cout << ans;
return 0;
}
```
|
### Prompt
Generate a Cpp solution to the following problem:
You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation.
* Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation.
You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.
Examples of operation: The following are three examples of valid operations (on three decks with different sizes).
* If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6].
* If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3].
* If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1].
Input
The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.
The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.
It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.
Output
On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).
Then, print q lines, each describing one operation.
To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|.
It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.
It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.
Examples
Input
4
3 1 2 4
Output
2
3 1 2 1
2 1 3
Input
6
6 5 4 3 2 1
Output
1
6 1 1 1 1 1 1
Input
1
1
Output
0
Note
Explanation of the first testcase: Initially the deck is [3 1 2 4].
* The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3].
* The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4].
Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1].
* The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10, inf = 2e9 + 10, mod = 1e9 + 7, inv2 = (mod + 1) / 2;
int n, c[55], pos[55], c1[55];
void f(int l, int r, int num) {
for (int i = l; i <= r; ++i) {
int t = c[i];
c1[i + num] = t;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
c1[i] = c[i];
pos[c[i]] = i;
}
int flag = n & 1;
vector<vector<int>> res;
for (int i = 1; i <= n; ++i) {
int id = pos[i];
vector<int> ans;
if (flag == 0) {
for (int j = i - 1; j > 0; --j) {
ans.push_back(1);
c1[n - j + 1] = j;
}
f(i, id, n - i - id + 1);
f(id + 1, n, -id);
if (id - i + 1) ans.push_back(id - i + 1);
if (n - id) ans.push_back(n - id);
if (ans.size() > 1) {
res.push_back(ans);
}
} else {
f(id, n - i + 1, i - id);
f(1, id - 1, n - id + 1);
if (id - 1) ans.push_back(id - 1);
if (n - i - id + 2) ans.push_back(n - i - id + 2);
for (int j = i - 1; j > 0; --j) {
ans.push_back(1);
c1[j] = j;
}
if (ans.size() > 1) {
res.push_back(ans);
}
}
for (int j = 1; j <= n; ++j) {
c[j] = c1[j];
pos[c[j]] = j;
}
flag ^= 1;
}
cout << res.size() << '\n';
for (auto x : res) {
cout << x.size() << ' ';
for (int i = 0; i < x.size(); ++i) cout << x[i] << " \n"[i == x.size() - 1];
}
}
```
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given an array a consisting of n integers. You have to process q queries to this array; each query is given as four numbers l, r, x and y, denoting that for every i such that l ≤ i ≤ r and ai = x you have to set ai equal to y.
Print the array after all queries are processed.
Input
The first line contains one integer n (1 ≤ n ≤ 200000) — the size of array a.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the elements of array a.
The third line contains one integer q (1 ≤ q ≤ 200000) — the number of queries you have to process.
Then q lines follow. i-th line contains four integers l, r, x and y denoting i-th query (1 ≤ l ≤ r ≤ n, 1 ≤ x, y ≤ 100).
Output
Print n integers — elements of array a after all changes are made.
Example
Input
5
1 2 3 4 5
3
3 5 3 5
1 5 5 1
1 5 1 5
Output
5 2 5 4 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class Segm_Tree {
public:
Segm_Tree() {
cin >> n;
val.resize(n + 1);
tree.resize(n << 2);
lazy.resize(n << 2);
for (auto &x : tree) {
x.resize(101);
for (int i = 1; i <= 100; ++i) {
x[i] = i;
}
}
for (int i = 1; i <= n; ++i) {
cin >> val[i];
}
}
void Solve() {
int q, l, r, x, y;
cin >> q;
while (q--) {
cin >> l >> r >> x >> y;
Update(l, r, x, y, 1, n, 1);
}
Finish(1, n, 1);
}
private:
int n, q;
vector<int> val;
vector<bool> lazy;
vector<vector<int> > tree;
void Propagate(int cur_node) {
int left = cur_node << 1;
int right = left | 1;
for (int i = 1; i <= 100; ++i) {
tree[left][i] = tree[cur_node][tree[left][i]];
tree[right][i] = tree[cur_node][tree[right][i]];
}
for (int i = 1; i <= 100; ++i) {
tree[cur_node][i] = i;
}
lazy[left] = true;
lazy[right] = true;
lazy[cur_node] = false;
}
void Update(int l, int r, int x, int y, int st, int dr, int cur_node) {
if (l <= st and dr <= r) {
for (int i = 1; i <= 100; ++i) {
if (tree[cur_node][i] == x) {
tree[cur_node][i] = y;
}
}
lazy[cur_node] = true;
if (st != dr and lazy[cur_node]) {
Propagate(cur_node);
}
return;
}
if (lazy[cur_node]) {
Propagate(cur_node);
}
int mid = (st + dr) >> 1;
int left = cur_node << 1;
int right = left | 1;
if (l <= mid) {
Update(l, r, x, y, st, mid, left);
}
if (mid + 1 <= r) {
Update(l, r, x, y, mid + 1, dr, right);
}
}
void Finish(int st, int dr, int cur_node) {
if (st == dr) {
cout << tree[cur_node][val[st]] << ' ';
return;
}
if (lazy[cur_node]) {
Propagate(cur_node);
}
int mid = (st + dr) >> 1;
int left = cur_node << 1;
int right = left | 1;
Finish(st, mid, left);
Finish(mid + 1, dr, right);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Segm_Tree T;
T.Solve();
}
```
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Artsem has a friend Saunders from University of Chicago. Saunders presented him with the following problem.
Let [n] denote the set {1, ..., n}. We will also write f: [x] → [y] when a function f is defined in integer points 1, ..., x, and all its values are integers from 1 to y.
Now then, you are given a function f: [n] → [n]. Your task is to find a positive integer m, and two functions g: [n] → [m], h: [m] → [n], such that g(h(x)) = x for all <image>, and h(g(x)) = f(x) for all <image>, or determine that finding these is impossible.
Input
The first line contains an integer n (1 ≤ n ≤ 105).
The second line contains n space-separated integers — values f(1), ..., f(n) (1 ≤ f(i) ≤ n).
Output
If there is no answer, print one integer -1.
Otherwise, on the first line print the number m (1 ≤ m ≤ 106). On the second line print n numbers g(1), ..., g(n). On the third line print m numbers h(1), ..., h(m).
If there are several correct answers, you may output any of them. It is guaranteed that if a valid answer exists, then there is an answer satisfying the above restrictions.
Examples
Input
3
1 2 3
Output
3
1 2 3
1 2 3
Input
3
2 2 2
Output
1
1 1 1
2
Input
2
2 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 100100;
int n, m;
int a[maxn + 5];
int b[maxn + 5];
int c[maxn + 5];
int id[maxn + 5];
int main() {
scanf("%d", &n);
memset(id, -1, sizeof id);
memset(c, -1, sizeof c);
m = 0;
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
scanf("%d", a + i), --a[i];
if (!~id[a[i]]) id[a[i]] = m++;
b[i] = id[a[i]];
if (a[i] == i) c[id[a[i]]] = i;
}
for (int i = (0), i_end_ = (m); i < i_end_; ++i)
if (!~c[i]) {
printf("-1\n");
return 0;
}
for (int i = (0), i_end_ = (m); i < i_end_; ++i) assert(b[c[i]] == i);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) assert(c[b[i]] == a[i]);
printf("%d\n", m);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) printf("%d ", b[i] + 1);
printf("\n");
for (int i = (0), i_end_ = (m); i < i_end_; ++i) printf("%d ", c[i] + 1);
printf("\n");
return 0;
}
```
|
### Prompt
Construct a Cpp code solution to the problem outlined:
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int T, n;
long long W;
pair<long long, int> w[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (cin >> T; T--;) {
vector<int> id;
cin >> n >> W;
long long x = W;
for (int i = 1; i <= n; ++i) cin >> w[i].first, w[i].second = i;
sort(w + 1, w + n + 1, greater<pair<int, int> >());
for (int i = 1; i <= n; ++i)
if (w[i].first <= x) x -= w[i].first, id.push_back(w[i].second);
if (W - x < (W + 1) / 2)
cout << "-1\n";
else {
cout << id.size() << '\n';
for (int i : id) cout << i << ' ';
cout << '\n';
}
}
return 0;
}
```
|
### Prompt
Please create a solution in CPP to the following problem:
Vasya has been playing Plane of Tanks with his friends the whole year. Now it is time to divide the participants into several categories depending on their results.
A player is given a non-negative integer number of points in each round of the Plane of Tanks. Vasya wrote results for each round of the last year. He has n records in total.
In order to determine a player's category consider the best result obtained by the player and the best results of other players. The player belongs to category:
* "noob" — if more than 50% of players have better results;
* "random" — if his result is not worse than the result that 50% of players have, but more than 20% of players have better results;
* "average" — if his result is not worse than the result that 80% of players have, but more than 10% of players have better results;
* "hardcore" — if his result is not worse than the result that 90% of players have, but more than 1% of players have better results;
* "pro" — if his result is not worse than the result that 99% of players have.
When the percentage is calculated the player himself is taken into account. That means that if two players played the game and the first one gained 100 points and the second one 1000 points, then the first player's result is not worse than the result that 50% of players have, and the second one is not worse than the result that 100% of players have.
Vasya gave you the last year Plane of Tanks results. Help Vasya determine each player's category.
Input
The first line contains the only integer number n (1 ≤ n ≤ 1000) — a number of records with the players' results.
Each of the next n lines contains a player's name and the amount of points, obtained by the player for the round, separated with a space. The name contains not less than 1 and no more than 10 characters. The name consists of lowercase Latin letters only. It is guaranteed that any two different players have different names. The amount of points, obtained by the player for the round, is a non-negative integer number and does not exceed 1000.
Output
Print on the first line the number m — the number of players, who participated in one round at least.
Each one of the next m lines should contain a player name and a category he belongs to, separated with space. Category can be one of the following: "noob", "random", "average", "hardcore" or "pro" (without quotes). The name of each player should be printed only once. Player names with respective categories can be printed in an arbitrary order.
Examples
Input
5
vasya 100
vasya 200
artem 100
kolya 200
igor 250
Output
4
artem noob
igor pro
kolya random
vasya random
Input
3
vasya 200
kolya 1000
vasya 1000
Output
2
kolya pro
vasya pro
Note
In the first example the best result, obtained by artem is not worse than the result that 25% of players have (his own result), so he belongs to category "noob". vasya and kolya have best results not worse than the results that 75% players have (both of them and artem), so they belong to category "random". igor has best result not worse than the result that 100% of players have (all other players and himself), so he belongs to category "pro".
In the second example both players have the same amount of points, so they have results not worse than 100% players have, so they belong to category "pro".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<string, int> a, pair<string, int> b) {
return a.second < b.second;
}
struct category {
string name;
string cate;
};
int main() {
map<string, int> score;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string name;
int scr;
cin >> name >> scr;
score[name] = max(score[name], scr);
}
vector<pair<string, int> > sorted;
for (map<string, int>::iterator i = score.begin(); i != score.end(); i++)
sorted.push_back(make_pair(i->first, i->second));
sort(sorted.begin(), sorted.end(), cmp);
int playernum = sorted.size();
category ans[1001];
int curscore = -1, betternum = -1;
for (int i = playernum - 1; i >= 0; i--) {
if (sorted[i].second != curscore) {
curscore = sorted[i].second;
betternum = playernum - i - 1;
}
ans[i].name = sorted[i].first;
double ratio = (double)((double)betternum / (double)playernum);
if (ratio > 0.5) {
ans[i].cate = "noob";
continue;
}
if (ratio > 0.2) {
ans[i].cate = "random";
continue;
}
if (ratio > 0.1) {
ans[i].cate = "average";
continue;
}
if (ratio > 0.01) {
ans[i].cate = "hardcore";
continue;
}
ans[i].cate = "pro";
}
cout << playernum << endl;
for (int i = 0; i < playernum; i++)
cout << ans[i].name << " " << ans[i].cate << endl;
return 0;
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.