text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a Cpp code solution to the problem outlined:
Long story short, shashlik is Miroslav's favorite food. Shashlik is prepared on several skewers simultaneously. There are two states for each skewer: initial and turned over.
This time Miroslav laid out n skewers parallel to each other, and enumerated them with consecutive integers from 1 to n in order from left to right. For better cooking, he puts them quite close to each other, so when he turns skewer number i, it leads to turning k closest skewers from each side of the skewer i, that is, skewers number i - k, i - k + 1, ..., i - 1, i + 1, ..., i + k - 1, i + k (if they exist).
For example, let n = 6 and k = 1. When Miroslav turns skewer number 3, then skewers with numbers 2, 3, and 4 will come up turned over. If after that he turns skewer number 1, then skewers number 1, 3, and 4 will be turned over, while skewer number 2 will be in the initial position (because it is turned again).
As we said before, the art of cooking requires perfect timing, so Miroslav wants to turn over all n skewers with the minimal possible number of actions. For example, for the above example n = 6 and k = 1, two turnings are sufficient: he can turn over skewers number 2 and 5.
Help Miroslav turn over all n skewers.
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ 1000) — the number of skewers and the number of skewers from each side that are turned in one step.
Output
The first line should contain integer l — the minimum number of actions needed by Miroslav to turn over all n skewers. After than print l integers from 1 to n denoting the number of the skewer that is to be turned over at the corresponding step.
Examples
Input
7 2
Output
2
1 6
Input
5 1
Output
2
1 4
Note
In the first example the first operation turns over skewers 1, 2 and 3, the second operation turns over skewers 4, 5, 6 and 7.
In the second example it is also correct to turn over skewers 2 and 5, but turning skewers 2 and 4, or 1 and 5 are incorrect solutions because the skewer 3 is in the initial state after these operations.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cont[100005];
int main() {
long long n, k;
while (cin >> n >> k) {
if (n < k * 2) {
if (n == 1) {
cout << 1 << '\n' << 1 << '\n';
} else {
cout << 1 << '\n' << n / 2 + 1 << '\n';
;
}
continue;
}
int gap = (k << 1) + 1;
vector<int> ans;
int left = n % gap;
int now;
if (left == 0) {
now = k + 1;
} else if (left >= k)
now = left - k + 1;
else {
now = 1;
}
while (now <= n) {
ans.push_back(now);
now += gap;
}
cout << ans.size() << '\n';
for (auto i : ans) {
cout << i << ' ';
}
cout << '\n';
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Gennady owns a small hotel in the countryside where he lives a peaceful life. He loves to take long walks, watch sunsets and play cards with tourists staying in his hotel. His favorite game is called "Mau-Mau".
To play Mau-Mau, you need a pack of 52 cards. Each card has a suit (Diamonds — D, Clubs — C, Spades — S, or Hearts — H), and a rank (2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K, or A).
At the start of the game, there is one card on the table and you have five cards in your hand. You can play a card from your hand if and only if it has the same rank or the same suit as the card on the table.
In order to check if you'd be a good playing partner, Gennady has prepared a task for you. Given the card on the table and five cards in your hand, check if you can play at least one card.
Input
The first line of the input contains one string which describes the card on the table. The second line contains five strings which describe the cards in your hand.
Each string is two characters long. The first character denotes the rank and belongs to the set \{{\tt 2}, {\tt 3}, {\tt 4}, {\tt 5}, {\tt 6}, {\tt 7}, {\tt 8}, {\tt 9}, {\tt T}, {\tt J}, {\tt Q}, {\tt K}, {\tt A}\}. The second character denotes the suit and belongs to the set \{{\tt D}, {\tt C}, {\tt S}, {\tt H}\}.
All the cards in the input are different.
Output
If it is possible to play a card from your hand, print one word "YES". Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
AS
2H 4C TH JH AD
Output
YES
Input
2H
3D 4C AC KD AS
Output
NO
Input
4D
AS AC AD AH 5H
Output
YES
Note
In the first example, there is an Ace of Spades (AS) on the table. You can play an Ace of Diamonds (AD) because both of them are Aces.
In the second example, you cannot play any card.
In the third example, you can play an Ace of Diamonds (AD) because it has the same suit as a Four of Diamonds (4D), which lies on the table.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
char odin, dva;
char table[1];
string itog, itog2;
vector<pair<char, char> > allkarts;
allkarts.resize(5);
cin >> odin >> dva;
allkarts[0].first = odin;
allkarts[0].second = dva;
odin = '\0';
dva = '\0';
for (int i = 1; i < 6; i++) {
cin >> odin >> dva;
allkarts[i].first = odin;
allkarts[i].second = dva;
odin = '\0';
dva = '\0';
}
for (int i = 1; i < 6; i++) {
if ((allkarts[0].first == allkarts[i].first) ||
(allkarts[0].second == allkarts[i].second)) {
itog = "YES";
break;
} else {
itog = "NO";
}
}
cout << itog;
return EXIT_SUCCESS;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Tavas is a cheerleader in the new sports competition named "Pashmaks".
<image>
This competition consists of two part: swimming and then running. People will immediately start running R meters after they finished swimming exactly S meters. A winner is a such person that nobody else finishes running before him/her (there may be more than one winner).
Before the match starts, Tavas knows that there are n competitors registered for the match. Also, he knows that i-th person's swimming speed is si meters per second and his/her running speed is ri meters per second. Unfortunately, he doesn't know the values of R and S, but he knows that they are real numbers greater than 0.
As a cheerleader, Tavas wants to know who to cheer up. So, he wants to know all people that might win. We consider a competitor might win if and only if there are some values of R and S such that with these values, (s)he will be a winner.
Tavas isn't really familiar with programming, so he asked you to help him.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 2 × 105).
The next n lines contain the details of competitors. i-th line contains two integers si and ri (1 ≤ si, ri ≤ 104).
Output
In the first and the only line of output, print a sequence of numbers of possible winners in increasing order.
Examples
Input
3
1 3
2 2
3 1
Output
1 2 3
Input
3
1 2
1 1
2 1
Output
1 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
struct CUN {
int x, y, pos;
} use[N];
int n, tot, top;
int neet[N], sta[N];
double k[N];
bool vis[N];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return (f) ? x : (-x);
}
inline int my(CUN a, CUN b) {
if (a.x != b.x) return a.x > b.x;
return a.y > b.y;
}
inline double gett(int ax, int ay, int bx, int by) {
return ((double)ax * bx * (by - ay)) / ((double)ay * by * (bx - ax));
}
inline double suan(CUN &a, CUN &b) {
return ((double)a.x * b.x * (b.y - a.y)) / ((double)a.y * b.y * (b.x - a.x));
}
signed main() {
n = read();
int nx, ny = 0;
for (register int i = 1; i <= n; i++) {
use[i].x = read();
use[i].y = read();
use[i].pos = i;
if (use[i].y > ny || ((use[i].y == ny) && (nx < use[i].x))) {
ny = use[i].y;
nx = use[i].x;
}
}
sort(use + 1, use + n + 1, my);
top = 1;
sta[top] = 1;
for (register int i = 2; (i <= n) && (use[i].x >= nx); i++) {
if (use[i].x == use[sta[top]].x) {
if (use[i].y == use[sta[top]].y) {
neet[use[i].pos] = neet[use[sta[top]].pos];
neet[use[sta[top]].pos] = use[i].pos;
}
continue;
}
while ((top > 1) && (k[top] > gett(use[sta[top]].x, use[sta[top]].y,
use[i].x, use[i].y)))
--top;
sta[++top] = i;
k[top] = gett(use[sta[top - 1]].x, use[sta[top - 1]].y, use[i].x, use[i].y);
}
while (top) {
for (register int i = use[sta[top]].pos; i; i = neet[i]) vis[i] = 1;
--top;
}
for (register int i = 1; i <= n; i++)
if (vis[i]) printf("%d ", i);
printf("\n");
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word s. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word s.
Input
The first and only line contains the word s, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters.
Output
If Vasya managed to say hello, print "YES", otherwise print "NO".
Examples
Input
ahhellllloou
Output
YES
Input
hlelo
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int h = 0, e = 0, l = 0, l1 = 0, o = 0;
for (char tem : s) {
if (h == 0) {
if (tem == 'h') h = 1;
} else if (e == 0) {
if (tem == 'e') e = 1;
} else if (l == 0) {
if (tem == 'l') l = 1;
} else if (l1 == 0) {
if (tem == 'l') l1 = 1;
} else if (o == 0) {
if (tem == 'o') o = 1;
}
}
if (h && e && l && l1 & o) {
cout << "YES" << endl;
} else
cout << "NO";
}
``` |
### Prompt
Your task is to create a Cpp solution 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<iostream>
using namespace std;
int main(){
string s;
int k;
cin>>k>>s;
if(k>=s.length())cout<<s<<'\n';
else{
for(int i=0;i<k;i++)cout<<s[i];
cout<<"...\n";
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n,Lp[2010],Rp[2010],Mis[2010],buc[2010],tmpMis[2010],mn=0x3f3f3f3f,Suf[2010];
char tms[2010];
bool a[2010],b[2010],s1,s2;
void Sort(){//use a bucket sort to let the complexity of sorting become O(n)
for(int i=0;i<=n;i++)buc[i]=0;
for(int i=1;i<=Mis[0];i++)buc[Rp[Mis[i]]+1]++;
for(int i=1;i<=n;i++)buc[i]+=buc[i-1];
for(int i=1;i<=Mis[0];i++)tmpMis[++buc[Rp[Mis[i]]]]=Mis[i];
for(int i=1;i<=Mis[0];i++)Mis[i]=tmpMis[i];
}
int main(){
scanf("%s",tms),n=strlen(tms);
for(int i=0;i<n;i++)a[i]=tms[i]-'0';
scanf("%s",tms);
for(int i=0;i<n;i++)b[i]=tms[i]-'0';
memset(Lp,0x3f3f3f3f,sizeof(Lp)),memset(Rp,0x3f3f3f3f,sizeof(Rp));
for(int i=0;i<n;i++)for(int j=0;j<n;j++)if(b[j])Lp[i]=min(Lp[i],(i-j+n)%n),Rp[i]=min(Rp[i],(j-i+n)%n);
for(int i=0;i<n;i++)s1|=a[i],s2|=b[i];//check if there's no '1' in array b. If so, only if there's no '1' in array a, it is unable to get a proper answer.
if(!s2){
if(!s1)puts("0");
else puts("-1");
return 0;
}
for(int i=0;i<n;i++){//numerate the end position of a_i
Mis[0]=0;
for(int j=0,k=i;j<n;j++,k++,k%=n)if(a[k]!=b[j])Mis[++Mis[0]]=k;//find the mismatched positions
Sort();
Suf[Mis[0]+1]=0;
for(int j=Mis[0];j;j--)Suf[j]=max(Suf[j+1],Lp[Mis[j]]);//suffix maximum
mn=min(mn,max(i,Suf[1])*2-i+Mis[0]);//only go left/right situations
mn=min(mn,(Suf[1]+(n-i)%n)*2-(n-i)%n+Mis[0]);
for(int j=1;j<=Mis[0];j++){
mn=min(mn,(Rp[Mis[j]]+max(i,Suf[j+1]))*2-i+Mis[0]);
mn=min(mn,(Suf[j+1]+max((n-i)%n,Rp[Mis[j]]))*2-(n-i)%n+Mis[0]);
}
}
printf("%d\n",mn);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A nearby pie shop is having a special sale. For each pie you pay full price for, you may select one pie of a strictly lesser value to get for free. Given the prices of all the pies you wish to acquire, determine the minimum total amount you must pay for all of the pies.
Input
Input will begin with an integer n (1 ≤ n ≤ 500000), the number of pies you wish to acquire. Following this is a line with n integers, each indicating the cost of a pie. All costs are positive integers not exceeding 109.
Output
Print the minimum cost to acquire all the pies.
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
6
3 4 5 3 4 5
Output
14
Input
5
5 5 5 5 5
Output
25
Input
4
309999 6000 2080 2080
Output
314159
Note
In the first test case you can pay for a pie with cost 5 and get a pie with cost 4 for free, then pay for a pie with cost 5 and get a pie with cost 3 for free, then pay for a pie with cost 4 and get a pie with cost 3 for free.
In the second test case you have to pay full price for every pie.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n = 0;
long long sum = 0;
map<long long, int, greater<long long> > a;
priority_queue<long long, vector<long long>, greater<long long> > q, tmp;
int main() {
scanf("%d", &n);
long long x = 0;
for (int i = 1; i <= n; ++i) scanf("%lld", &x), sum += x, ++a[x];
int left = 0;
for (auto const &obj : a) {
long long v = obj.first;
int c = obj.second;
while (left > 0 && c > 0) {
tmp.push(v);
--left;
--c;
}
while (c >= 2 && (!q.empty() && 2 * v > q.top())) {
if (q.top() < v) {
tmp.push(v);
tmp.push(v);
} else {
tmp.push(2 * v - q.top());
tmp.push(q.top());
}
q.pop();
c -= 2;
}
if (c > 0 && !q.empty() && q.top() < v) q.pop(), q.push(v);
while (!tmp.empty()) {
q.push(tmp.top());
tmp.pop();
}
left += c;
}
long long free = 0;
while (!q.empty()) {
free += q.top();
q.pop();
}
printf("%lld", sum - free);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The Little Elephant loves strings very much.
He has an array a from n strings, consisting of lowercase English letters. Let's number the elements of the array from 1 to n, then let's denote the element number i as ai. For each string ai (1 ≤ i ≤ n) the Little Elephant wants to find the number of pairs of integers l and r (1 ≤ l ≤ r ≤ |ai|) such that substring ai[l... r] is a substring to at least k strings from array a (including the i-th string).
Help the Little Elephant solve this problem.
If you are not familiar with the basic notation in string problems, you can find the corresponding definitions in the notes.
Input
The first line contains two space-separated integers — n and k (1 ≤ n, k ≤ 105). Next n lines contain array a. The i-th line contains a non-empty string ai, consisting of lowercase English letter. The total length of all strings ai does not exceed 105.
Output
On a single line print n space-separated integers — the i-th number is the answer for string ai.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 1
abc
a
ab
Output
6 1 3
Input
7 4
rubik
furik
abab
baba
aaabbbababa
abababababa
zero
Output
1 0 9 9 21 30 0
Note
Let's assume that you are given string a = a1a2... a|a|, then let's denote the string's length as |a| and the string's i-th character as ai.
A substring a[l... r] (1 ≤ l ≤ r ≤ |a|) of string a is string alal + 1... ar.
String a is a substring of string b, if there exists such pair of integers l and r (1 ≤ l ≤ r ≤ |b|), that b[l... r] = a.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int ALPHA = 26;
int n, k;
string st[N];
struct Suffix_Automaton {
int sz, last;
int father[N], depth[N], child[N][ALPHA], cnt[N];
set<int> s[N];
vector<int> a[N];
Suffix_Automaton() {
sz = 1;
last = 1;
}
inline int new_node(int dep) {
depth[++sz] = dep;
father[sz] = 0;
memset(child[sz], 0, sizeof(child[sz]));
return sz;
}
inline void extend(int ch, int col) {
int np = child[last][ch];
if (np) {
if (depth[np] == depth[last] + 1) {
s[np].insert(col);
last = np;
return;
} else {
int nq = new_node(depth[last] + 1);
father[nq] = father[np];
father[np] = nq;
memcpy(child[nq], child[np], sizeof(child[nq]));
for (int p = last; child[p][ch] == np; p = father[p]) child[p][ch] = nq;
s[nq].insert(col);
last = nq;
return;
}
} else {
np = new_node(depth[last] + 1);
int p = last;
for (; child[p][ch] == 0; p = father[p]) child[p][ch] = np;
if (child[p][ch] == np) {
father[np] = 1;
s[np].insert(col);
last = np;
return;
} else {
int q = child[p][ch];
if (depth[q] == depth[p] + 1) {
father[np] = q;
s[np].insert(col);
last = np;
return;
} else {
int nq = new_node(depth[p] + 1);
father[nq] = father[q];
father[np] = father[q] = nq;
memcpy(child[nq], child[q], sizeof(child[nq]));
for (; child[p][ch] == q; p = father[p]) child[p][ch] = nq;
s[np].insert(col);
last = np;
}
}
}
}
inline void insert(string s, int col) {
last = 1;
for (register int i = 0; i < (int)s.size(); ++i) extend(s[i] - 'a', col);
}
inline void dfs(int u) {
for (unsigned i = 0; i < a[u].size(); ++i) {
int v = a[u][i];
dfs(v);
if ((int)s[u].size() < (int)s[v].size()) swap(s[u], s[v]);
for (set<int>::iterator it = s[v].begin(); it != s[v].end(); ++it)
s[u].insert(*it);
}
cnt[u] = (int)s[u].size();
}
inline void work() {
for (register int i = 2; i <= sz; ++i) a[father[i]].push_back(i);
dfs(1);
}
} SAM;
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
int main() {
read(n);
read(k);
for (register int i = 1; i <= n; ++i) {
cin >> st[i];
SAM.insert(st[i], i);
}
SAM.work();
for (register int i = 1; i <= n; ++i) {
int now = 1;
long long ans = 0;
for (register int j = 0; j < st[i].size(); ++j) {
now = SAM.child[now][st[i][j] - 'a'];
while (now != 1 && SAM.cnt[now] < k) now = SAM.father[now];
ans += (long long)SAM.depth[now];
}
printf("%lld ", ans);
}
printf("\n");
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There is a circle with a circumference of L. Each point on the circumference has a coordinate value, which represents the arc length from a certain reference point clockwise to the point. On this circumference, there are N ants. These ants are numbered 1 through N in order of increasing coordinate, and ant i is at coordinate X_i.
The N ants have just started walking. For each ant i, you are given the initial direction W_i. Ant i is initially walking clockwise if W_i is 1; counterclockwise if W_i is 2. Every ant walks at a constant speed of 1 per second. Sometimes, two ants bump into each other. Each of these two ants will then turn around and start walking in the opposite direction.
For each ant, find its position after T seconds.
Constraints
* All input values are integers.
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^9
* 1 \leq T \leq 10^9
* 0 \leq X_1 < X_2 < ... < X_N \leq L - 1
* 1 \leq W_i \leq 2
Input
The input is given from Standard Input in the following format:
N L T
X_1 W_1
X_2 W_2
:
X_N W_N
Output
Print N lines. The i-th line should contain the coordinate of ant i after T seconds. Here, each coordinate must be between 0 and L-1, inclusive.
Examples
Input
3 8 3
0 1
3 2
6 1
Output
1
3
0
Input
4 20 9
7 2
9 1
12 1
18 1
Output
7
18
18
1
### Response
```cpp
#include<algorithm>
#include<cstring>
#include<cctype>
#include<cstdio>
#define rep(i,x,y) for(int i=x; i<=y; ++i)
using namespace std;
const int N=100005;
int n,L,T,x,w,a[N],id;
int getint()
{
char ch;
while(!isdigit(ch=getchar()));
int x=ch-48;
while(isdigit(ch=getchar())) x=x*10+ch-48;
return x;
}
int main()
{
n=getint(),L=getint(),T=getint();
rep(i,1,n)
{
x=getint(),w=getint()==2?-1:1;
int dis=x+w*T;
if(dis>0) id=(id+dis/L)%n;
if(dis<0) id=(id+(dis+1)/L-1)%n;
a[i]=(dis%L+L)%L;
}
sort(a+1,a+1+n),id=(id+n)%n;
rep(i,id+1,n) printf("%d\n",a[i]);
rep(i,1,id) printf("%d\n",a[i]);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
problem
You are looking for a constellation in a picture of the starry sky. The photo always contains exactly one figure with the same shape, orientation, and size as the constellation you are looking for. However, there is a possibility that extra stars are shown in the photograph other than the stars that make up the constellation.
For example, the constellations in Figure 1 are included in the photo in Figure 2 (circled). If you translate the coordinates of a star in a given constellation by 2 in the x direction and −3 in the y direction, it will be the position in the photo.
Given the shape of the constellation you want to look for and the position of the star in the picture, write a program that answers the amount to translate to convert the coordinates of the constellation to the coordinates in the picture.
<image> | <image>
--- | ---
Figure 1: The constellation you want to find | Figure 2: Photograph of the starry sky
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line of the input contains the number of stars m that make up the constellation you want to find. In the following m line, the integers indicating the x and y coordinates of the m stars that make up the constellation you want to search for are written separated by blanks. The number n of stars in the photo is written on the m + 2 line. In the following n lines, the integers indicating the x and y coordinates of the n stars in the photo are written separated by blanks.
The positions of the m stars that make up the constellation are all different. Also, the positions of the n stars in the picture are all different. 1 ≤ m ≤ 200, 1 ≤ n ≤ 1000. The x and y coordinates of a star are all 0 or more and 1000000 or less.
When m is 0, it indicates the end of input. The number of datasets does not exceed 5.
output
The output of each dataset consists of one line, with two integers separated by blanks. These show how much the coordinates of the constellation you want to find should be translated to become the coordinates in the photo. The first integer is the amount to translate in the x direction, and the second integer is the amount to translate in the y direction.
Examples
Input
5
8 5
6 4
4 3
7 10
0 10
10
10 5
2 7
9 7
8 10
10 2
1 2
8 1
6 7
6 0
0 9
5
904207 809784
845370 244806
499091 59863
638406 182509
435076 362268
10
757559 866424
114810 239537
519926 989458
461089 424480
674361 448440
81851 150384
459107 795405
299682 6700
254125 362183
50795 541942
0
Output
2 -3
-384281 179674
Input
None
Output
None
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int m, n;
cin >> m;
while (m > 0) {
vector<pair <int, int>> p, q;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
p.push_back(make_pair(x, y));
}
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
q.push_back(make_pair(x, y));
}
int xp = p[0].first, yp = p[0].second;
for (int i = 0; i < n; i++) {
bool f = 1;
int xf = q[i].first, yf = q[i].second;
for (int j = 1; j < m; j++) {
pair<int, int> pk = make_pair(p[j].first - xp + xf, p[j].second - yp + yf);
if (find(q.begin(), q.end(), pk) == q.end()) {
f = 0;
break;
}
}
if (f) {
cout << xf - xp << " " << yf - yp << endl;
break;
}
}
cin >> m;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
There are N squares aligned in a row. The i-th square from the left contains an integer a_i.
Initially, all the squares are white. Snuke will perform the following operation some number of times:
* Select K consecutive squares. Then, paint all of them white, or paint all of them black. Here, the colors of the squares are overwritten.
After Snuke finishes performing the operation, the score will be calculated as the sum of the integers contained in the black squares. Find the maximum possible score.
Constraints
* 1≤N≤10^5
* 1≤K≤N
* a_i is an integer.
* |a_i|≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the maximum possible score.
Examples
Input
5 3
-10 10 -10 10 -10
Output
10
Input
4 2
10 -10 -10 10
Output
20
Input
1 1
-10
Output
0
Input
10 5
5 -4 -5 -8 -4 7 2 -4 0 7
Output
17
### Response
```cpp
#include <iostream>
using namespace std;
int a[100010];
long long num[100010],t[100010],sum[100010];
int main(){
int n,k;
long long ans=0;
cin>>n>>k;
int i;
for(i=1;i<=n;i++)cin>>a[i];
for(i=1;i<=n;i++)sum[i]=sum[i-1]+a[i];
for(i=1;i<=n;i++)num[i]=num[i-1]+max(a[i],0);
for(i=n;i>=1;i--)t[i]=t[i+1]+max(a[i],0);
for(i=0;i<=n-k;i++)
ans=max(ans,num[i]+t[i+k+1]+max(sum[i+k]-sum[i],0LL));
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
We have a grid of squares with N rows and M columns. Let (i, j) denote the square at the i-th row from the top and j-th column from the left. We will choose K of the squares and put a piece on each of them.
If we place the K pieces on squares (x_1, y_1), (x_2, y_2), ..., and (x_K, y_K), the cost of this arrangement is computed as:
\sum_{i=1}^{K-1} \sum_{j=i+1}^K (|x_i - x_j| + |y_i - y_j|)
Find the sum of the costs of all possible arrangements of the pieces. Since this value can be tremendous, print it modulo 10^9+7.
We consider two arrangements of the pieces different if and only if there is a square that contains a piece in one of the arrangements but not in the other.
Constraints
* 2 \leq N \times M \leq 2 \times 10^5
* 2 \leq K \leq N \times M
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M K
Output
Print the sum of the costs of all possible arrangements of the pieces, modulo 10^9+7.
Examples
Input
2 2 2
Output
8
Input
4 5 4
Output
87210
Input
100 100 5000
Output
817260251
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll MOD = 1e9 + 7;
ll lgput(ll b, int p) {
ll ans = 1;
while(p) {
if(p % 2)
ans = (ans * b) % MOD;
b = (b * b) % MOD;
p /= 2;
}
return ans;
}
ll invmod(ll x) {
return lgput(x, MOD - 2);
}
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
vector<ll> fact(n * m + 1, 1);
for(int i = 1; i <= n * m; i ++)
fact[i] = (i * fact[i - 1]) % MOD;
ll comb = (((fact[n * m - 2] * invmod(fact[k - 2])) % MOD) * invmod(fact[n * m - k])) % MOD;
ll s = 0;
for(int i = -(n - 1); i <= n - 1; i ++)
for(int j = -(m - 1); j <= m - 1; j ++) {
s = (s + (1LL * (abs(i) + abs(j)) * (n - abs(i)) * (m - abs(j))) % MOD) % MOD;
//cout << i << " " << j << " -> " << s << endl;
}
s = (s * comb) % MOD;
cout << (s * invmod(2)) % MOD;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given a permutation of integers from 1 to n. Exactly once you apply the following operation to this permutation: pick a random segment and shuffle its elements. Formally:
1. Pick a random segment (continuous subsequence) from l to r. All <image> segments are equiprobable.
2. Let k = r - l + 1, i.e. the length of the chosen segment. Pick a random permutation of integers from 1 to k, p1, p2, ..., pk. All k! permutation are equiprobable.
3. This permutation is applied to elements of the chosen segment, i.e. permutation a1, a2, ..., al - 1, al, al + 1, ..., ar - 1, ar, ar + 1, ..., an is transformed to a1, a2, ..., al - 1, al - 1 + p1, al - 1 + p2, ..., al - 1 + pk - 1, al - 1 + pk, ar + 1, ..., an.
Inversion if a pair of elements (not necessary neighbouring) with the wrong relative order. In other words, the number of inversion is equal to the number of pairs (i, j) such that i < j and ai > aj. Find the expected number of inversions after we apply exactly one operation mentioned above.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the length of the permutation.
The second line contains n distinct integers from 1 to n — elements of the permutation.
Output
Print one real value — the expected number of inversions. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 9.
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>.
Example
Input
3
2 3 1
Output
1.916666666666666666666666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int INF = 2e9 + 5;
const double eps = 1e-6;
template <class T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
const int maxn = 1e5 + 100;
int n, a[maxn];
long long bit[maxn];
double ans = 0;
inline int lowbit(int x) { return x & (-x); }
long long query(int x) {
long long res = 0;
while (x > 0) {
res += bit[x];
x -= lowbit(x);
}
return res;
}
void add(int x, int v) {
while (x <= n) {
bit[x] += v;
x += lowbit(x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++)
ans += 1.0 * (1LL * i * (n - i) * (n - i + 1)) / 2 / n / (n + 1);
for (int i = n; i >= 1; i--) {
long long k = query(a[i] - 1);
ans += 1.0 * (k * (1LL * n * (n + 1) - 2.0 * i * (n + 1)) / n / (n + 1));
add(a[i], 1);
}
memset(bit, 0, sizeof(bit));
for (int i = n; i >= 1; i--) {
long long k = query(a[i] - 1);
ans += 1.0 * (2 * k * i) / n / (n + 1);
add(a[i], i);
}
printf("%.16f\n", ans);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 ≤ n, d ≤ 100). The next line contains integers a1, a2, ..., an (1 ≤ ai ≤ 100). The third line contains integer m (1 ≤ m ≤ 100).
Output
In a single line print a single integer — the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 + 10;
int A[MAX_N];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
A[i] = temp;
}
int m;
cin >> m;
sort(A, A + n);
int ans = 0;
if (m <= n)
for (int i = 0; i < m; i++) ans += A[i];
else {
for (int i = 0; i < n; i++) ans += A[i];
for (int i = n; i < m; i++) ans -= d;
}
cout << ans << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
int a[111111];
int mx;
int main() {
int num;
cin >> num;
for (int i = 1; i <= num; i++) {
cin >> a[i];
mx = max(mx, a[i]);
}
cout << (mx ^ a[num]) << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Find the maximum possible sum of the digits (in base 10) of a positive integer not greater than N.
Constraints
* 1\leq N \leq 10^{16}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the maximum possible sum of the digits (in base 10) of a positive integer not greater than N.
Examples
Input
100
Output
18
Input
9995
Output
35
Input
3141592653589793
Output
137
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
signed main(){
scanf("%lld",&n);
int k,flag=1,cnt=0;
while (n){
k=n%10;
n/=10;
if (n)flag&=(k==9);
cnt++;
}
printf("%lld\n",(cnt-1)*9+(flag?k:k-1));
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You are given two positive integers d and s. Find minimal positive integer n which is divisible by d and has sum of digits equal to s.
Input
The first line contains two positive integers d and s (1 ≤ d ≤ 500, 1 ≤ s ≤ 5000) separated by space.
Output
Print the required number or -1 if it doesn't exist.
Examples
Input
13 50
Output
699998
Input
61 2
Output
1000000000000000000000000000001
Input
15 50
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int d, s;
bool vis[505][5005];
struct state {
int d, s;
string cur;
state(int d = 0, int s = 0, string cur = "") : d(d), s(s), cur(cur){};
};
void bfs() {
cin >> d >> s;
queue<state> q;
q.push(state(0, 0, ""));
vis[0][0] = true;
while (not q.empty()) {
state val = q.front();
q.pop();
if (val.s > s) continue;
if (val.d == 0 and val.s == s) {
cout << val.cur << "\n";
return;
}
for (int i = 0; i < 10; i++) {
int cur_d = (val.d * 10 + i) % d;
int cur_s = val.s + i;
if (!vis[cur_d][cur_s]) {
vis[cur_d][cur_s] = true;
q.push(state(cur_d, cur_s, val.cur + (char)(i + '0')));
}
}
}
cout << -1 << "\n";
}
int main() {
bfs();
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Given is an integer N. Find the number of digits that N has in base K.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^9
* 2 \leq K \leq 10
Input
Input is given from Standard Input in the following format:
N K
Output
Print the number of digits that N has in base K.
Examples
Input
11 2
Output
4
Input
1010101 10
Output
7
Input
314159265 3
Output
18
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n,k;
int main(){
cin>>n>>k;
int ans=0;
while (n){
n/=k;
ans++;
}
cout<<ans;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
On a number axis directed from the left rightwards, n marbles with coordinates x1, x2, ..., xn are situated. Let's assume that the sizes of the marbles are infinitely small, that is in this task each of them is assumed to be a material point. You can stick pins in some of them and the cost of sticking in the marble number i is equal to ci, number ci may be negative. After you choose and stick the pins you need, the marbles will start to roll left according to the rule: if a marble has a pin stuck in it, then the marble doesn't move, otherwise the marble rolls all the way up to the next marble which has a pin stuck in it and stops moving there. If there is no pinned marble on the left to the given unpinned one, it is concluded that the marble rolls to the left to infinity and you will pay an infinitely large fine for it. If no marble rolled infinitely to the left, then the fine will consist of two summands:
* the sum of the costs of stuck pins;
* the sum of the lengths of the paths of each of the marbles, that is the sum of absolute values of differences between their initial and final positions.
Your task is to choose and pin some marbles in the way that will make the fine for you to pay as little as possible.
Input
The first input line contains an integer n (1 ≤ n ≤ 3000) which is the number of marbles. The next n lines contain the descriptions of the marbles in pairs of integers xi, ci ( - 109 ≤ xi, ci ≤ 109). The numbers are space-separated. Each description is given on a separate line. No two marbles have identical initial positions.
Output
Output the single number — the least fine you will have to pay.
Examples
Input
3
2 3
3 4
1 2
Output
5
Input
4
1 7
3 1
5 10
6 1
Output
11
### Response
```cpp
#include <bits/stdc++.h>
bool debug = false;
using namespace std;
long long convertToNum(string s) {
long long val = 0;
for (int i = 0; i < (s.size()); i++) val = val * 10 + s[i] - '0';
return val;
}
string convertToString(long long a) {
string res = "";
if (!a) return "0";
while (a) {
res = (char)(a % 10 + 48) + res;
a /= 10;
}
return res;
}
long long GCD(long long x, long long y) {
if (!x) return y;
if (!y) return x;
if (x == y) return x;
if (x < y)
return GCD(x, y % x);
else
return GCD(x % y, y);
}
long long POW(long long x, long long y, long long Base) {
if (!y) return 1;
long long u = POW(x, y / 2, Base);
u = (u * u) % Base;
if (y & 1)
return (u * x) % Base;
else
return u;
}
const int Dice[24][6] = {
{1, 2, 3, 4, 5, 6}, {1, 6, 3, 5, 2, 4}, {1, 4, 3, 2, 6, 5},
{1, 5, 3, 6, 4, 2}, {2, 1, 4, 3, 6, 5}, {6, 1, 5, 3, 4, 2},
{5, 1, 6, 3, 2, 4}, {4, 1, 2, 3, 5, 6}, {3, 2, 1, 4, 6, 5},
{3, 5, 1, 6, 2, 4}, {3, 4, 1, 2, 5, 6}, {3, 6, 1, 5, 4, 2},
{2, 3, 4, 1, 5, 6}, {4, 3, 2, 1, 6, 5}, {5, 3, 6, 1, 4, 2},
{6, 3, 5, 1, 2, 4}, {2, 5, 4, 6, 1, 3}, {4, 6, 2, 5, 1, 3},
{5, 4, 6, 2, 1, 3}, {6, 2, 5, 4, 1, 3}, {2, 6, 4, 5, 3, 1},
{4, 5, 2, 6, 3, 1}, {5, 2, 6, 4, 3, 1}, {6, 4, 5, 2, 3, 1}};
const double eps = 1e-10;
double PI = acos(-1.0);
int cmp(double q, double w) {
return (q < w + eps) ? (q > w - eps) ? 0 : -1 : 1;
}
struct point {
double x, y;
point(double x, double y) : x(x), y(y) {}
point() { x = y = 0.0; }
point operator+(point q) { return point(x + q.x, y + q.y); }
point operator-(point q) { return point(x - q.x, y - q.y); }
point operator*(double t) { return point(x * t, y * t); }
point operator/(double t) { return point(x / t, y / t); }
double operator*(point q) { return q.x * x + q.y * y; }
double operator%(point q) { return x * q.y - y * q.x; }
int cmp(point q) const {
if (int t = ::cmp(x, q.x)) return t;
return ::cmp(y, q.y);
}
bool operator>(point q) const { return cmp(q) > 0; }
bool operator<(point q) const { return cmp(q) < 0; }
bool operator==(point q) const { return cmp(q) == 0; }
bool operator>=(point q) const { return cmp(q) >= 0; }
bool operator<=(point q) const { return cmp(q) <= 0; }
bool operator!=(point q) const { return cmp(q) != 0; }
};
pair<int, int> p[3004];
long long Sum[3004], n;
long long F[3004];
int main() {
cin >> n;
for (int i = (1); i <= (n); i++) cin >> p[i].first >> p[i].second;
sort(p + 1, p + n + 1);
long long limit = p[1].first;
p[n + 1] = make_pair(1000000003, 0);
for (int i = (1); i <= (n); i++) Sum[i] = Sum[i - 1] + p[i].first - limit;
F[1] = p[1].second;
for (int i = (2); i <= (n + 1); i++) {
F[i] = 1000000000000000LL;
for (int j = (i - 1); j >= (1); j--) {
long long cost = Sum[i - 1] - Sum[j];
int sl = i - j - 1;
cost = cost - sl * (p[j].first - limit);
F[i] = min(F[i], F[j] + cost + p[i].second);
}
}
cout << F[n + 1] << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ans, n, k, i, x;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
k = k + x;
}
for (i = 1; i <= 5; i++)
if ((k + i - 1) % (n + 1)) ans++;
cout << ans;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
This is the easy version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 3n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 1000) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 1000.
Output
For each test case, output an integer k (0≤ k≤ 3n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string a, b;
cin >> a;
cin >> b;
vector<long long int> ans;
for (long long int i = n - 1; i >= 1; i--) {
if (a[i] != b[i]) {
ans.push_back(i + 1);
ans.push_back(1);
ans.push_back(i + 1);
}
}
if (a[0] != b[0]) ans.push_back(1);
cout << ans.size() << " ";
for (auto i : ans) {
cout << i << " ";
}
cout << '\n';
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Nauuo is a girl who loves playing chess.
One day she invented a game by herself which needs n chess pieces to play on a m× m chessboard. The rows and columns are numbered from 1 to m. We denote a cell on the intersection of the r-th row and c-th column as (r,c).
The game's goal is to place n chess pieces numbered from 1 to n on the chessboard, the i-th piece lies on (r_i,\,c_i), while the following rule is satisfied: for all pairs of pieces i and j, |r_i-r_j|+|c_i-c_j|≥|i-j|. Here |x| means the absolute value of x.
However, Nauuo discovered that sometimes she couldn't find a solution because the chessboard was too small.
She wants to find the smallest chessboard on which she can put n pieces according to the rules.
She also wonders how to place the pieces on such a chessboard. Can you help her?
Input
The only line contains a single integer n (1≤ n≤ 1000) — the number of chess pieces for the game.
Output
The first line contains a single integer — the minimum value of m, where m is the length of sides of the suitable chessboard.
The i-th of the next n lines contains two integers r_i and c_i (1≤ r_i,c_i≤ m) — the coordinates of the i-th chess piece.
If there are multiple answers, print any.
Examples
Input
2
Output
2
1 1
1 2
Input
4
Output
3
1 1
1 3
3 1
3 3
Note
In the first example, you can't place the two pieces on a 1×1 chessboard without breaking the rule. But you can place two pieces on a 2×2 chessboard like this:
<image>
In the second example, you can't place four pieces on a 2×2 chessboard without breaking the rule. For example, if you place the pieces like this:
<image>
then |r_1-r_3|+|c_1-c_3|=|1-2|+|1-1|=1, |1-3|=2, 1<2; and |r_1-r_4|+|c_1-c_4|=|1-2|+|1-2|=2, |1-4|=3, 2<3. It doesn't satisfy the rule.
However, on a 3×3 chessboard, you can place four pieces like this:
<image>
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int s = n / 2 + 1;
printf("%d\n", s);
printf("1 1\n");
int l = 1, r = 2;
for (int i = 2; i <= n; i++) {
printf("%d %d\n", l, r);
if (l < r)
l++;
else
r++;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
In this problem, your task is to use ASCII graphics to paint a cardiogram.
A cardiogram is a polyline with the following corners:
<image>
That is, a cardiogram is fully defined by a sequence of positive integers a1, a2, ..., an.
Your task is to paint a cardiogram by given sequence ai.
Input
The first line contains integer n (2 ≤ n ≤ 1000). The next line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 1000). It is guaranteed that the sum of all ai doesn't exceed 1000.
Output
Print max |yi - yj| lines (where yk is the y coordinate of the k-th point of the polyline), in each line print <image> characters. Each character must equal either « / » (slash), « \ » (backslash), « » (space). The printed image must be the image of the given polyline. Please study the test samples for better understanding of how to print a cardiogram.
Note that in this problem the checker checks your answer taking spaces into consideration. Do not print any extra characters. Remember that the wrong answer to the first pretest doesn't give you a penalty.
Examples
Input
5
3 1 2 5 1
Output
<span class="tex-span"> / </span><span class="tex-span">\</span>
<span class="tex-span"> / </span><span class="tex-span">\</span><span class="tex-span"> / </span> <span class="tex-span">\</span>
<span class="tex-span"> / </span> <span class="tex-span">\</span>
<span class="tex-span"> / </span> <span class="tex-span">\</span>
<span class="tex-span">\</span><span class="tex-span"> / </span>
Input
3
1 5 1
Output
<span class="tex-span"> / </span><span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span><span class="tex-span"> / </span>
Note
Due to the technical reasons the answers for the samples cannot be copied from the statement. We've attached two text documents with the answers below.
http://assets.codeforces.com/rounds/435/1.txt
http://assets.codeforces.com/rounds/435/2.txt
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
void Error(string err) {
cout << err;
cerr << err;
while (1)
;
}
int main() {
int n, arr[1010];
pair<int, int> p[1010];
cin >> n;
for (int i = (0); i < (n); i++) cin >> arr[i];
p[0].first = p[0].second = 0;
bool pos = true;
int mx = 0, mn = 0;
for (int i = (0); i < (n); i++) {
p[i + 1].first = p[i].first + arr[i];
if (pos)
p[i + 1].second = p[i].second + arr[i];
else
p[i + 1].second = p[i].second - arr[i];
pos = !pos;
mx = max(mx, p[i + 1].second);
mn = min(mn, p[i + 1].second);
}
vector<string> v;
v.resize(mx - mn);
for (int i = (0); i < (p[n].first); i++) v[0] += ' ';
for (int i = (1); i < (v.size()); i++) v[i] = v[0];
for (int i = 1; i <= n; i++) {
pair<int, int> last_pnt = p[i - 1], nw_pnt = p[i];
if (last_pnt.second > nw_pnt.second)
for (int j = last_pnt.first; j < nw_pnt.first; j++)
v[mx - last_pnt.second + (j - last_pnt.first)][j] = '\\';
else
for (int j = last_pnt.first; j < nw_pnt.first; j++)
v[-1 + mx - last_pnt.second - (j - last_pnt.first)][j] = '/';
}
for (int i = (0); i < (v.size()); i++) cout << v[i] << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Today is Devu's birthday. For celebrating the occasion, he bought n sweets from the nearby market. He has invited his f friends. He would like to distribute the sweets among them. As he is a nice guy and the occasion is great, he doesn't want any friend to be sad, so he would ensure to give at least one sweet to each friend.
He wants to celebrate it in a unique style, so he would like to ensure following condition for the distribution of sweets. Assume that he has distributed n sweets to his friends such that ith friend is given ai sweets. He wants to make sure that there should not be any positive integer x > 1, which divides every ai.
Please find the number of ways he can distribute sweets to his friends in the required way. Note that the order of distribution is important, for example [1, 2] and [2, 1] are distinct distributions. As the answer could be very large, output answer modulo 1000000007 (109 + 7).
To make the problem more interesting, you are given q queries. Each query contains an n, f pair. For each query please output the required number of ways modulo 1000000007 (109 + 7).
Input
The first line contains an integer q representing the number of queries (1 ≤ q ≤ 105). Each of the next q lines contains two space space-separated integers n, f (1 ≤ f ≤ n ≤ 105).
Output
For each query, output a single integer in a line corresponding to the answer of each query.
Examples
Input
5
6 2
7 2
6 3
6 4
7 4
Output
2
6
9
10
20
Note
For first query: n = 6, f = 2. Possible partitions are [1, 5] and [5, 1].
For second query: n = 7, f = 2. Possible partitions are [1, 6] and [2, 5] and [3, 4] and [4, 3] and [5, 3] and [6, 1]. So in total there are 6 possible ways of partitioning.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
long long fac[100010], revfac[100010];
long long pow(long long a, int k) {
if (!k) return 1;
long long ans = pow(a, k >> 1);
ans = ans * ans % 1000000007;
if (k & 1) ans = ans * a % 1000000007;
return ans;
}
long long H(int n, int f) {
if (n < f) return 0;
return fac[n - 1] * revfac[n - f] % 1000000007 * revfac[f - 1] % 1000000007;
}
long long val[100010];
int calc(int n, int f) {
if (f == 1) return n == 1;
long long ans = H(n, f);
for (int i = 0, sz = adj[n].size(); i < sz; i++) {
int d = adj[n][i];
if (d < f) {
val[d] = 0;
continue;
}
val[d] = H(d, f);
for (int j = adj[d].size(); j--;) {
int dd = adj[d][j];
val[d] -= val[dd];
}
val[d] %= 1000000007;
if (val[d] < 0) val[d] += 1000000007;
ans -= val[d];
}
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
return ans;
}
void pre() {
fac[0] = revfac[0] = 1;
for (int i = 1; i < 100010; i++) {
fac[i] = fac[i - 1] * i % 1000000007;
revfac[i] = pow(fac[i], 1000000007 - 2);
}
for (int i = 2, j; i < 100010; i++) {
for (j = 2; j * j < i; j++) {
if (i % j == 0) adj[i].push_back(j);
}
if (j * j == i) adj[i].push_back(j);
for (j--; j > 1; j--) {
if (i % j == 0) adj[i].push_back(i / j);
}
}
}
int main() {
pre();
int q, n, f;
cin >> q;
while (q--) {
scanf("%d %d", &n, &f);
printf("%d\n", calc(n, f));
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are working for an administration office of the International Center for Picassonian Cubism (ICPC), which plans to build a new art gallery for young artists. The center is organizing an architectural design competition to find the best design for the new building.
Submitted designs will look like a screenshot of a well known game as shown below.
<image>
This is because the center specifies that the building should be constructed by stacking regular units called pieces, each of which consists of four cubic blocks. In addition, the center requires the competitors to submit designs that satisfy the following restrictions.
* All the pieces are aligned. When two pieces touch each other, the faces of the touching blocks must be placed exactly at the same position.
* All the pieces are stable. Since pieces are merely stacked, their centers of masses must be carefully positioned so as not to collapse.
* The pieces are stacked in a tree-like form in order to symbolize boundless potentiality of young artists. In other words, one and only one piece touches the ground, and each of other pieces touches one and only one piece on its bottom faces.
* The building has a flat shape. This is because the construction site is a narrow area located between a straight moat and an expressway where no more than one block can be placed between the moat and the expressway as illustrated below.
<image>
It will take many days to fully check stability of designs as it requires complicated structural calculation. Therefore, you are asked to quickly check obviously unstable designs by focusing on centers of masses. The rules of your quick check are as follows.
Assume the center of mass of a block is located at the center of the block, and all blocks have the same weight. We denote a location of a block by xy-coordinates of its left-bottom corner. The unit length is the edge length of a block.
Among the blocks of the piece that touch another piece or the ground on their bottom faces, let xL be the leftmost x-coordinate of the leftmost block, and let xR be the rightmost x-coordinate of the rightmost block. Let the x-coordinate of its accumulated center of mass of the piece be M, where the accumulated center of mass of a piece P is the center of the mass of the pieces that are directly and indirectly supported by P, in addition to P itself. Then the piece is stable, if and only if xL < M < xR. Otherwise, it is unstable. A design of a building is unstable if any of its pieces is unstable.
Note that the above rules could judge some designs to be unstable even if it would not collapse in reality. For example, the left one of the following designs shall be judged to be unstable.
<image> | | <image>
---|---|---
Also note that the rules judge boundary cases to be unstable. For example, the top piece in the above right design has its center of mass exactly above the right end of the bottom piece. This shall be judged to be unstable.
Write a program that judges stability of each design based on the above quick check rules.
Input
The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. Each dataset, which represents a front view of a building, is formatted as follows.
> w h
> p0(h-1)p1(h-1)...p(w-1)(h-1)
> ...
> p01p11...p(w-1)1
> p00p10...p(w-1)0
>
The integers w and h separated by a space are the numbers of columns and rows of the layout, respectively. You may assume 1 ≤ w ≤ 10 and 1 ≤ h ≤ 60. The next h lines specify the placement of the pieces. The character pxy indicates the status of a block at (x,y), either ``.`', meaning empty, or one digit character between ``1`' and ``9`', inclusive, meaning a block of a piece. (As mentioned earlier, we denote a location of a block by xy-coordinates of its left-bottom corner.)
When two blocks with the same number touch each other by any of their top, bottom, left or right face, those blocks are of the same piece. (Note that there might be two different pieces that are denoted by the same number.) The bottom of a block at (x,0) touches the ground.
You may assume that the pieces in each dataset are stacked in a tree-like form.
Output
For each dataset, output a line containing a word `STABLE` when the design is stable with respect to the above quick check rules. Otherwise, output `UNSTABLE`. The output should be written with uppercase letters, and should not contain any other extra characters.
Sample Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output for the Sample Input
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
Example
Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
char field[100][100];
bool visited[100][100];
int W, H;
int tx[] = {1, 0, -1, 0};
int ty[] = {0, -1, 0, 1};
struct Tree {
int lx, rx;
int block[15];
vector<Tree> child;
Tree () {
fill(block, block + 15, 0);
}
Tree(int rx, int ry, vector<Tree> child) : lx(lx), rx(rx), child(child) {
fill(block, block + 15, 0);
}
void print() {
printf("lx, rx = %d, %d\n", lx, rx);
for (int i = 0; i < child.size(); i++) {
child[i].print();
}
}
int num(int idx) {
int n = 0;
for (int i = 0; i < child.size(); i++) {
n += child[i].num(idx);
}
n += block[idx];
return n;
}
int numChild() {
int n = 0;
for (int i = 0; i < child.size(); i++) {
n += child[i].numChild();
}
return n + 1;
}
};
typedef pair<int, int> P;
typedef pair<Tree, bool> Res;
void init() {
fill(&field[0][0], &field[99][100], '!');
fill(&visited[0][0], &visited[99][100], false);
}
Res search(char c, int cx, int cy, bool isBottom) {
//printf("called\n");
//printf("%c, %d, %d\n", c, cx, cy);
queue<P> Q;
Q.push(P(cx, cy));
Tree t;
vector<P> next;
t.lx = cx, t.rx = cx;
bool p = false;
while (!Q.empty()) {
P cur = Q.front();
Q.pop();
int x = cur.first;
int y = cur.second;
if (visited[y][x] || field[y][x] != c) {
continue;
}
p = true;
//printf("%d %d\n", x, y);
visited[y][x] = true;
t.block[x]++;
if (field[y - 1][x] != '.' && field[y - 1][x] != '!' && field[y - 1][x] != c) {
next.push_back(P(x, y - 1));
//printf("%d, %d\n", x, y - 1);
}
if (!isBottom && field[y + 1][x] != '.' && field[y + 1][x] != '!' && field[y + 1][x] != c) {
t.lx = min(t.lx, x);
t.rx = max(t.rx, x);
}
if (isBottom && field[y + 1][x] == '!') {
t.lx = min(t.lx, x);
t.rx = max(t.rx, x);
}
for (int i = 0; i < 4; i++) {
int nx = x + tx[i];
int ny = y + ty[i];
if (field[ny][nx] == c && !visited[ny][nx]) {
Q.push(P(nx, ny));
}
}
}
if (!p) {
return Res(Tree(), false);
}
for (int i = 0; i < next.size(); i++) {
int x = next[i].first;
int y = next[i].second;
Res res = search(field[y][x], x, y, false);
if (res.second) {
t.child.push_back(res.first);
}
}
return Res(t, true);
}
Tree make_tree() {
for (int i = H; i >= 1; i--) {
for (int j = 1; j <= W; j++) {
if (field[i][j] != '.') {
char c = field[i][j];
Res r = search(c, j, i, true);
Tree t = r.first;
return t;
}
}
}
}
bool check(Tree t) {
if (t.child.size() == 0) {
double g = 0.0;
for (int i = 1; i <= W; i++) {
g += t.block[i] * (i - 0.5);
}
g /= 4;
// printf("g = %lf\n", g);
if (t.lx - 1 < g && g < t.rx) {
return true;
} else {
return false;
}
}
for (int i = 0; i < t.child.size(); i++) {
if (!check(t.child[i])) {
return false;
}
}
double g = 0;
for (int i = 1; i <= W; i++) {
g += (i - 0.5) * t.num(i);
}
g /= (4 * (t.numChild()));
//printf("G = %lf\n", g);
if (t.lx - 1 < g && g < t.rx) {
return true;
} else {
return false;
}
}
void solve() {
Tree t = make_tree();
//t.print();
if (check(t)) {
printf("STABLE\n");
} else {
printf("UNSTABLE\n");
}
}
int main() {
while (true) {
scanf("%d %d ", &W, &H);
init();
if (W == 0 && H == 0) {
return 0;
}
for (int i = 1; i <= H; i++) {
for (int j = 1; j <= W; j++) {
scanf("%c ", &field[i][j]);
}
}
solve();
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a rectangular table 3 × n. Each cell contains an integer. You can move from one cell to another if they share a side.
Find such path from the upper left cell to the bottom right cell of the table that doesn't visit any of the cells twice, and the sum of numbers written in the cells of this path is maximum possible.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of columns in the table.
Next three lines contain n integers each — the description of the table. The j-th number in the i-th line corresponds to the cell aij ( - 109 ≤ aij ≤ 109) of the table.
Output
Output the maximum sum of numbers on a path from the upper left cell to the bottom right cell of the table, that doesn't visit any of the cells twice.
Examples
Input
3
1 1 1
1 -1 1
1 1 1
Output
7
Input
5
10 10 10 -1 -1
-1 10 10 10 10
-1 10 10 10 10
Output
110
Note
The path for the first example:
<image>
The path for the second example:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
long long a[N][4], dp[N][4], bk[N][4];
int main() {
scanf("%d", &n);
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= n; j++) scanf("%lld", &a[j][i]);
for (int i = 1; i <= 3; i++)
dp[1][i] = dp[1][i - 1] + a[1][i], bk[1][i] = a[1][i];
for (int i = 2; i <= n; i++) {
dp[i][1] = bk[i][1] = dp[i - 1][1] + a[i][1];
dp[i][2] = bk[i][2] = dp[i - 1][2] + a[i][2];
dp[i][3] = bk[i][3] = dp[i - 1][3] + a[i][3];
dp[i][1] = max(dp[i][1], bk[i][2] + a[i][1]);
dp[i][1] = max(dp[i][1], bk[i][3] + a[i][2] + a[i][1]);
dp[i][2] = max(dp[i][2], bk[i][1] + a[i][2]);
dp[i][2] = max(dp[i][2], bk[i][3] + a[i][2]);
dp[i][3] = max(dp[i][3], bk[i][2] + a[i][3]);
dp[i][3] = max(dp[i][3], bk[i][1] + a[i][2] + a[i][3]);
dp[i][1] = max(dp[i][1], bk[i - 1][3] + a[i][3] + a[i][2] + a[i - 1][2] +
a[i - 1][1] + a[i][1]);
dp[i][3] = max(dp[i][3], bk[i - 1][1] + a[i][1] + a[i][2] + a[i - 1][2] +
a[i - 1][3] + a[i][3]);
}
printf("%lld\n", dp[n][3]);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given a string S of length N consisting of `A`, `C`, `G` and `T`. Answer the following Q queries:
* Query i (1 \leq i \leq Q): You will be given integers l_i and r_i (1 \leq l_i < r_i \leq N). Consider the substring of S starting at index l_i and ending at index r_i (both inclusive). In this string, how many times does `AC` occurs as a substring?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq Q \leq 10^5
* S is a string of length N.
* Each character in S is `A`, `C`, `G` or `T`.
* 1 \leq l_i < r_i \leq N
Input
Input is given from Standard Input in the following format:
N Q
S
l_1 r_1
:
l_Q r_Q
Output
Print Q lines. The i-th line should contain the answer to the i-th query.
Example
Input
8 3
ACACTACG
3 7
2 3
1 8
Output
2
0
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main(){
int n,q;
cin >> n >> q;
string S;
cin >> S;
for(int i=1;i<n;i++){
a[i+1]+=a[i];
if(S[i-1]=='A' && S[i]=='C')a[i+1]++;
}
int l,r;
for(int i=0;i<q;i++){
cin >> l >> r;
cout << a[r]-a[l] << endl;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The organizers of a programming contest have decided to present t-shirts to participants. There are six different t-shirts sizes in this problem: S, M, L, XL, XXL, XXXL (sizes are listed in increasing order). The t-shirts are already prepared. For each size from S to XXXL you are given the number of t-shirts of this size.
During the registration, the organizers asked each of the n participants about the t-shirt size he wants. If a participant hesitated between two sizes, he could specify two neighboring sizes — this means that any of these two sizes suits him.
Write a program that will determine whether it is possible to present a t-shirt to each participant of the competition, or not. Of course, each participant should get a t-shirt of proper size:
* the size he wanted, if he specified one size;
* any of the two neibouring sizes, if he specified two sizes.
If it is possible, the program should find any valid distribution of the t-shirts.
Input
The first line of the input contains six non-negative integers — the number of t-shirts of each size. The numbers are given for the sizes S, M, L, XL, XXL, XXXL, respectively. The total number of t-shirts doesn't exceed 100 000.
The second line contains positive integer n (1 ≤ n ≤ 100 000) — the number of participants.
The following n lines contain the sizes specified by the participants, one line per participant. The i-th line contains information provided by the i-th participant: single size or two sizes separated by comma (without any spaces). If there are two sizes, the sizes are written in increasing order. It is guaranteed that two sizes separated by comma are neighboring.
Output
If it is not possible to present a t-shirt to each participant, print «NO» (without quotes).
Otherwise, print n + 1 lines. In the first line print «YES» (without quotes). In the following n lines print the t-shirt sizes the orginizers should give to participants, one per line. The order of the participants should be the same as in the input.
If there are multiple solutions, print any of them.
Examples
Input
0 1 0 1 1 0
3
XL
S,M
XL,XXL
Output
YES
XL
M
XXL
Input
1 1 2 0 1 1
5
S
M
S,M
XXL,XXXL
XL,XXL
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
int r[6];
map<string, int> c;
map<int, string> cc;
bool vis[N];
vector<pair<int, int> > w[6];
int ans[N];
int main() {
c["S"] = 0;
c["M"] = 1;
c["L"] = 2;
c["XL"] = 3;
c["XXL"] = 4;
c["XXXL"] = 5;
cc[0] = "S";
cc[1] = "M";
cc[2] = "L";
cc[3] = "XL";
cc[4] = "XXL";
cc[5] = "XXXL";
for (int i = 0, ttto = 6; i < ttto; i++) cin >> r[i];
int n, f = 1;
cin >> n;
for (int i = 0, ttto = n; i < ttto; i++) {
string s, t;
cin >> s;
int p = s.find(",");
if (p != string::npos) t = s.substr(p + 1, s.size());
if (p == string::npos) {
r[c[s]]--;
vis[i] = 1;
ans[i] = c[s];
if (r[c[s]] < 0) f = 0;
} else {
s = s.substr(0, p);
int u = c[s], v = c[t];
if (u > v) swap(u, v);
w[u].push_back(pair<int, int>(1, i));
w[v].push_back(pair<int, int>(0, i));
}
}
if (f == 0)
puts("NO");
else {
for (int i = 0, ttto = 6; i < ttto; i++) {
sort(w[i].begin(), w[i].end());
for (int j = 0, ttto = w[i].size(); j < ttto; j++)
if (!vis[w[i][j].second] && r[i])
ans[w[i][j].second] = i, vis[w[i][j].second] = 1, r[i]--;
}
for (int i = 0, ttto = n; i < ttto; i++)
if (!vis[i]) {
cerr << i << endl;
puts("NO");
return 0;
}
puts("YES");
for (int i = 0, ttto = n; i < ttto; i++) cout << cc[ans[i]] << "\n";
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
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;
int main() {
int n, x;
cin >> n;
map<int, int> A;
map<int, int>::iterator it;
for (int i = 0; i < (n); i++) {
cin >> x;
if (x == 0) continue;
A[x]++;
}
bool possible = 1;
int twoc = 0;
for (it = A.begin(); it != A.end(); it++) {
if (it->second > 2) {
possible = 0;
break;
} else if (it->second == 2)
twoc++;
}
if (possible)
cout << twoc << endl;
else
cout << -1 << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Recently Anton found a box with digits in his room. There are k2 digits 2, k3 digits 3, k5 digits 5 and k6 digits 6.
Anton's favorite integers are 32 and 256. He decided to compose this integers from digits he has. He wants to make the sum of these integers as large as possible. Help him solve this task!
Each digit can be used no more than once, i.e. the composed integers should contain no more than k2 digits 2, k3 digits 3 and so on. Of course, unused digits are not counted in the sum.
Input
The only line of the input contains four integers k2, k3, k5 and k6 — the number of digits 2, 3, 5 and 6 respectively (0 ≤ k2, k3, k5, k6 ≤ 5·106).
Output
Print one integer — maximum possible sum of Anton's favorite integers that can be composed using digits from the box.
Examples
Input
5 1 3 4
Output
800
Input
1 1 1 1
Output
256
Note
In the first sample, there are five digits 2, one digit 3, three digits 5 and four digits 6. Anton can compose three integers 256 and one integer 32 to achieve the value 256 + 256 + 256 + 32 = 800. Note, that there is one unused integer 2 and one unused integer 6. They are not counted in the answer.
In the second sample, the optimal answer is to create on integer 256, thus the answer is 256.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
long long k[5], maxi = 0, mini, i;
scanf("%I64d %I64d %I64d %I64d", &k[1], &k[2], &k[3], &k[4]);
mini = (long long)pow(10, 7);
for (i = 1; i <= 4; i++) {
if (i != 2 && k[i] < mini) {
mini = k[i];
}
}
maxi = maxi + (mini * 256);
k[1] = k[1] - mini;
if (k[1] >= k[2])
mini = k[2];
else
mini = k[1];
maxi += mini * 32;
printf("%I64d", maxi);
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You have a positive integer m and a non-negative integer s. Your task is to find the smallest and the largest of the numbers that have length m and sum of digits s. The required numbers should be non-negative integers written in the decimal base without leading zeroes.
Input
The single line of the input contains a pair of integers m, s (1 ≤ m ≤ 100, 0 ≤ s ≤ 900) — the length and the sum of the digits of the required numbers.
Output
In the output print the pair of the required non-negative integer numbers — first the minimum possible number, then — the maximum possible number. If no numbers satisfying conditions required exist, print the pair of numbers "-1 -1" (without the quotes).
Examples
Input
2 15
Output
69 96
Input
3 0
Output
-1 -1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, s;
cin >> m >> s;
int scopy = s;
string min = "";
string max = "";
if (m == 1 && s == 0) {
cout << "0 0";
return 0;
}
if ((s < 1 && m > 0) || s > m * 9) {
cout << "-1 -1";
return 0;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= 9; j++) {
if (i == 1 && j == 0) j = 1;
if (j + ((m - i) * 9) >= s) {
min += to_string(j);
s -= j;
break;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 9; j >= 0; j--) {
if (j <= scopy) {
max += to_string(j);
scopy -= j;
break;
}
}
}
cout << min << ' ' << max;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Let's arrange a deck of cards. There are totally 36 cards of 4 suits(S, H, C, D) and 9 values (1, 2, ... 9). For example, 'eight of heart' is represented by H8 and 'one of diamonds' is represented by D1.
Your task is to write a program which sorts a given set of cards in ascending order by their values using the Bubble Sort algorithms and the Selection Sort algorithm respectively. These algorithms should be based on the following pseudocode:
BubbleSort(C)
1 for i = 0 to C.length-1
2 for j = C.length-1 downto i+1
3 if C[j].value < C[j-1].value
4 swap C[j] and C[j-1]
SelectionSort(C)
1 for i = 0 to C.length-1
2 mini = i
3 for j = i to C.length-1
4 if C[j].value < C[mini].value
5 mini = j
6 swap C[i] and C[mini]
Note that, indices for array elements are based on 0-origin.
For each algorithm, report the stability of the output for the given input (instance). Here, 'stability of the output' means that: cards with the same value appear in the output in the same order as they do in the input (instance).
Constraints
1 ≤ N ≤ 36
Input
The first line contains an integer N, the number of cards.
N cards are given in the following line. Each card is represented by two characters. Two consecutive cards are separated by a space character.
Output
In the first line, print the arranged cards provided by the Bubble Sort algorithm. Two consecutive cards should be separated by a space character.
In the second line, print the stability ("Stable" or "Not stable") of this output.
In the third line, print the arranged cards provided by the Selection Sort algorithm. Two consecutive cards should be separated by a space character.
In the fourth line, print the stability ("Stable" or "Not stable") of this output.
Examples
Input
5
H4 C9 S4 D2 C3
Output
D2 C3 H4 S4 C9
Stable
D2 C3 S4 H4 C9
Not stable
Input
2
S1 H1
Output
S1 H1
Stable
S1 H1
Stable
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main(){
int N;
string c1[36], c2[36];
cin >> N;
for(int i=0;i<N;i++) cin >> c1[i];
for(int i=0;i<N;i++) c2[i]=c1[i];
for(int i=0;i<N;i++){
for(int j=N-1;j>i;j--){
if(c1[j][1]<c1[j-1][1]){
string tmp=c1[j];
c1[j]=c1[j-1];
c1[j-1]=tmp;
}
}
}
for(int i=0;i<N;i++){
int minj = i;
for(int j=i;j<N;j++){
if(c2[j][1]<c2[minj][1]) minj=j;
}
string tmp=c2[i];
c2[i]=c2[minj];
c2[minj]=tmp;
}
cout << c1[0];
for(int i=1;i<N;i++) cout << ' ' << c1[i];
cout << endl << "Stable" << endl;
cout << c2[0];
for(int i=1;i<N;i++) cout << ' ' << c2[i];
cout << endl;
bool isStable=true;
for(int i=0;i<N;i++){
if(c1[i]!=c2[i]) isStable=false;
}
cout << (isStable?"Stable":"Not stable") << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 101;
char s[N];
int dp[2][N << 1][N][55];
int abs(int a) { return a > 0 ? a : -a; }
int max(int a, int b) { return a > b ? a : b; }
int dfs(int f, int d, int i, int n) {
if (!s[i] || n < 0) return n ? 0 : abs(d);
int &ret = dp[f][d + 100][i][n];
if (ret != -1) return ret;
int mv = f ? 1 : -1;
return ret = max(dfs(f, d + mv, i + 1, n - (s[i] != 'F')),
dfs(!f, d, i + 1, n - (s[i] != 'T')));
}
int main() {
int n, ans = 0;
scanf("%s%d", s, &n);
memset(dp, -1, sizeof(dp));
for (; n >= 0; n -= 2) ans = max(ans, dfs(1, 0, 0, n));
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Vus the [Cossack](https://en.wikipedia.org/wiki/Cossacks) holds a programming competition, in which n people participate. He decided to award them all with pens and notebooks. It is known that Vus has exactly m pens and k notebooks.
Determine whether the Cossack can reward all participants, giving each of them at least one pen and at least one notebook.
Input
The first line contains three integers n, m, and k (1 ≤ n, m, k ≤ 100) — the number of participants, the number of pens, and the number of notebooks respectively.
Output
Print "Yes" if it possible to reward all the participants. Otherwise, print "No".
You can print each letter in any case (upper or lower).
Examples
Input
5 8 6
Output
Yes
Input
3 9 3
Output
Yes
Input
8 5 20
Output
No
Note
In the first example, there are 5 participants. The Cossack has 8 pens and 6 notebooks. Therefore, he has enough pens and notebooks.
In the second example, there are 3 participants. The Cossack has 9 pens and 3 notebooks. He has more than enough pens but only the minimum needed number of notebooks.
In the third example, there are 8 participants but only 5 pens. Since the Cossack does not have enough pens, the answer is "No".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, i, j;
cin >> a >> b >> c;
if (b >= a && c >= a)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, j, n, i;
scanf("%d", &n);
int a[103] = {0}, cnt = 0;
int f, s, mx = 0;
for (int i = (int)0; i < (int)n; i++) {
scanf("%d", &l);
scanf("%d", &r);
mx = max(mx, r);
if (i == 0) {
f = l;
s = r;
cnt = r - l;
continue;
}
for (j = l + 1; j <= r; j++) a[j] = 1;
}
for (i = f + 1; i <= s; i++) {
if (a[i] == 1) cnt--;
}
printf("%d\n", max(cnt, 0));
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given an undirected graph consisting of n vertices and m edges. Initially there is a single integer written on every vertex: the vertex i has p_i written on it. All p_i are distinct integers from 1 to n.
You have to process q queries of two types:
* 1 v — among all vertices reachable from the vertex v using the edges of the graph (including the vertex v itself), find a vertex u with the largest number p_u written on it, print p_u and replace p_u with 0;
* 2 i — delete the i-th edge from the graph.
Note that, in a query of the first type, it is possible that all vertices reachable from v have 0 written on them. In this case, u is not explicitly defined, but since the selection of u does not affect anything, you can choose any vertex reachable from v and print its value (which is 0).
Input
The first line contains three integers n, m and q (1 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ m ≤ 3 ⋅ 10^5; 1 ≤ q ≤ 5 ⋅ 10^5).
The second line contains n distinct integers p_1, p_2, ..., p_n, where p_i is the number initially written on vertex i (1 ≤ p_i ≤ n).
Then m lines follow, the i-th of them contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) and means that the i-th edge connects vertices a_i and b_i. It is guaranteed that the graph does not contain multi-edges.
Then q lines follow, which describe the queries. Each line is given by one of the following formats:
* 1 v — denotes a query of the first type with a vertex v (1 ≤ v ≤ n).
* 2 i — denotes a query of the second type with an edge i (1 ≤ i ≤ m). For each query of the second type, it is guaranteed that the corresponding edge is not deleted from the graph yet.
Output
For every query of the first type, print the value of p_u written on the chosen vertex u.
Example
Input
5 4 6
1 2 5 4 3
1 2
2 3
1 3
4 5
1 1
2 1
2 3
1 1
1 2
1 2
Output
5
1
2
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int f[N], sz[N], hed[N], ed, n, m, Q, id[N], opt[N], a[N], u[N], v[N], del[N],
p[N];
set<pair<int, int> > s[N];
bool ban[N];
struct edge {
int to, nex;
bool vis;
edge(int _ = 0, int __ = 0) : to(_), nex(__), vis(0) {}
} e[N << 1];
inline void add(int u, int v) {
e[++ed] = edge(v, hed[u]);
hed[u] = ed;
}
int gfa(int x) { return f[x] ^ x ? (f[x] = gfa(f[x])) : x; }
void merge(int u, int v) {
u = gfa(u);
v = gfa(v);
if (sz[u] >= sz[v]) swap(u, v);
f[u] = v;
sz[v] += sz[u];
}
void dfs(int u, int fa, int x, int y) {
f[u] = x;
s[y].erase(make_pair(a[u], u));
s[x].insert(make_pair(a[u], u));
for (int i = hed[u], v = e[i].to; i; i = e[i].nex, v = e[i].to)
if ((v ^ fa) && !e[i].vis) dfs(v, u, x, y);
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
ed = 1;
for (int i = (1); i <= (n); ++i) scanf("%d", a + i), f[i] = i, sz[i] = 1;
for (int i = (1); i <= (m); ++i) scanf("%d%d", u + i, v + i);
for (int i = (1); i <= (Q); ++i) scanf("%d%d", opt + i, id + i);
for (int i = (1); i <= (Q); ++i)
if (opt[i] == 2) ban[id[i]] = 1;
for (int i = (1); i <= (m); ++i)
if (gfa(u[i]) ^ gfa(v[i]) && !ban[i])
merge(u[i], v[i]), add(u[i], v[i]), add(v[i], u[i]);
for (int i = (Q); i >= (1); --i)
if (opt[i] == 2 && (gfa(u[id[i]]) ^ gfa(v[id[i]]))) {
int x = gfa(u[id[i]]), y = gfa(v[id[i]]);
add(u[id[i]], v[id[i]]), add(v[id[i]], u[id[i]]);
del[i] = sz[x] < sz[y] ? ed : ed - 1;
p[i] = sz[x] < sz[y] ? x : y;
merge(x, y);
}
for (int i = (1); i <= (n); ++i) s[gfa(i)].insert(make_pair(a[i], i));
for (int i = (1); i <= (Q); ++i) {
if (opt[i] == 1) {
int u = gfa(id[i]), x = s[u].rbegin()->second;
printf("%d\n", a[x]);
a[x] = 0;
s[u].erase(*s[u].rbegin());
s[u].insert(make_pair(0, x));
} else if (del[i]) {
int x = e[del[i]].to;
e[del[i]].vis = e[del[i] ^ 1].vis = 1;
dfs(x, 0, p[i], gfa(x));
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Vasya collects coins: he has exactly one coin for every year from 1 to n. Naturally, Vasya keeps all the coins in his collection in the order in which they were released. Once Vasya's younger brother made a change — he took all the coins whose release year dated from l to r inclusively and put them in the reverse order. That is, he took a certain segment [l, r] and reversed it. At that the segment's endpoints did not coincide. For example, if n = 8, then initially Vasya's coins were kept in the order 1 2 3 4 5 6 7 8. If Vasya's younger brother chose the segment [2, 6], then after the reversal the coin order will change to 1 6 5 4 3 2 7 8. Vasya suspects that someone else could have spoilt the permutation after his brother. Help him to find that out. Check if the given permutation can be obtained from the permutation 1 2 ... n using exactly one segment reversal. If it is possible, find the segment itself.
Input
The first line contains an integer n (1 ≤ n ≤ 1000) which is the number of coins in Vasya's collection. The second line contains space-separated n integers which are the spoilt sequence of coins. It is guaranteed that the given sequence is a permutation, i.e. it contains only integers from 1 to n, and every number is used exactly 1 time.
Output
If it is impossible to obtain the given permutation from the original one in exactly one action, print 0 0. Otherwise, print two numbers l r (1 ≤ l < r ≤ n) which are the endpoints of the segment that needs to be reversed to obtain from permutation 1 2 ... n the given one.
Examples
Input
8
1 6 5 4 3 2 7 8
Output
2 6
Input
4
2 3 4 1
Output
0 0
Input
4
1 2 3 4
Output
0 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(0), temp;
a.push_back(0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
}
temp = a;
int f = 0, l = 0;
for (int i = 1; i < n + 1; i++) {
if (a[i] != i) {
f = i;
break;
}
}
for (int i = n; i > 0; i--) {
if (a[i] != i) {
l = i;
break;
}
}
int j = l;
for (int i = f; i <= l; i++) {
a[i] = temp[j];
j--;
}
sort(temp.begin(), temp.end());
if (a == temp) {
cout << f << " " << l << endl;
} else
cout << 0 << " " << 0 << endl;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You have n × n square grid and an integer k. Put an integer in each cell while satisfying the conditions below.
* All numbers in the grid should be between 1 and k inclusive.
* Minimum number of the i-th row is 1 (1 ≤ i ≤ n).
* Minimum number of the j-th column is 1 (1 ≤ j ≤ n).
Find the number of ways to put integers in the grid. Since the answer can be very large, find the answer modulo (10^{9} + 7).
<image> These are the examples of valid and invalid grid when n=k=2.
Input
The only line contains two integers n and k (1 ≤ n ≤ 250, 1 ≤ k ≤ 10^{9}).
Output
Print the answer modulo (10^{9} + 7).
Examples
Input
2 2
Output
7
Input
123 456789
Output
689974806
Note
In the first example, following 7 cases are possible.
<image>
In the second example, make sure you print the answer modulo (10^{9} + 7).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int MOD = 1000000007;
const int nmax = 101234;
int n, nw, nx = 1;
long long K, dp[2][256], f[256], inv[256], K2[256], K1[256];
long long ksm(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
long long C(int a, int b) { return f[b] * inv[a] % MOD * inv[b - a] % MOD; }
inline void add(long long &a, long long b) {
a += b;
if (a > MOD) a -= MOD;
}
int main() {
scanf("%d%I64d", &n, &K);
inv[0] = f[0] = 1;
for (int i = 1; i <= n; ++i) f[i] = f[i - 1] * i % MOD;
inv[n] = ksm(f[n], MOD - 2);
for (int i = n - 1; i; --i) inv[i] = inv[i + 1] * (i + 1) % MOD;
for (int i = 0; i <= n; ++i) {
K1[i] = ksm(K - 1, i);
K2[i] = ksm(K, i);
}
for (int i = 0; i < n; ++i) dp[nw][i] = C(i, n) * ksm(K - 1, i) % MOD;
for (int i = 2; i <= n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < j; ++k)
add(dp[nx][k],
dp[nw][j] * K1[k] % MOD * K2[n - j] % MOD * C(j - k, j) % MOD);
add(dp[nx][j],
dp[nw][j] * K1[j] % MOD * (K2[n - j] - K1[n - j] + MOD) % MOD);
}
nx = nw;
nw = 1 - nw;
memset(dp[nx], 0, sizeof dp[nx]);
}
printf("%I64d\n", dp[nw][0]);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Tavas is a strange creature. Usually "zzz" comes out of people's mouth while sleeping, but string s of length n comes out from Tavas' mouth instead.
<image>
Today Tavas fell asleep in Malekas' place. While he was sleeping, Malekas did a little process on s. Malekas has a favorite string p. He determined all positions x1 < x2 < ... < xk where p matches s. More formally, for each xi (1 ≤ i ≤ k) he condition sxisxi + 1... sxi + |p| - 1 = p is fullfilled.
Then Malekas wrote down one of subsequences of x1, x2, ... xk (possibly, he didn't write anything) on a piece of paper. Here a sequence b is a subsequence of sequence a if and only if we can turn a into b by removing some of its elements (maybe no one of them or all).
After Tavas woke up, Malekas told him everything. He couldn't remember string s, but he knew that both p and s only contains lowercase English letters and also he had the subsequence he had written on that piece of paper.
Tavas wonders, what is the number of possible values of s? He asked SaDDas, but he wasn't smart enough to solve this. So, Tavas asked you to calculate this number for him.
Answer can be very large, so Tavas wants you to print the answer modulo 109 + 7.
Input
The first line contains two integers n and m, the length of s and the length of the subsequence Malekas wrote down (1 ≤ n ≤ 106 and 0 ≤ m ≤ n - |p| + 1).
The second line contains string p (1 ≤ |p| ≤ n).
The next line contains m space separated integers y1, y2, ..., ym, Malekas' subsequence (1 ≤ y1 < y2 < ... < ym ≤ n - |p| + 1).
Output
In a single line print the answer modulo 1000 000 007.
Examples
Input
6 2
ioi
1 3
Output
26
Input
5 2
ioi
1 2
Output
0
Note
In the first sample test all strings of form "ioioi?" where the question mark replaces arbitrary English letter satisfy.
Here |x| denotes the length of string x.
Please note that it's possible that there is no such string (answer is 0).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char Str[1000005], T[1000005];
long long Mod = 1000000007;
bool Marked[1000005];
int KMP[1000005];
set<int> S;
set<int>::iterator it;
long long Power(int base, int expo) {
if (expo == 0)
return 1;
else {
long long x = Power(base, expo >> 1);
if (expo & 1)
return (((x * x) % Mod) * base) % Mod;
else
return (x * x) % Mod;
}
}
void Algo_KMP(int length) {
int i, j;
KMP[1] = 1;
for (i = 2; i <= length; ++i) {
j = KMP[i - 1];
while (true) {
if (T[j] != T[i]) {
if (j == 1) {
KMP[i] = 1;
break;
} else
j = KMP[j - 1];
} else {
KMP[i] = j + 1;
break;
}
}
}
}
long long query(int N, int length) {
int i, j;
for (i = 1, j = 1; i <= N;) {
if (Str[i] != T[j]) {
if (j == 1)
++i;
else
j = KMP[j - 1];
} else {
if (j == length) {
S.insert(i - length + 1);
++i;
j = KMP[j];
} else {
++i;
++j;
}
}
}
int Count = 0;
for (i = 1; i <= N; ++i) {
if (Marked[i] == true) {
it = S.find(i);
if (it == S.end()) return 0;
}
if (Str[i] == '@') ++Count;
}
return Power(26, Count);
}
int main() {
int N, m, i, k, Num;
scanf("%d%d%s", &N, &m, T + 1);
for (i = 1; i <= m; ++i) {
scanf("%d", &Num);
Marked[Num] = true;
}
if (m == 0) {
printf("%lld\n", Power(26, N));
return 0;
}
int Cur = 1, length = strlen(T + 1);
for (i = 1; i <= N; ++i) {
if (Marked[i] == false) continue;
if (Cur < i) {
Cur = i;
k = 1;
} else
k = Cur - i + 1;
for (; k <= length; ++k, ++Cur) Str[Cur] = T[k];
}
for (i = 1; i <= N; ++i) {
if (!(Str[i] >= 'a' && Str[i] <= 'z')) Str[i] = '@';
}
Str[N + 1] = '\0';
Algo_KMP(length);
printf("%lld\n", query(N, length));
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
### Response
```cpp
#include <bits/stdc++.h>
#define int long long
#define f first
#define s second
using namespace std;
int n,dp[1009][10009];
pair <pair<int,int>,int> v[1009];
int f(int i,int c){
if(i==n)return 0;
if(dp[i][c]!=-1)
return dp[i][c];
dp[i][c]=f(i+1,c);
if(v[i].f.f<=c)
dp[i][c]=max(dp[i][c],v[i].s+f(i+1,min(c-v[i].f.f,v[i].f.s)));
return dp[i][c];
}
int32_t main(){
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n;
for(int i=0;i<n;i++){
cin >> v[i].f.f >> v[i].f.s >> v[i].s;
v[i].f.f+=v[i].f.s;
}
sort(v,v+n);
reverse(v,v+n);
for(int i=0;i<n;i++)
v[i].f.f-=v[i].f.s;
memset(dp,-1,sizeof(long long)*1009*10009);
int m=0;
for(int i=0;i<n;i++)
m=max(v[i].s+f(i+1,v[i].f.s),m);
cout << m << endl;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Nastia has received an array of n positive integers as a gift.
She calls such an array a good that for all i (2 ≤ i ≤ n) takes place gcd(a_{i - 1}, a_{i}) = 1, where gcd(u, v) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers u and v.
You can perform the operation: select two different indices i, j (1 ≤ i, j ≤ n, i ≠ j) and two integers x, y (1 ≤ x, y ≤ 2 ⋅ 10^9) so that min{(a_i, a_j)} = min{(x, y)}. Then change a_i to x and a_j to y.
The girl asks you to make the array good using at most n operations.
It can be proven that this is always possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 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 ≤ 10^9) — the array which Nastia has received as a gift.
It's guaranteed that the sum of n in one test doesn't exceed 2 ⋅ 10^5.
Output
For each of t test cases print a single integer k (0 ≤ k ≤ n) — the number of operations. You don't need to minimize this number.
In each of the next k lines print 4 integers i, j, x, y (1 ≤ i ≠ j ≤ n, 1 ≤ x, y ≤ 2 ⋅ 10^9) so that min{(a_i, a_j)} = min{(x, y)} — in this manner you replace a_i with x and a_j with y.
If there are multiple answers, print any.
Example
Input
2
5
9 6 3 11 15
3
7 5 13
Output
2
1 5 11 9
2 5 7 6
0
Note
Consider the first test case.
Initially a = [9, 6, 3, 11, 15].
In the first operation replace a_1 with 11 and a_5 with 9. It's valid, because min{(a_1, a_5)} = min{(11, 9)} = 9.
After this a = [11, 6, 3, 11, 9].
In the second operation replace a_2 with 7 and a_5 with 6. It's valid, because min{(a_2, a_5)} = min{(7, 6)} = 6.
After this a = [11, 7, 3, 11, 6] — a good array.
In the second test case, the initial array is already good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn=2e5+100;
const int inf=1e9;
const int mod=998244353;
typedef long long ll;
#define fi first
#define se second
#define mp(x,y) make_pair(x,y)
#define rep(i, x, y) for(int i = x; i <= y; ++i)
int a[maxn];
int main()
{
// freopen("text.in","r",stdin);
int T,n,x,y;
scanf("%d",&T);
int num=1e9+7;
while (T--) {
scanf("%d",&n);
for (int i=1;i<=n;i++) {
scanf("%d",&a[i]);
}
printf("%d\n",n/2);
for (int i=1;i<=n/2;i++) {
x=a[i*2-1]; y=a[i*2];
//a[i-1]=min(x,y); a[i]=a[i-1]+1;
printf("%d %d %d %d\n",i*2-1,i*2,min(x,y),num);
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
In the land of Bovinia there are n pastures, but no paths connecting the pastures. Of course, this is a terrible situation, so Kevin Sun is planning to rectify it by constructing m undirected paths connecting pairs of distinct pastures. To make transportation more efficient, he also plans to pave some of these new paths.
Kevin is very particular about certain aspects of path-paving. Since he loves odd numbers, he wants each pasture to have an odd number of paved paths connected to it. Thus we call a paving sunny if each pasture is incident to an odd number of paved paths. He also enjoys short paths more than long paths, so he would like the longest paved path to be as short as possible. After adding each path, Kevin wants to know if a sunny paving exists for the paths of Bovinia, and if at least one does, the minimum possible length of the longest path in such a paving. Note that "longest path" here means maximum-weight edge.
Input
The first line contains two integers n (2 ≤ n ≤ 100 000) and m (1 ≤ m ≤ 300 000), denoting the number of pastures and paths, respectively. The next m lines each contain three integers ai, bi and li, describing the i-th path. The i-th path connects pastures ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) and has length li (1 ≤ li ≤ 109). Paths are given in the order in which they are constructed.
Output
Output m lines. The i-th line should contain a single integer denoting the minimum possible length of the longest path (maximum-weight edge) in a sunny paving using only the first i paths. If Kevin cannot pave a set of paths so that each pasture is incident to an odd number of paved paths, output - 1.
Note that the paving is only hypothetical—your answer after adding the i-th path should not be affected by any of your previous answers.
Examples
Input
4 4
1 3 4
2 4 8
1 2 2
3 4 3
Output
-1
8
8
3
Input
3 2
1 2 3
2 3 4
Output
-1
-1
Input
4 10
2 1 987
3 2 829
4 1 768
4 2 608
3 4 593
3 2 488
4 2 334
2 1 204
1 3 114
1 4 39
Output
-1
-1
829
829
768
768
768
488
334
204
Note
For the first sample, these are the paths that Kevin should pave after building the i-th path:
1. No set of paths works.
2. Paths 1 (length 4) and 2 (length 8).
3. Paths 1 (length 4) and 2 (length 8).
4. Paths 3 (length 2) and 4 (length 3).
In the second sample, there never exists a paving that makes Kevin happy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int a = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while ('0' <= c && c <= '9') {
a = a * 10 + c - 48;
c = getchar();
}
return a;
}
int fa[400005], ch[400005][2], tag[400005], siz[400005], li[400005];
pair<int, int> mx[400005], val[400005];
int getpos(int first) { return ch[fa[first]][1] == first; }
bool isroot(int first) {
return ch[fa[first]][0] != first && ch[fa[first]][1] != first;
}
void pushup(int first) {
assert(li[first] >= 0);
siz[first] = siz[ch[first][0]] + siz[ch[first][1]] + li[first];
mx[first] = max(max(mx[ch[first][0]], mx[ch[first][1]]), val[first]);
}
void ptag(int first) {
swap(ch[first][0], ch[first][1]);
tag[first] ^= 1;
}
void pd(int first) {
if (tag[first]) {
ptag(ch[first][0]);
ptag(ch[first][1]);
tag[first] = 0;
}
}
void rotate(int first) {
int second = fa[first], z = fa[second], d = getpos(first);
ch[second][d] = ch[first][!d];
if (ch[first][!d]) fa[ch[first][!d]] = second;
fa[first] = z;
if (!isroot(second)) ch[z][getpos(second)] = first;
fa[second] = first;
ch[first][!d] = second;
pushup(second);
pushup(first);
}
int st[400005], top;
void splay(int first) {
int tmp = first;
st[top = 1] = first;
while (!isroot(first)) {
first = fa[first];
st[++top] = first;
}
while (top) pd(st[top--]);
first = tmp;
while (!isroot(first)) {
int second = fa[first], z = fa[second];
if (!isroot(second)) {
rotate(getpos(first) == getpos(second) ? second : first);
}
rotate(first);
}
}
void access(int first) {
for (int second = 0; first; first = fa[second = first]) {
splay(first);
li[first] -= siz[second];
li[first] += siz[ch[first][1]];
ch[first][1] = second;
pushup(first);
assert(siz[first] >= 0);
}
}
void makeroot(int first) {
access(first);
splay(first);
ptag(first);
access(first);
}
int n, m, F[400005], op[400005];
void link(int first, int second) {
makeroot(first);
makeroot(second);
fa[first] = second;
li[second] += siz[first];
pushup(second);
assert(siz[second] >= 0);
}
void cut(int first, int second) {
makeroot(first);
access(second);
splay(second);
fa[first] = ch[second][0] = 0;
pushup(second);
assert(siz[second] >= 0);
}
int u[400005], v[400005], w[400005];
int Find(int a) {
if (F[a] == a) return a;
return F[a] = Find(F[a]);
}
set<pair<int, int> > S;
void maintain() {
while (S.size()) {
pair<int, int> e = *(--S.end());
int first = u[e.second], second = e.second;
makeroot(first);
access(second);
splay(second);
assert(siz[first]);
if (siz[first] % 2 == 0) {
S.erase(e);
} else
break;
}
}
int main() {
n = read();
m = read();
if (n & 1) {
while (m--) puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i) F[i] = i, op[i] = 1;
for (int i = 1; i <= n; ++i) siz[i] = li[i] = 1;
int cnt = n;
for (int i = n + 1; i <= n + m; ++i) {
u[i] = read(), v[i] = read(), w[i] = read();
val[i] = make_pair(w[i], i);
int fu = Find(u[i]), fv = Find(v[i]);
if (fu != fv) {
if (op[fu] && op[fv]) cnt -= 2;
op[fu] ^= op[fv];
F[fv] = fu;
link(u[i], i);
link(i, v[i]);
S.insert(make_pair(w[i], i));
} else {
int first = u[i], second = v[i];
makeroot(first);
access(second);
splay(second);
pair<int, int> e = mx[second];
if (e.first > w[i]) {
cut(u[e.second], e.second);
cut(v[e.second], e.second);
if (S.find(make_pair(e.first, e.second)) != S.end()) {
S.erase(make_pair(e.first, e.second));
}
link(first, i);
link(second, i);
S.insert(make_pair(w[i], i));
}
}
if (cnt) {
puts("-1");
} else {
maintain();
printf("%d\n", (*(--S.end())).first);
}
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Ayrat has number n, represented as it's prime factorization pi of size m, i.e. n = p1·p2·...·pm. Ayrat got secret information that that the product of all divisors of n taken modulo 109 + 7 is the password to the secret data base. Now he wants to calculate this value.
Input
The first line of the input contains a single integer m (1 ≤ m ≤ 200 000) — the number of primes in factorization of n.
The second line contains m primes numbers pi (2 ≤ pi ≤ 200 000).
Output
Print one integer — the product of all divisors of n modulo 109 + 7.
Examples
Input
2
2 3
Output
36
Input
3
2 3 2
Output
1728
Note
In the first sample n = 2·3 = 6. The divisors of 6 are 1, 2, 3 and 6, their product is equal to 1·2·3·6 = 36.
In the second sample 2·3·2 = 12. The divisors of 12 are 1, 2, 3, 4, 6 and 12. 1·2·3·4·6·12 = 1728.
### Response
```cpp
#include <bits/stdc++.h>
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
std::cerr << v << " ";
return *this;
}
} dbg;
long long bigmod(long long sonkha, long long ghat, long long vag_const) {
long long vag_shesh = 1;
while (ghat > 0) {
if (ghat % 2 == 1) {
vag_shesh = (vag_shesh * sonkha) % vag_const;
}
ghat /= 2;
sonkha = (sonkha * sonkha) % vag_const;
}
return vag_shesh;
}
long long inverse_mod(long long bivajok, long long vag_const) {
return bigmod(bivajok, vag_const - 2, vag_const);
}
using namespace std;
map<long long, long long> mpp, indx;
long long prod = 1, ans = 1, fw[200005], bw[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, y, k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
mpp[m]++;
}
m = 0;
for (auto& x : mpp) {
prod *= (x.second + 1);
prod %= (1000000007 - 1);
fw[m] = prod;
indx[x.first] = m++;
}
prod = 1;
for (map<long long, long long>::reverse_iterator x = mpp.rbegin();
x != mpp.rend(); x++) {
prod *= ((x->second) + 1);
prod %= (1000000007 - 1);
bw[indx[(x->first)]] = prod;
}
for (auto& x : mpp) {
y = x.second;
k = y++;
if (y & 1LL)
k /= 2;
else
y /= 2;
y = (k * y) % (1000000007 - 1);
if (indx[x.first] > 0) y = (fw[indx[x.first] - 1] * y) % (1000000007 - 1);
if (indx[x.first] + 1 < m)
y = (bw[indx[x.first] + 1] * y) % (1000000007 - 1);
ans *= (bigmod(x.first, y, 1000000007));
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
It is known that fleas in Berland can jump only vertically and horizontally, and the length of the jump is always equal to s centimeters. A flea has found herself at the center of some cell of the checked board of the size n × m centimeters (each cell is 1 × 1 centimeters). She can jump as she wishes for an arbitrary number of times, she can even visit a cell more than once. The only restriction is that she cannot jump out of the board.
The flea can count the amount of cells that she can reach from the starting position (x, y). Let's denote this amount by dx, y. Your task is to find the number of such starting positions (x, y), which have the maximum possible value of dx, y.
Input
The first line contains three integers n, m, s (1 ≤ n, m, s ≤ 106) — length of the board, width of the board and length of the flea's jump.
Output
Output the only integer — the number of the required starting positions of the flea.
Examples
Input
2 3 1000000
Output
6
Input
3 3 2
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, mx1, mx2;
map<long long, long long> c1, c2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> s;
for (long long i = 1; i <= min(m, s); i++) {
c1[(m - i) / s + 1]++;
}
for (long long i = 1; i <= min(n, s); i++) {
c2[(n - i) / s + 1]++;
}
for (map<long long, long long>::iterator it = c1.begin(); it != c1.end();
it++) {
mx1 = max(mx1, it->first);
}
for (map<long long, long long>::iterator it = c2.begin(); it != c2.end();
it++) {
mx2 = max(mx2, it->first);
}
cout << mx1 * mx2 * c1[mx1] * c2[mx2] << "\n";
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
In order to pass the entrance examination tomorrow, Taro has to study for T more hours.
Fortunately, he can leap to World B where time passes X times as fast as it does in our world (World A).
While (X \times t) hours pass in World B, t hours pass in World A.
How many hours will pass in World A while Taro studies for T hours in World B?
Constraints
* All values in input are integers.
* 1 \leq T \leq 100
* 1 \leq X \leq 100
Input
Input is given from Standard Input in the following format:
T X
Output
Print the number of hours that will pass in World A.
The output will be regarded as correct when its absolute or relative error from the judge's output is at most 10^{-3}.
Examples
Input
8 3
Output
2.6666666667
Input
99 1
Output
99.0000000000
Input
1 100
Output
0.0100000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
long double x,y;
cin >> x >> y;
cout << x/y;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
### Response
```cpp
#include<iostream>
#include<cmath>
#include<cstdio>
#define EPS (1e-10)
#define equal(a,b) fabs((a)-(b))<EPS
using namespace std;
struct Point{
double x,y;
Point(double _x,double _y):x(_x),y(_y){ }
Point operator + (const Point &a){
return Point(x+a.x,y+a.y);
}
Point operator - (const Point &a){
return Point(x-a.x,y-a.y);
}
Point operator *(double k){
return Point (k*x,k*y);
}
Point operator /(double k){
return Point(x/k,y/k);
}
friend double norm(const Point &a){
return a.x*a.x+a.y*a.y;
}
friend double abs(const Point &a){
return sqrt(norm(a));
}
friend double dot(const Point &a,const Point &b){
return a.x*b.x+a.y*b.y;
}
friend double cross(const Point &a,const Point &b){
return fabs(a.x*b.y-b.x*a.y);
}
};
typedef Point Vector;
bool isOrthogonal(const Vector &a,const Vector & b){
return equal(cross(a,b),0.0);
}
bool isParallel(const Vector &a,const Vector &b){
return equal(dot(a,b),0.0);
}
int main(){
int x1,x2,y1,y2,q;
cin>>x1>>y1>>x2>>y2>>q;
Point a(x1,y1),b(x2,y2);
while(q--){
int x3,y3;
cin>>x3>>y3;
Point c(x3,y3);
double t=dot(c-a,b-a)/abs(b-a);
Vector det= (b-a) / abs(b-a) *t;
Point ort=a+det;
printf("%.10f %.10f\n",ort.x,ort.y);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Arkady decides to observe a river for n consecutive days. The river's water level on each day is equal to some real value.
Arkady goes to the riverside each day and makes a mark on the side of the channel at the height of the water level, but if it coincides with a mark made before, no new mark is created. The water does not wash the marks away. Arkady writes down the number of marks strictly above the water level each day, on the i-th day this value is equal to mi.
Define di as the number of marks strictly under the water level on the i-th day. You are to find out the minimum possible sum of di over all days. There are no marks on the channel before the first day.
Input
The first line contains a single positive integer n (1 ≤ n ≤ 105) — the number of days.
The second line contains n space-separated integers m1, m2, ..., mn (0 ≤ mi < i) — the number of marks strictly above the water on each day.
Output
Output one single integer — the minimum possible sum of the number of marks strictly below the water level among all days.
Examples
Input
6
0 1 0 3 0 2
Output
6
Input
5
0 1 2 1 2
Output
1
Input
5
0 1 1 2 2
Output
0
Note
In the first example, the following figure shows an optimal case.
<image>
Note that on day 3, a new mark should be created because if not, there cannot be 3 marks above water on day 4. The total number of marks underwater is 0 + 0 + 2 + 0 + 3 + 1 = 6.
In the second example, the following figure shows an optimal case.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N], t[N];
long long ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], t[i] = a[i] + 1;
for (int i = 1; i <= n; i++) t[i] = max(t[i - 1], t[i]);
for (int i = n - 1; i >= 1; i--) t[i] = max(t[i + 1] - 1, t[i]);
for (int i = 1; i <= n; i++) ans += t[i] - a[i] - 1;
cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given a tree T consisting of n vertices. A number is written on each vertex; the number written on vertex i is ai. Let's denote the function I(x, y) as the difference between maximum and minimum value of ai on a simple path connecting vertices x and y.
Your task is to calculate <image>.
Input
The first line contains one integer number n (1 ≤ n ≤ 106) — the number of vertices in the tree.
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the numbers written on the vertices.
Then n - 1 lines follow. Each line contains two integers x and y denoting an edge connecting vertex x and vertex y (1 ≤ x, y ≤ n, x ≠ y). It is guaranteed that these edges denote a tree.
Output
Print one number equal to <image>.
Example
Input
4
2 2 3 1
1 2
1 3
1 4
Output
6
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000010LL;
const int mod = 1000000007;
const int MAXN = 1000010;
long long n, m, u, v, x, y, t, a, b, ans;
long long A[MAXN];
int ind[MAXN];
int par[MAXN];
long long sz[MAXN];
bool mark[MAXN];
vector<int> G[MAXN];
bool cmp(int i, int j) { return A[i] < A[j]; }
int get(int x) {
if (par[x] == x) return x;
return par[x] = get(par[x]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i < MAXN; i++) par[i] = i;
for (int i = 1; i < MAXN; i++) ind[i] = i;
sort(ind + 1, ind + n + 1, cmp);
for (int j = 1; j <= n; j++) {
int i = ind[j];
long long s = 0;
long long tmp = 0;
for (int v : G[i]) {
int x = get(v);
if (!mark[v]) continue;
par[x] = i;
s += sz[x];
ans += sz[x] * A[i];
tmp += sz[x] * sz[x];
}
ans += (s * s - tmp) / 2 * A[i];
sz[i] = s + 1;
mark[i] = true;
}
cerr << "ans" << '=' << ans << endl;
;
reverse(ind + 1, ind + n + 1);
memset(mark, 0, sizeof(mark));
memset(sz, 0, sizeof(sz));
for (int i = 1; i < MAXN; i++) par[i] = i;
for (int j = 1; j <= n; j++) {
int i = ind[j];
long long s = 0, tmp = 0;
for (int v : G[i]) {
int x = get(v);
if (!mark[v]) continue;
par[x] = i;
s += sz[x];
ans -= sz[x] * A[i];
tmp += sz[x] * sz[x];
}
ans -= (s * s - tmp) / 2 * A[i];
sz[i] = s + 1;
mark[i] = true;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
As you must know, the maximum clique problem in an arbitrary graph is NP-hard. Nevertheless, for some graphs of specific kinds it can be solved effectively.
Just in case, let us remind you that a clique in a non-directed graph is a subset of the vertices of a graph, such that any two vertices of this subset are connected by an edge. In particular, an empty set of vertexes and a set consisting of a single vertex, are cliques.
Let's define a divisibility graph for a set of positive integers A = {a1, a2, ..., an} as follows. The vertices of the given graph are numbers from set A, and two numbers ai and aj (i ≠ j) are connected by an edge if and only if either ai is divisible by aj, or aj is divisible by ai.
You are given a set of non-negative integers A. Determine the size of a maximum clique in a divisibility graph for set A.
Input
The first line contains integer n (1 ≤ n ≤ 106), that sets the size of set A.
The second line contains n distinct positive integers a1, a2, ..., an (1 ≤ ai ≤ 106) — elements of subset A. The numbers in the line follow in the ascending order.
Output
Print a single number — the maximum size of a clique in a divisibility graph for set A.
Examples
Input
8
3 4 6 8 10 18 21 24
Output
3
Note
In the first sample test a clique of size 3 is, for example, a subset of vertexes {3, 6, 18}. A clique of a larger size doesn't exist in this graph.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e6 + 5;
int a[N];
int val[N], val1[N];
void solve() {
int n;
cin >> n;
int cc = 0, last = -1;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (last != a[i]) {
if (last != -1) val[last] = cc, val1[last] = cc;
last = a[i];
cc = 1;
} else {
cc++;
}
}
val[last] = cc;
val1[last] = cc;
int ans = 1;
for (int i = 1; i <= N - 1; i++) {
ans = max(ans, val[i]);
for (int j = 2 * i; j < N; j += i) {
val[j] = max(val[j], val[i] + val1[j]);
}
}
cout << ans << '\n';
}
signed main() {
ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
clock_t clk = clock();
int t;
t = 1;
while (t--) {
solve();
}
cerr << (double)(clock() - clk) / CLOCKS_PER_SEC;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Vus the [Cossack](https://en.wikipedia.org/wiki/Cossacks) holds a programming competition, in which n people participate. He decided to award them all with pens and notebooks. It is known that Vus has exactly m pens and k notebooks.
Determine whether the Cossack can reward all participants, giving each of them at least one pen and at least one notebook.
Input
The first line contains three integers n, m, and k (1 ≤ n, m, k ≤ 100) — the number of participants, the number of pens, and the number of notebooks respectively.
Output
Print "Yes" if it possible to reward all the participants. Otherwise, print "No".
You can print each letter in any case (upper or lower).
Examples
Input
5 8 6
Output
Yes
Input
3 9 3
Output
Yes
Input
8 5 20
Output
No
Note
In the first example, there are 5 participants. The Cossack has 8 pens and 6 notebooks. Therefore, he has enough pens and notebooks.
In the second example, there are 3 participants. The Cossack has 9 pens and 3 notebooks. He has more than enough pens but only the minimum needed number of notebooks.
In the third example, there are 8 participants but only 5 pens. Since the Cossack does not have enough pens, the answer is "No".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n <= m && n <= k)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Little Artem is fond of dancing. Most of all dances Artem likes rueda — Cuban dance that is danced by pairs of boys and girls forming a circle and dancing together.
More detailed, there are n pairs of boys and girls standing in a circle. Initially, boy number 1 dances with a girl number 1, boy number 2 dances with a girl number 2 and so on. Girls are numbered in the clockwise order. During the dance different moves are announced and all pairs perform this moves. While performing moves boys move along the circle, while girls always stay at their initial position. For the purpose of this problem we consider two different types of moves:
1. Value x and some direction are announced, and all boys move x positions in the corresponding direction.
2. Boys dancing with even-indexed girls swap positions with boys who are dancing with odd-indexed girls. That is the one who was dancing with the girl 1 swaps with the one who was dancing with the girl number 2, while the one who was dancing with girl number 3 swaps with the one who was dancing with the girl number 4 and so one. It's guaranteed that n is even.
Your task is to determine the final position of each boy.
Input
The first line of the input contains two integers n and q (2 ≤ n ≤ 1 000 000, 1 ≤ q ≤ 2 000 000) — the number of couples in the rueda and the number of commands to perform, respectively. It's guaranteed that n is even.
Next q lines contain the descriptions of the commands. Each command has type as the integer 1 or 2 first. Command of the first type is given as x ( - n ≤ x ≤ n), where 0 ≤ x ≤ n means all boys moves x girls in clockwise direction, while - x means all boys move x positions in counter-clockwise direction. There is no other input for commands of the second type.
Output
Output n integers, the i-th of them should be equal to the index of boy the i-th girl is dancing with after performing all q moves.
Examples
Input
6 3
1 2
2
1 2
Output
4 3 6 5 2 1
Input
2 3
1 1
2
1 -2
Output
1 2
Input
4 2
2
1 3
Output
1 4 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 7;
int read() {
int x = 0, f = 1;
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();
}
return x * f;
}
int n, q;
int a[Maxn];
int x, y;
int main() {
int tp, f;
x = 1, y = 2;
n = read();
q = read();
while (q--) {
tp = read();
if (tp == 1) {
f = read();
x += f;
y += f;
} else {
if (x & 1) {
x++;
y--;
} else {
y++;
x--;
}
}
if (x < 1)
x += n;
else if (x > n)
x -= n;
if (y < 1)
y += n;
else if (y > n)
y -= n;
}
int tmp = 1;
for (int i = x; i <= n; i += 2) {
a[i] = tmp;
tmp += 2;
}
int zk;
if (x & 1)
zk = 1;
else
zk = 2;
for (int i = zk; i < x; i += 2) {
a[i] = tmp;
tmp += 2;
}
tmp = 2;
for (int i = y; i <= n; i += 2) {
a[i] = tmp;
tmp += 2;
}
if (y & 1)
zk = 1;
else
zk = 2;
for (int i = zk; i < y; i += 2) {
a[i] = tmp;
tmp += 2;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given n segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every k ∈ [1..n], calculate the number of points with integer coordinates such that the number of segments that cover these points equals k. A segment with endpoints l_i and r_i covers point x if and only if l_i ≤ x ≤ r_i.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of segments.
The next n lines contain segments. The i-th line contains a pair of integers l_i, r_i (0 ≤ l_i ≤ r_i ≤ 10^{18}) — the endpoints of the i-th segment.
Output
Print n space separated integers cnt_1, cnt_2, ..., cnt_n, where cnt_i is equal to the number of points such that the number of segments that cover these points equals to i.
Examples
Input
3
0 3
1 3
3 8
Output
6 2 1
Input
3
1 3
2 4
5 7
Output
5 2 0
Note
The picture describing the first example:
<image>
Points with coordinates [0, 4, 5, 6, 7, 8] are covered by one segment, points [1, 2] are covered by two segments and point [3] is covered by three segments.
The picture describing the second example:
<image>
Points [1, 4, 5, 6, 7] are covered by one segment, points [2, 3] are covered by two segments and there are no points covered by three segments.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
long long l[maxn], r[maxn], ans[maxn];
int tl[maxn], tr[maxn], s[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> ds;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
ds.push_back(l[i]), ds.push_back(r[i]);
ds.push_back(l[i] - 1), ds.push_back(l[i] + 1);
ds.push_back(r[i] - 1), ds.push_back(r[i] + 1);
}
sort(ds.begin(), ds.end()),
ds.resize(unique(ds.begin(), ds.end()) - ds.begin());
for (int i = 0; i < n; ++i) {
tl[i] = lower_bound(ds.begin(), ds.end(), l[i]) - ds.begin();
tr[i] = lower_bound(ds.begin(), ds.end(), r[i]) - ds.begin();
}
for (int i = 0; i < n; ++i) ++s[tl[i]], --s[tr[i] + 1];
for (int i = 1; i < maxn; ++i) s[i] += s[i - 1];
for (int i = 0; i < ds.size() - 1; ++i) {
long long nxt = ds[i + 1] - 1;
ans[s[i]] += nxt - ds[i] + 1;
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
cout << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
A binary heap which satisfies max-heap property is called max-heap. In a max-heap, for every node $i$ other than the root, $A[i] \leq A[parent(i)]$, that is, the value of a node is at most the value of its parent. The largest element in a max-heap is stored at the root, and the subtree rooted at a node contains values no larger than that contained at the node itself.
Here is an example of a max-heap.
<image>
Write a program which reads an array and constructs a max-heap from the array based on the following pseudo code.
$maxHeapify(A, i)$ move the value of $A[i]$ down to leaves to make a sub-tree of node $i$ a max-heap. Here, $H$ is the size of the heap.
1 maxHeapify(A, i)
2 l = left(i)
3 r = right(i)
4 // select the node which has the maximum value
5 if l ≤ H and A[l] > A[i]
6 largest = l
7 else
8 largest = i
9 if r ≤ H and A[r] > A[largest]
10 largest = r
11
12 if largest ≠ i // value of children is larger than that of i
13 swap A[i] and A[largest]
14 maxHeapify(A, largest) // call recursively
The following procedure buildMaxHeap(A) makes $A$ a max-heap by performing maxHeapify in a bottom-up manner.
1 buildMaxHeap(A)
2 for i = H/2 downto 1
3 maxHeapify(A, i)
Input
In the first line, an integer $H$ is given. In the second line, $H$ integers which represent elements in the binary heap are given in order of node id (from $1$ to $H$).
Output
Print values of nodes in the max-heap in order of their id (from $1$ to $H$). Print a single space character before each value.
Example
Input
10
4 1 3 2 16 9 10 14 8 7
Output
16 14 10 8 7 9 3 2 4 1
### Response
```cpp
#include <iostream>
using namespace std;
int H, A[500001];
void max_heapify(int i) {
int l = 2 * i;
int r = 2 * i + 1;
int largest = 0;
if (l <= H && A[l] > A[i])
largest = l;
else
largest = i;
if (r <= H && A[r] > A[largest])
largest = r;
if (largest != i) {
swap(A[i], A[largest]);
max_heapify(largest);
}
}
int main() {
cin >> H;
for (int i = 0; i < H; i++)
cin >> A[i + 1];
for (int i = H / 2; i >= 1; i--)
max_heapify(i);
for (int i = 1; i <= H; i++)
cout << " " << A[i];
cout << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
AtCoDeer the deer found N rectangle lying on the table, each with height 1. If we consider the surface of the desk as a two-dimensional plane, the i-th rectangle i(1≤i≤N) covers the vertical range of [i-1,i] and the horizontal range of [l_i,r_i], as shown in the following figure:
<image>
AtCoDeer will move these rectangles horizontally so that all the rectangles are connected. For each rectangle, the cost to move it horizontally by a distance of x, is x. Find the minimum cost to achieve connectivity. It can be proved that this value is always an integer under the constraints of the problem.
Constraints
* All input values are integers.
* 1≤N≤10^5
* 1≤l_i<r_i≤10^9
Input
The input is given from Standard Input in the following format:
N
l_1 r_1
l_2 r_2
:
l_N r_N
Output
Print the minimum cost to achieve connectivity.
Examples
Input
3
1 3
5 7
1 3
Output
2
Input
3
2 5
4 6
1 4
Output
0
Input
5
999999999 1000000000
1 2
314 315
500000 500001
999999999 1000000000
Output
1999999680
Input
5
123456 789012
123 456
12 345678901
123456 789012
1 23
Output
246433
Input
1
1 400
Output
0
### Response
```cpp
#include "bits/stdc++.h"
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(int i=0;i<n;i++)
#define rep3(i,a,b) for(int i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define tii tuple<int,int,int>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define edge(v,a,b) v[a].pb(b);v[b].pb(a);
ll MOD=1e9+7;
#define INF 1e9+7
#define N 400001
#define MAX_V 400010
#define vec vector<int>
#define ALL(c) (c).begin(),(c).end()
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
template<typename A, size_t NNN, typename T>
void Fill(A (&array)[NNN], const T &val){
fill( (T*)array, (T*)(array+NNN), val );
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
#define umap unordered_map<ll,int,custom_hash>
struct pair_hash
{
template<class T1,class T2>
size_t operator() (const pair<T1,T2> &p)const{
return hash<T1>()(p.first)^hash<T2>()(p.second);
}
};
int main(){
ll n=lin();
priority_queue<ll> p1;
priority_queue<ll,vector<ll>,greater<ll>> p2;
ll ans=0;
ll d=0;
ll l=lin(),r=lin();
ll mid=l+r;
ll length=r-l;
p1.push(mid);
p2.push(mid);
rep(i,n-1){
l=lin();r=lin();
d+=length+r-l;
length=r-l;
mid=l+r;
ll n1=p1.top()-d,n2=p2.top()+d;
if(mid<=n1){
p2.push(n1-d);
p1.pop();
p1.push(mid+d);p1.push(mid+d);
ans+=p2.top()+d-mid;
}
else if(n1<mid&&mid<=n2){
p1.push(mid+d);
p2.push(mid-d);
}
else{
p1.push(n2+d);
p2.pop();
p2.push(mid-d);p2.push(mid-d);
ans+=mid-(p1.top()-d);
}
}
cout<<ans/2;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a matrix of size n × n filled with lowercase English letters. You can change no more than k letters in this matrix.
Consider all paths from the upper left corner to the lower right corner that move from a cell to its neighboring cell to the right or down. Each path is associated with the string that is formed by all the letters in the cells the path visits. Thus, the length of each string is 2n - 1.
Find the lexicographically smallest string that can be associated with a path after changing letters in at most k cells of the matrix.
A string a is lexicographically smaller than a string b, if the first different letter in a and b is smaller in a.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ n^2) — the size of the matrix and the number of letters you can change.
Each of the next n lines contains a string of n lowercase English letters denoting one row of the matrix.
Output
Output the lexicographically smallest string that can be associated with some valid path after changing no more than k letters in the matrix.
Examples
Input
4 2
abcd
bcde
bcad
bcde
Output
aaabcde
Input
5 3
bwwwz
hrhdh
sepsp
sqfaf
ajbvw
Output
aaaepfafw
Input
7 6
ypnxnnp
pnxonpm
nxanpou
xnnpmud
nhtdudu
npmuduh
pmutsnz
Output
aaaaaaadudsnz
Note
In the first sample test case it is possible to change letters 'b' in cells (2, 1) and (3, 1) to 'a', then the minimum path contains cells (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4). The first coordinate corresponds to the row and the second coordinate corresponds to the column.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char str[2005][2005];
int dp[2005][2005];
int dist[2005][2005];
int opt[2005];
int col[2005][2005];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 0; i < 2005; i++) {
for (int j = 0; j < 2005; j++) dp[i][j] = 10000;
}
dp[0][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
dp[i][j] = (str[i][j] != 'a') + min(dp[i - 1][j], dp[i][j - 1]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) dist[i][j] = 100;
}
for (int i = 1; i <= 2 * n - 1; i++) opt[i] = 100;
queue<pair<int, int> > qu;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dp[i][j] <= k) {
opt[i + j - 1] = 0;
dist[i][j] = 0;
qu.push({i, j});
}
}
}
if (qu.empty()) {
qu.push({1, 1});
dist[1][1] = str[1][1] - 'a';
opt[1] = dist[1][1];
}
while (!qu.empty()) {
pair<int, int> cur = qu.front();
qu.pop();
int x = cur.first, y = cur.second;
if (dist[x][y] > opt[x + y - 1]) continue;
if (col[x][y]) continue;
col[x][y] = 1;
if (x < n && str[x + 1][y] - 'a' <= opt[x + y] && dp[x + 1][y] > k) {
opt[x + y] = str[x + 1][y] - 'a';
dist[x + 1][y] = opt[x + y];
qu.push({x + 1, y});
}
if (y < n && str[x][y + 1] - 'a' <= opt[x + y] && dp[x][y + 1] > k) {
opt[x + y] = str[x][y + 1] - 'a';
dist[x][y + 1] = opt[x + y];
qu.push({x, y + 1});
}
}
string ans;
for (int i = 1; i <= 2 * n - 1; i++) ans += opt[i] + 'a';
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Vasya has a sequence of cubes and exactly one integer is written on each cube. Vasya exhibited all his cubes in a row. So the sequence of numbers written on the cubes in the order from the left to the right equals to a1, a2, ..., an.
While Vasya was walking, his little brother Stepan played with Vasya's cubes and changed their order, so now the sequence of numbers written on the cubes became equal to b1, b2, ..., bn.
Stepan said that he swapped only cubes which where on the positions between l and r, inclusive, and did not remove or add any other cubes (i. e. he said that he reordered cubes between positions l and r, inclusive, in some way).
Your task is to determine if it is possible that Stepan said the truth, or it is guaranteed that Stepan deceived his brother.
Input
The first line contains three integers n, l, r (1 ≤ n ≤ 105, 1 ≤ l ≤ r ≤ n) — the number of Vasya's cubes and the positions told by Stepan.
The second line contains the sequence a1, a2, ..., an (1 ≤ ai ≤ n) — the sequence of integers written on cubes in the Vasya's order.
The third line contains the sequence b1, b2, ..., bn (1 ≤ bi ≤ n) — the sequence of integers written on cubes after Stepan rearranged their order.
It is guaranteed that Stepan did not remove or add other cubes, he only rearranged Vasya's cubes.
Output
Print "LIE" (without quotes) if it is guaranteed that Stepan deceived his brother. In the other case, print "TRUTH" (without quotes).
Examples
Input
5 2 4
3 4 2 3 1
3 2 3 4 1
Output
TRUTH
Input
3 1 2
1 2 3
3 1 2
Output
LIE
Input
4 2 4
1 1 1 1
1 1 1 1
Output
TRUTH
Note
In the first example there is a situation when Stepan said the truth. Initially the sequence of integers on the cubes was equal to [3, 4, 2, 3, 1]. Stepan could at first swap cubes on positions 2 and 3 (after that the sequence of integers on cubes became equal to [3, 2, 4, 3, 1]), and then swap cubes in positions 3 and 4 (after that the sequence of integers on cubes became equal to [3, 2, 3, 4, 1]).
In the second example it is not possible that Stepan said truth because he said that he swapped cubes only between positions 1 and 2, but we can see that it is guaranteed that he changed the position of the cube which was on the position 3 at first. So it is guaranteed that Stepan deceived his brother.
In the third example for any values l and r there is a situation when Stepan said the truth.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a[100005];
int b[100005];
int n, l, r;
scanf("%d%d%d", &n, &l, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i < l; i++) {
if (a[i] != b[i]) {
printf("LIE");
return 0;
}
}
for (int i = r + 1; i <= n; i++) {
if (a[i] != b[i]) {
printf("LIE");
return 0;
}
}
printf("TRUTH");
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Two experienced climbers are planning a first-ever attempt: they start at two points of the equal altitudes on a mountain range, move back and forth on a single route keeping their altitudes equal, and finally meet with each other at a point on the route. A wise man told them that if a route has no point lower than the start points (of the equal altitudes) there is at least a way to achieve the attempt. This is the reason why the two climbers dare to start planning this fancy attempt.
The two climbers already obtained altimeters (devices that indicate altitude) and communication devices that are needed for keeping their altitudes equal. They also picked up a candidate route for the attempt: the route consists of consequent line segments without branches; the two starting points are at the two ends of the route; there is no point lower than the two starting points of the equal altitudes. An illustration of the route is given in Figure E.1 (this figure corresponds to the first dataset of the sample input).
<image>
Figure E.1: An illustration of a route
The attempt should be possible for the route as the wise man said. The two climbers, however, could not find a pair of move sequences to achieve the attempt, because they cannot keep their altitudes equal without a complex combination of both forward and backward moves. For example, for the route illustrated above: a climber starting at p1 (say A) moves to s, and the other climber (say B) moves from p6 to p5; then A moves back to t while B moves to p4; finally A arrives at p3 and at the same time B also arrives at p3. Things can be much more complicated and thus they asked you to write a program to find a pair of move sequences for them.
There may exist more than one possible pair of move sequences, and thus you are requested to find the pair of move sequences with the shortest length sum. Here, we measure the length along the route surface, i.e., an uphill path from (0, 0) to (3, 4) has the length of 5.
Input
The input is a sequence of datasets.
The first line of each dataset has an integer indicating the number of points N (2 ≤ N ≤ 100) on the route. Each of the following N lines has the coordinates (xi, yi) (i = 1, 2, ... , N) of the points: the two start points are (x1, y1) and (xN, yN); the line segments of the route connect (xi, yi) and (xi+1, yi+1) for i = 1, 2, ... , N - 1. Here, xi is the horizontal distance along the route from the start point x1, and yi is the altitude relative to the start point y1. All the coordinates are non-negative integers smaller than 1000, and inequality xi < xi+1 holds for i = 1, 2, .. , N - 1, and 0 = y1 = yN ≤ yi for i = 2, 3, ... , N - 1.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output the minimum sum of lengths (along the route) of move sequences until the two climbers meet with each other at a point on the route. Each output value may not have an error greater than 0.01.
Example
Input
6
0 0
3 4
9 12
17 6
21 9
33 0
5
0 0
10 0
20 0
30 0
40 0
10
0 0
1 2
3 0
6 3
9 0
11 2
13 0
15 2
16 2
18 0
7
0 0
150 997
300 1
450 999
600 2
750 998
900 0
0
Output
52.5
40.0
30.3356209304689
10078.072814085803
### Response
```cpp
#include <queue>
#include <set>
#include <unordered_set>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
typedef pair<int,int> pii;
/// pair<int,int> hasher
namespace std{
template<typename I>
class hash<pair<I,I>>{
public:
size_t operator()(const pair<I,I> &p) const {return hash<long long>() (((long long)(p.first))<<32|p.second);}
};
}
double solve(const vector<pii> &a){
set<int>ys;
for(auto &e:a)ys.insert(e.second);
int n=a.size();
vector<double>mx,my;
mx.reserve(n*2);
my.reserve(n*2);
for(int i=0;i<n;i++){
mx.push_back(a[i].first);
my.push_back(a[i].second);
if(i==n-1)continue;
//??????????????§y??§?¨??????????ys?????????????????????
if(a[i].second<a[i+1].second){ //??????i????°???§??????
for(auto it=ys.begin();it!=ys.end();++it){
if(a[i].second<*it && *it<a[i+1].second){
double dy=a[i+1].second-a[i].second;
double dx=(a[i+1].first-a[i].first)/dy*(*it-a[i].second);
mx.push_back(a[i].first+dx);
my.push_back(*it);
}
}
}else{ //??????i????±±??§??????
for(auto it=ys.end();it--!=ys.begin();){
if(a[i+1].second<*it && *it<a[i].second){
double dy=a[i+1].second-a[i].second;
double dx=(a[i+1].first-a[i].first)/dy*(*it-a[i].second);
mx.push_back(a[i].first+dx);
my.push_back(*it);
}
}
}
}
int m=mx.size();
priority_queue<pair<double,pii>>q;
unordered_set<pii>se;
q.push({0,{0,m-1}});
for(;!q.empty();){
double c=q.top().first;
int l=q.top().second.first;
int r=q.top().second.second;
q.pop();
if(se.find({l,r})!=se.end())continue;
se.insert({l,r});
if(l==r)return -c;
for(int i=-1;i<2;i++)for(int j=-1;j<2;j++){
if((i||j) && 0<=l+i&&l+i<m && 0<=r+j&&r+j<m && fabs(my[l+i]-my[r+j])<1e-9)
q.push({c-hypot(mx[l]-mx[l+i],my[l]-my[l+i])-hypot(mx[r]-mx[r+j],my[r]-my[r+j]),{l+i,r+j}});
}
}
abort();
}
int main(){
int N,x,y;
for(;scanf("%d",&N),N;){
vector<pii>a(N);
for(int i=0;i<N;i++)scanf("%d%d",&a[i].first,&a[i].second);
printf("%f\n",solve(a));
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dr8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dc8[] = {1, -1, 0, 0, -1, 1, -1, 1};
int dr4[] = {0, 1, -1, 0};
int dc4[] = {1, 0, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x, y;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
x = -1;
y = 1000000009;
sort(v.begin(), v.end());
pair<int, int> fr[n + 2], bk[n + 2];
map<int, int> m;
for (int i = 0; i < n; i++) {
int f = v[i].first;
int s = v[i].second;
x = f;
y = min(y, s);
fr[i + 1] = make_pair(x, y);
}
x = v[n - 1].first;
y = 1000000009;
for (int i = n - 1; i >= 0; i--) {
int f = v[i].first;
int s = v[i].second;
y = min(y, s);
bk[i + 1] = make_pair(x, y);
}
int mx = 0;
fr[0] = make_pair(0, 1000000009);
bk[n + 1] = make_pair(0, 1000000009);
for (int i = 1; i <= n; i++) {
int x1 = fr[i - 1].first, y1 = fr[i - 1].second, x2 = bk[i + 1].first,
y2 = bk[i + 1].second;
if (y1 < x1 || y2 < x2) continue;
if (y1 < x2) continue;
int mn = min(y1, y2);
int mxx = max(x1, x2);
mx = max(mx, mn - mxx);
}
cout << mx;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
A sequence a is a subsegment of a sequence b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end. We will denote the subsegments as [l, r], where l, r are two integers with 1 ≤ l ≤ r ≤ n. This indicates the subsegment where l-1 elements from the beginning and n-r elements from the end are deleted from the sequence.
For a permutation p_1, p_2, …, p_n, we define a framed segment as a subsegment [l,r] where max\\{p_l, p_{l+1}, ..., p_r\} - min\\{p_l, p_{l+1}, ..., p_r\} = r - l. For example, for the permutation (6, 7, 1, 8, 5, 3, 2, 4) some of its framed segments are: [1, 2], [5, 8], [6, 7], [3, 3], [8, 8]. In particular, a subsegment [i,i] is always a framed segments for any i between 1 and n, inclusive.
We define the happiness of a permutation p as the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n, and [l, r] is a framed segment. For example, the permutation [3, 1, 2] has happiness 5: all segments except [1, 2] are framed segments.
Given integers n and m, Jongwon wants to compute the sum of happiness for all permutations of length n, modulo the prime number m. Note that there exist n! (factorial of n) different permutations of length n.
Input
The only line contains two integers n and m (1 ≤ n ≤ 250 000, 10^8 ≤ m ≤ 10^9, m is prime).
Output
Print r (0 ≤ r < m), the sum of happiness for all permutations of length n, modulo a prime number m.
Examples
Input
1 993244853
Output
1
Input
2 993244853
Output
6
Input
3 993244853
Output
32
Input
2019 993244853
Output
923958830
Input
2020 437122297
Output
265955509
Note
For sample input n=3, let's consider all permutations of length 3:
* [1, 2, 3], all subsegments are framed segment. Happiness is 6.
* [1, 3, 2], all subsegments except [1, 2] are framed segment. Happiness is 5.
* [2, 1, 3], all subsegments except [2, 3] are framed segment. Happiness is 5.
* [2, 3, 1], all subsegments except [2, 3] are framed segment. Happiness is 5.
* [3, 1, 2], all subsegments except [1, 2] are framed segment. Happiness is 5.
* [3, 2, 1], all subsegments are framed segment. Happiness is 6.
Thus, the sum of happiness is 6+5+5+5+5+6 = 32.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long M;
long long fact[1000005];
void init() {
fact[0] = 1;
for (long long i = 1; i <= 1000000; i++) {
fact[i] = (i * fact[i - 1]) % M;
fact[i] %= M;
}
}
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n >> M;
init();
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += ((n - i + 1) * ((fact[i] * fact[n - i + 1]) % M)) % M;
ans %= M;
}
ans %= M;
cout << ans << endl;
}
int main() {
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Write a program which print coordinates $(x_i, y_i)$ of given $n$ points on the plane by the following criteria.
1. first by $x$-coordinate
2. in case of a tie, by $y$-coordinate
Constraints
* $1 \leq n \leq 100,000$
* $-1,000,000,000 \leq x_i, y_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$x_0 \; y_0$
$x_1 \; y_1$
:
$x_{n-1} \; y_{n-1}$
In the first line, the number of points $n$ is given. In the following $n$ lines, coordinates of each point are given.
Output
Print coordinate of given points in order.
Example
Input
5
4 7
5 5
2 3
6 8
2 1
Output
2 1
2 3
4 7
5 5
6 8
### Response
```cpp
#include <iostream>
#include <queue>
#include <vector>
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
#include <functional>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <map>
using ll=long long;
using namespace std;
//const int INF = 7+(1e+9);
ll GCD(ll x, ll y)
{
if (y == 0)
{
return x;
}
else
{
return GCD(y, x % y);
}
}
ll LCM(ll x, ll y)
{
return x / GCD(x, y) * y;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
vector<vector<char>> vec(12,vector<char>(12));
int dx[]={0,-1,0,1};
int dy[]={1,0,-1,0};
int dfs(int y,int x){
vec[y][x]='5';
for(int i=0;i<4;i++){
if(x+dx[i]<12&&x+dx[i]>=0&&y+dy[i]<12&&y+dy[i]>=0&&vec[dy[i]+y][dx[i]+x]=='1'){
dfs(y+dy[i],x+dx[i]);
}
}
return 0;
}
int main(){
int n;
cin>>n;
vector<pair<int,int>> vec(n);
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
vec[i]=make_pair(x,y);
}
sort(vec.begin(),vec.end());
for(int i=0;i<n;i++){
cout<<vec[i].first<<" "<<vec[i].second<<endl;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Mad scientist Mike has applied for a job. His task is to manage a system of water pumping stations.
The system consists of n pumping stations, which are numbered by integers from 1 to n. Some pairs of stations are connected by bidirectional pipes through which water can flow in either direction (but only in one at a time). For each pipe you know its bandwidth — the maximum number of liters of water that can flow through it in one hour. Each pumping station can pump incoming water from some stations to other stations through the pipes, provided that in one hour the total influx of water to the station is equal to the total outflux of water from the station.
It is Mike's responsibility to pump water between stations. From station a to station b through the pipes (possibly through other stations) within one hour one can transmit a certain number of liters of water according to the rules described above. During this time, water from other stations can not flow into station a, and can not flow out of the station b. However, any amount of water can flow out of station a or in station b. If a total of x litres of water flows out of the station a in an hour, then Mike gets x bollars more to his salary.
To get paid, Mike needs to work for n - 1 days, according to the contract. On the first day he selects two stations v1 and v2, and within one hour he pumps a certain amount of water from v1 to v2. Next, on the i-th day Mike chooses a station vi + 1 that has been never selected before, and pumps a certain amount of water out of the station vi to station vi + 1 for one hour. The quantity of water he pumps on the i-th day does not depend on the amount of water pumped on the (i - 1)-th day.
Mike needs to earn as much bollars as he can for his projects. Help Mike find such a permutation of station numbers v1, v2, ..., vn so Mike will be able to earn the highest possible salary.
Input
The first line of the input contains two space-separated integers n and m (2 ≤ n ≤ 200, 1 ≤ m ≤ 1000) — the number of stations and pipes in the system, accordingly. The i-th of the next m lines contains three space-separated integers ai, bi and ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 100) — the numbers of stations connected by the i-th pipe and the pipe's bandwidth, accordingly. It is guaranteed that any two stations are connected by at most one pipe and that there is a pipe path between any two stations.
Output
On the first line print a single integer — the maximum salary Mike can earn.
On the second line print a space-separated permutation of n numbers from 1 to n — the numbers of stations in the sequence v1, v2, ..., vn. If there are multiple answers, print any of them.
Examples
Input
6 11
1 2 10
1 6 8
2 3 4
2 5 2
2 6 3
3 4 5
3 5 4
3 6 2
4 5 7
4 6 2
5 6 3
Output
77
6 2 1 5 3 4
### Response
```cpp
#include <bits/stdc++.h>
const int N = 200;
const int inf = 1e9;
using namespace std;
struct edges {
int u, v, w;
} edge[N + 5];
int n, m, t[N + 5], t1[N + 5], t2[N + 5], e1[N + 5], e2[N + 5], e[N + 5],
edge_cnt, fa[N + 5], a[N + 5], ans;
namespace F {
const int N = 3e6;
const long long inf = 2e18;
struct edges {
int to;
long long cost;
} edge[N * 2 + 5], e[N * 2 + 5];
int nxt[N * 2 + 5], head[N + 5], edge_cnt = 1, dis[N + 5], q[N + 5], cur[N + 5],
S, T;
void add_edge(int u, int v, long long w) {
edge[++edge_cnt] = (edges){v, w};
nxt[edge_cnt] = head[u];
head[u] = edge_cnt;
}
void add(int u, int v, long long w) {
add_edge(u, v, w);
add_edge(v, u, w);
}
int bfs() {
for (int i = 1; i <= n; i++) cur[i] = head[i], dis[i] = 0;
int l = 1, r = 0;
dis[S] = 1;
q[++r] = S;
while (l <= r) {
int u = q[l++];
for (int i = head[u]; i; i = nxt[i]) {
int v = edge[i].to, w = edge[i].cost;
if (w && !dis[v]) {
dis[v] = dis[u] + 1;
q[++r] = v;
}
}
}
return dis[T];
}
long long dfs(int u, long long flow) {
if (u == T) return flow;
long long sm = 0;
for (int &i = cur[u]; i; i = nxt[i]) {
int v = edge[i].to;
long long w = edge[i].cost;
if (dis[v] == dis[u] + 1 && w) {
long long res = dfs(v, min(w, flow));
edge[i].cost -= res;
edge[i ^ 1].cost += res;
sm += res;
flow -= res;
if (!flow) break;
}
}
return sm;
}
void init() {
for (int i = 2; i <= edge_cnt; i++) e[i] = edge[i];
}
void clear() {
for (int i = 2; i <= edge_cnt; i++) edge[i] = e[i];
}
long long dinic(int s, int t) {
S = s;
T = t;
clear();
long long ans = 0;
while (bfs()) ans += dfs(S, inf);
return ans;
}
} // namespace F
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void build(int l, int r) {
if (l >= r) return;
int val = F::dinic(t[l], t[r]), cnt1 = 0, cnt2 = 0;
edge[++edge_cnt] = (edges){t[l], t[r], val};
for (int i = l; i <= r; i++)
if (F::dis[t[i]])
t1[++cnt1] = t[i];
else
t2[++cnt2] = t[i];
for (int i = 1; i <= cnt1; i++) t[i] = t1[i];
for (int i = 1; i <= cnt2; i++) t[i + cnt1] = t2[i];
build(1, cnt1);
build(cnt1 + 1, cnt2 + cnt1);
}
void solve(int l, int r, int ql, int qr) {
if (l > r) return;
if (l == r) {
a[l] = t[l];
return;
}
for (int i = l; i <= r; i++) fa[t[i]] = t[i];
int mi = inf, id = 0, cnt1 = 0, cnt2 = 0, q1 = 0, q2 = 0;
for (int i = ql; i <= qr; i++)
if (edge[e[i]].w < mi) mi = edge[e[i]].w, id = e[i];
ans += mi;
for (int i = ql; i <= qr; i++)
if (e[i] != id) fa[find(edge[e[i]].u)] = find(edge[e[i]].v);
int x = find(edge[id].u);
for (int i = l; i <= r; i++) {
if (find(t[i]) == x)
t1[++cnt1] = t[i];
else
t2[++cnt2] = t[i];
}
for (int i = ql; i <= qr; i++)
if (e[i] != id) {
if (find(edge[e[i]].u) == x)
e1[++q1] = e[i];
else
e2[++q2] = e[i];
}
for (int i = 1; i <= cnt1; i++) t[i + l - 1] = t1[i];
for (int i = 1; i <= cnt2; i++) t[l + i + cnt1 - 1] = t2[i];
for (int i = 1; i <= q1; i++) e[i + ql - 1] = e1[i];
for (int i = 1; i <= q2; i++) e[i + q1 + ql - 1] = e2[i];
solve(l, l + cnt1 - 1, ql, ql + q1 - 1);
solve(l + cnt1, r, ql + q1, ql + q1 + q2 - 1);
}
int main() {
scanf("%d%d", &n, &m);
int u, v, w;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
F::add(u, v, w);
}
F::init();
for (int i = 1; i <= n; i++) t[i] = i;
build(1, n);
for (int i = 1; i <= n; i++) t[i] = i;
for (int i = 1; i < n; i++) e[i] = i;
solve(1, n, 1, n - 1);
cout << ans << endl;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Let's call two strings s and t anagrams of each other if it is possible to rearrange symbols in the string s to get a string, equal to t.
Let's consider two strings s and t which are anagrams of each other. We say that t is a reducible anagram of s if there exists an integer k ≥ 2 and 2k non-empty strings s_1, t_1, s_2, t_2, ..., s_k, t_k that satisfy the following conditions:
1. If we write the strings s_1, s_2, ..., s_k in order, the resulting string will be equal to s;
2. If we write the strings t_1, t_2, ..., t_k in order, the resulting string will be equal to t;
3. For all integers i between 1 and k inclusive, s_i and t_i are anagrams of each other.
If such strings don't exist, then t is said to be an irreducible anagram of s. Note that these notions are only defined when s and t are anagrams of each other.
For example, consider the string s = "gamegame". Then the string t = "megamage" is a reducible anagram of s, we may choose for example s_1 = "game", s_2 = "gam", s_3 = "e" and t_1 = "mega", t_2 = "mag", t_3 = "e":
<image>
On the other hand, we can prove that t = "memegaga" is an irreducible anagram of s.
You will be given a string s and q queries, represented by two integers 1 ≤ l ≤ r ≤ |s| (where |s| is equal to the length of the string s). For each query, you should find if the substring of s formed by characters from the l-th to the r-th has at least one irreducible anagram.
Input
The first line contains a string s, consisting of lowercase English characters (1 ≤ |s| ≤ 2 ⋅ 10^5).
The second line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
Each of the following q lines contain two integers l and r (1 ≤ l ≤ r ≤ |s|), representing a query for the substring of s formed by characters from the l-th to the r-th.
Output
For each query, print a single line containing "Yes" (without quotes) if the corresponding substring has at least one irreducible anagram, and a single line containing "No" (without quotes) otherwise.
Examples
Input
aaaaa
3
1 1
2 4
5 5
Output
Yes
No
Yes
Input
aabbbbbbc
6
1 2
2 4
2 2
1 9
5 7
3 5
Output
No
Yes
Yes
Yes
No
No
Note
In the first sample, in the first and third queries, the substring is "a", which has itself as an irreducible anagram since two or more non-empty strings cannot be put together to obtain "a". On the other hand, in the second query, the substring is "aaa", which has no irreducible anagrams: its only anagram is itself, and we may choose s_1 = "a", s_2 = "aa", t_1 = "a", t_2 = "aa" to show that it is a reducible anagram.
In the second query of the second sample, the substring is "abb", which has, for example, "bba" as an irreducible anagram.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long LLINF = 1e18 + 7;
int pref[200009][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int n;
string s, t;
int q;
cin >> s >> q;
n = s.size();
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pref[i][j] = pref[i - 1][j];
}
pref[i][s[i - 1] - 'a']++;
}
while (q--) {
int l, r;
cin >> l >> r;
if (r == l) {
cout << "Yes\n";
continue;
}
bool ans = true;
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (pref[r][i] - pref[l - 1][i] > 0) {
cnt++;
}
}
if (s[r - 1] != s[l - 1] || cnt > 2) {
cout << "Yes\n";
continue;
}
if (cnt == 1) {
cout << "No\n";
continue;
}
cout << "No\n";
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, ma = -1;
string S;
cin >> N >> S;
for (int i = 1; i < N; i++) {
set<char> l;
set<char> r;
int count = 0;
for (int j = 0; j < i; j++) l.insert(S[j]);
for (int j = i; j < N; j++) r.insert(S[j]);
for (auto c : l) {
if (r.find(c) != end(r)) count++;
}
ma = max(ma, count);
}
cout << ma << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Lenny is playing a game on a 3 × 3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on.
Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.
Input
The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The j-th number in the i-th row is the number of times the j-th light of the i-th row of the grid is pressed.
Output
Print three lines, each containing three characters. The j-th character of the i-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".
Examples
Input
1 0 0
0 0 0
0 0 1
Output
001
010
100
Input
1 0 1
8 8 8
2 0 3
Output
010
011
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n = 3;
int grid[n][n];
int ans[n][n];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int s = 0;
s += (i ? grid[i - 1][j] : 0);
s += (j ? grid[i][j - 1] : 0);
s += (j + 1 < n ? grid[i][j + 1] : 0);
s += (i + 1 < n ? grid[i + 1][j] : 0);
s += grid[i][j];
ans[i][j] = !(s & 1);
cout << ans[i][j];
}
cout << endl;
}
}
int main() {
solve();
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given an array consisting of n integers a_1, a_2, ..., a_n, and a positive integer m. It is guaranteed that m is a divisor of n.
In a single move, you can choose any position i between 1 and n and increase a_i by 1.
Let's calculate c_r (0 ≤ r ≤ m-1) — the number of elements having remainder r when divided by m. In other words, for each remainder, let's find the number of corresponding elements in a with that remainder.
Your task is to change the array in such a way that c_0 = c_1 = ... = c_{m-1} = n/m.
Find the minimum number of moves to satisfy the above requirement.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ n). It is guaranteed that m is a divisor of n.
The second line of input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9), the elements of the array.
Output
In the first line, print a single integer — the minimum number of moves required to satisfy the following condition: for each remainder from 0 to m - 1, the number of elements of the array having this remainder equals n/m.
In the second line, print any array satisfying the condition and can be obtained from the given array with the minimum number of moves. The values of the elements of the resulting array must not exceed 10^{18}.
Examples
Input
6 3
3 2 0 6 10 12
Output
3
3 2 0 7 10 14
Input
4 2
0 1 2 3
Output
0
0 1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int val = n / m;
vector<vector<int>> v(m);
for (int i = 0; i < n; i++) v[a[i] % m].push_back(i);
long long ans = 0;
vector<pair<int, int>> fre;
for (int i = 0; i < 2 * m; ++i) {
int cur = i % m;
while (int(v[cur].size()) > val) {
int elem = v[cur].back();
v[cur].pop_back();
fre.push_back(make_pair(elem, i));
}
while (int(v[cur].size()) < val && !fre.empty()) {
int elem = fre.back().first;
int mmod = fre.back().second;
fre.pop_back();
v[cur].push_back(elem);
a[elem] += i - mmod;
ans += i - mmod;
}
}
cout << ans << endl;
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Write a program which reverses a given string str.
Input
str (the size of str ≤ 20) is given in a line.
Output
Print the reversed str in a line.
Example
Input
w32nimda
Output
admin23w
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main(){
string str;
cin>>str;
reverse(str.begin(),str.end());
cout<<str<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given an undirected graph consisting of n vertices. Initially there are no edges in the graph. Also you are given q queries, each query either adds one undirected edge to the graph or removes it. After each query you have to check if the resulting graph is bipartite (that is, you can paint all vertices of the graph into two colors so that there is no edge connecting two vertices of the same color).
Input
The first line contains two integers n and q (2 ≤ n, q ≤ 100000).
Then q lines follow. ith line contains two numbers xi and yi (1 ≤ xi < yi ≤ n). These numbers describe ith query: if there is an edge between vertices xi and yi, then remove it, otherwise add it.
Output
Print q lines. ith line must contain YES if the graph is bipartite after ith query, and NO otherwise.
Example
Input
3 5
2 3
1 3
1 2
1 2
1 2
Output
YES
YES
NO
YES
NO
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
std::unordered_map<int, int> used[100010];
bool ans[100010];
bool have;
int fa[100010], dis[100010], size[100010];
int fx, fy;
int find(int x) { return fa[x] == x ? x : find(fa[x]); }
int get(int x) {
int ret = 0;
while (fa[x] != x) {
ret ^= dis[x];
x = fa[x];
}
return ret;
}
bool insert(int a, int b) {
have = false;
if (find(a) == find(b)) {
return get(a) != get(b);
} else {
have = true;
fx = find(a);
fy = find(b);
if (size[fx] > size[fy]) std::swap(fx, fy);
fa[fx] = fy;
size[fy] += size[fx];
dis[fx] ^= get(a) ^ get(b) ^ 1;
return true;
}
}
void erase(int a, int b) {
fa[a] = a;
size[b] -= size[a];
dis[a] = 0;
}
struct SEG_Tree {
struct SEG {
int l;
int r;
std::vector<std::pair<int, int> > vec;
} t[800010];
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
}
void modify(int cur, int l, int r, std::pair<int, int> c) {
if (t[cur].l > r || t[cur].r < l) return;
if (t[cur].l >= l && t[cur].r <= r) {
t[cur].vec.push_back(c);
return;
}
modify(((cur) << 1), l, r, c);
modify(((cur) << 1 | 1), l, r, c);
}
void solve(int cur, bool flg) {
std::vector<std::pair<int, int> > v2;
for (int i = 0; i < t[cur].vec.size(); i++) {
flg &= insert(t[cur].vec[i].first, t[cur].vec[i].second);
if (have) v2.push_back(std::make_pair(fx, fy));
}
if (t[cur].l == t[cur].r) {
ans[t[cur].l] = flg;
} else {
solve(((cur) << 1), flg);
solve(((cur) << 1 | 1), flg);
}
for (int i = v2.size() - 1; i >= 0; i--) erase(v2[i].first, v2[i].second);
}
} t;
int x[100010], y[100010];
int main() {
int ti = clock();
int n = inp();
int q = inp();
t.build(1, 1, q);
for (register int i = 1; i <= n; i++) {
fa[i] = i;
size[i] = 1;
}
for (register int i = 1; i <= q; i++) {
x[i] = inp();
y[i] = inp();
if (used[x[i]][y[i]]) {
t.modify(1, used[x[i]][y[i]], i - 1, std::make_pair(x[i], y[i]));
used[x[i]][y[i]] = 0;
} else {
used[x[i]][y[i]] = i;
}
}
for (register int i = q; i >= 1; i--) {
if (used[x[i]][y[i]]) {
t.modify(1, used[x[i]][y[i]], q, std::make_pair(x[i], y[i]));
used[x[i]][y[i]] = 0;
}
}
t.solve(1, true);
for (int i = 1; i <= q; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cmp(int a, int b) { return b < a; }
int main() {
int n;
while (~scanf("%d", &n)) {
int a[10001];
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n, cmp);
int h1[2] = {0};
int count = 0;
int flag = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == a[i + 1]) {
a[i] = a[i + 1] = 0;
i++;
count++;
if (count % 2 == 0) {
flag++;
}
}
}
printf("%d\n", flag);
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Andrew skipped lessons on the subject 'Algorithms and Data Structures' for the entire term. When he came to the final test, the teacher decided to give him a difficult task as a punishment.
The teacher gave Andrew an array of n numbers a1, ..., an. After that he asked Andrew for each k from 1 to n - 1 to build a k-ary heap on the array and count the number of elements for which the property of the minimum-rooted heap is violated, i.e. the value of an element is less than the value of its parent.
Andrew looked up on the Wikipedia that a k-ary heap is a rooted tree with vertices in elements of the array. If the elements of the array are indexed from 1 to n, then the children of element v are elements with indices k(v - 1) + 2, ..., kv + 1 (if some of these elements lie outside the borders of the array, the corresponding children are absent). In any k-ary heap every element except for the first one has exactly one parent; for the element 1 the parent is absent (this element is the root of the heap). Denote p(v) as the number of the parent of the element with the number v. Let's say that for a non-root element v the property of the heap is violated if av < ap(v).
Help Andrew cope with the task!
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105).
The second line contains n space-separated integers a1, ..., an ( - 109 ≤ ai ≤ 109).
Output
in a single line print n - 1 integers, separate the consecutive numbers with a single space — the number of elements for which the property of the k-ary heap is violated, for k = 1, 2, ..., n - 1.
Examples
Input
5
1 5 4 3 2
Output
3 2 1 0
Input
6
2 2 2 2 2 2
Output
0 0 0 0 0
Note
Pictures with the heaps for the first sample are given below; elements for which the property of the heap is violated are marked with red.
<image> <image> <image> <image>
In the second sample all elements are equal, so the property holds for all pairs.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long w = 0, h = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') h = -h;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
w = w * 10 + ch - '0';
ch = getchar();
}
return w * h;
}
struct node {
long long val, id;
bool operator<(const node& p) const {
if (val == p.val) return id < p.id;
return val < p.val;
}
} a[200010];
long long n, k, c[200010], res, ans[200010];
void modify(long long x) {
for (; x <= n; x += x & (-x)) c[x]++;
}
long long ask(long long x) {
for (res = 0; x; x -= x & (-x)) res += c[x];
return res;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i].val = read(), a[i].id = i;
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
long long j = a[i].id;
for (k = 1; k * (j - 1) + 2 <= n && k < n; k++) {
long long l = k * (j - 1) + 2, r = min(n, k * j + 1);
ans[k] += ask(r) - ask(l - 1);
}
modify(a[i].id);
}
for (long long i = 1; i < n; i++) printf("%lld ", ans[i]);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Write a program which print coordinates $(x_i, y_i)$ of given $n$ points on the plane by the following criteria.
1. first by $x$-coordinate
2. in case of a tie, by $y$-coordinate
Constraints
* $1 \leq n \leq 100,000$
* $-1,000,000,000 \leq x_i, y_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$x_0 \; y_0$
$x_1 \; y_1$
:
$x_{n-1} \; y_{n-1}$
In the first line, the number of points $n$ is given. In the following $n$ lines, coordinates of each point are given.
Output
Print coordinate of given points in order.
Example
Input
5
4 7
5 5
2 3
6 8
2 1
Output
2 1
2 3
4 7
5 5
6 8
### Response
```cpp
#include <cstdio>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in(gcu());}
_sc(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
template <typename H,typename... T> _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
template <typename T>
_vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for (char c: s) pcu(c);}
template <typename H,typename... T> _vo(H&& h, T&&... t){out(h);out(move(t)...);}
template <typename T> _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
_vl(){out('\n');}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
int main() {
vector<pair<int, int>> v(in());
for (auto &p: v)
p = {in(), in()};
sort(v.begin(), v.end());
for (auto p: v)
outl(p.first, ' ', p.second);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Nick's company employed n people. Now Nick needs to build a tree hierarchy of «supervisor-surbodinate» relations in the company (this is to say that each employee, except one, has exactly one supervisor). There are m applications written in the following form: «employee ai is ready to become a supervisor of employee bi at extra cost ci». The qualification qj of each employee is known, and for each application the following is true: qai > qbi.
Would you help Nick calculate the minimum cost of such a hierarchy, or find out that it is impossible to build it.
Input
The first input line contains integer n (1 ≤ n ≤ 1000) — amount of employees in the company. The following line contains n space-separated numbers qj (0 ≤ qj ≤ 106)— the employees' qualifications. The following line contains number m (0 ≤ m ≤ 10000) — amount of received applications. The following m lines contain the applications themselves, each of them in the form of three space-separated numbers: ai, bi and ci (1 ≤ ai, bi ≤ n, 0 ≤ ci ≤ 106). Different applications can be similar, i.e. they can come from one and the same employee who offered to become a supervisor of the same person but at a different cost. For each application qai > qbi.
Output
Output the only line — the minimum cost of building such a hierarchy, or -1 if it is impossible to build it.
Examples
Input
4
7 2 3 1
4
1 2 5
2 4 1
3 4 1
1 3 5
Output
11
Input
3
1 2 3
2
3 1 2
3 1 3
Output
-1
Note
In the first sample one of the possible ways for building a hierarchy is to take applications with indexes 1, 2 and 4, which give 11 as the minimum total cost. In the second sample it is impossible to build the required hierarchy, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD2 = 998244353;
const long long N = 5000 * 100 + 1;
const long long N2 = 1000 * 1000 + 5;
const long double PI = 3.14159265;
const long long R = 250;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
const long long MAX = 1e4 + 5;
long long id[MAX], nodes, edges;
pair<long long, pair<long long, long long> > p[MAX];
long long vis[N2];
void initialize() {
for (long long i = 0; i < MAX; ++i) id[i] = i;
}
long long root(long long x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(long long x, long long y) {
long long p = root(x);
long long q = root(y);
id[q] = id[p];
}
long long kruskal(pair<long long, pair<long long, long long> > p[]) {
long long x, y;
long long cost, minimumCost = 0;
for (long long i = 0; i < edges; ++i) {
x = p[i].second.first;
y = p[i].second.second;
cost = p[i].first;
if (root(x) != root(y) && !vis[y]) {
vis[y] = 1;
minimumCost += cost;
union1(x, y);
}
}
return minimumCost;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x, y;
memset(vis, 0, sizeof(vis));
long long weight, cost, minimumCost;
initialize();
cin >> nodes;
long long q[N2];
for (long long i = 1; i <= nodes; i++) {
cin >> q[i];
}
cin >> edges;
for (long long i = 0; i < edges; ++i) {
cin >> x >> y >> weight;
if (q[x] <= q[y]) continue;
p[i] = make_pair(weight, make_pair(x, y));
}
sort(p, p + edges);
minimumCost = kruskal(p);
long long c = 0;
for (long long i = 1; i <= nodes; i++) {
if (id[i] == i) {
c++;
}
}
if (c == 1)
cout << minimumCost << "\n";
else
cout << -1 << "\n";
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Joisino has a formula consisting of N terms: A_1 op_1 A_2 ... op_{N-1} A_N. Here, A_i is an integer, and op_i is an binary operator either `+` or `-`. Because Joisino loves large numbers, she wants to maximize the evaluated value of the formula by inserting an arbitrary number of pairs of parentheses (possibly zero) into the formula. Opening parentheses can only be inserted immediately before an integer, and closing parentheses can only be inserted immediately after an integer. It is allowed to insert any number of parentheses at a position. Your task is to write a program to find the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Constraints
* 1≦N≦10^5
* 1≦A_i≦10^9
* op_i is either `+` or `-`.
Input
The input is given from Standard Input in the following format:
N
A_1 op_1 A_2 ... op_{N-1} A_N
Output
Print the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Examples
Input
3
5 - 1 - 3
Output
7
Input
5
1 - 2 + 3 - 4 + 5
Output
5
Input
5
1 - 20 - 13 + 14 - 5
Output
13
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN = 100005;
int n, x[MAXN], op[MAXN];
LL ans, rs[MAXN], suf[MAXN];
int main () {
scanf("%d", &n);
char ch[2]; op[1] = 1;
for(int i = 1; i < n; ++i) {
scanf("%d%s", &x[i], ch); op[i+1] = ch[0]=='+'?1:-1;
ans += x[i]*op[i];
}
scanf("%d", &x[n]); ans += x[n]*op[n];
for(int i = n; i >= 1; --i)
rs[i] = (op[i+1] == 1 ? rs[i+1] : 0) + x[i],
suf[i] = suf[i+1] + x[i];
LL pre = 0;
for(int i = 1; i <= n; pre += x[i]*op[i], ++i)
if(op[i] == -1 ) {
ans = max(ans, pre + suf[i] - 2*rs[i]);
}
printf("%lld\n", ans);
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built n towers in a row. The i-th tower is made of hi identical blocks. For clarification see picture for the first sample.
Limak will repeat the following operation till everything is destroyed.
Block is called internal if it has all four neighbors, i.e. it has each side (top, left, down and right) adjacent to other block or to the floor. Otherwise, block is boundary. In one operation Limak destroys all boundary blocks. His paws are very fast and he destroys all those blocks at the same time.
Limak is ready to start. You task is to count how many operations will it take him to destroy all towers.
Input
The first line contains single integer n (1 ≤ n ≤ 105).
The second line contains n space-separated integers h1, h2, ..., hn (1 ≤ hi ≤ 109) — sizes of towers.
Output
Print the number of operations needed to destroy all towers.
Examples
Input
6
2 1 4 6 2 2
Output
3
Input
7
3 3 3 1 3 3 3
Output
2
Note
The picture below shows all three operations for the first sample test. Each time boundary blocks are marked with red color.
<image> After first operation there are four blocks left and only one remains after second operation. This last block is destroyed in third operation.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a;
vector<int> v, l, r;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
v.push_back(x);
}
int c = 1;
for (int i = 0; i < n; i++) {
l.push_back(min(c, v[i]));
c = min(c, v[i]) + 1;
}
c = 1;
for (int i = n - 1; i >= 0; i--) {
r.push_back(min(c, v[i]));
c = min(c, v[i]) + 1;
}
reverse(r.begin(), r.end());
int res = 0;
for (int i = 0; i < n; i++) res = max(res, min(l[i], r[i]));
cout << res << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Write a program which prints multiplication tables in the following format:
1x1=1
1x2=2
.
.
9x8=72
9x9=81
Input
No input.
Output
1x1=1
1x2=2
.
.
9x8=72
9x9=81
Example
Input
Output
### Response
```cpp
#include <stdio.h>
int main()
{ int i,j;
for(i=1;i<=9;i++)
for(j=1;j<=9;j++)
printf("%dx%d=%d\n",i,j,i*j);
return(0);
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int isPrime(int n) {
int i, key = 1;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
key = 0;
break;
}
}
return key;
}
int main() {
int n;
cin >> n;
if (isPrime(n))
cout << "1" << endl;
else if (n % 2 == 0)
cout << "2" << endl;
else if (isPrime(n - 2))
cout << "2" << endl;
else
cout << "3" << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Levko has an array that consists of integers: a1, a2, ... , an. But he doesn’t like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
It’s time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 ≤ ai ≤ 109).
Output
A single number — the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
int n, k;
int a[N];
int dp[N];
bool Judge(long long x) {
int i, j;
for (i = 0; i <= n; i++) dp[i] = i;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++)
if (x * (j - i) >= abs(a[j] - a[i]))
dp[j] = min(dp[j], dp[i] + j - i - 1);
dp[n] = min(dp[n], dp[i] + n - i - 1);
}
if (dp[n] <= k) return true;
return false;
}
int main() {
scanf("%d%d", &n, &k);
int i;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
long long l = 0, r = (1ll << 31) - 1, mid;
int ret;
while (l + 1 < r) {
mid = (l + r) / 2;
if (Judge(mid))
r = mid;
else
l = mid;
}
if (Judge(l))
printf("%d\n", l);
else
printf("%d\n", r);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Consider the decimal presentation of an integer. Let's call a number d-magic if digit d appears in decimal presentation of the number on even positions and nowhere else.
For example, the numbers 1727374, 17, 1 are 7-magic but 77, 7, 123, 34, 71 are not 7-magic. On the other hand the number 7 is 0-magic, 123 is 2-magic, 34 is 4-magic and 71 is 1-magic.
Find the number of d-magic numbers in the segment [a, b] that are multiple of m. Because the answer can be very huge you should only find its value modulo 109 + 7 (so you should find the remainder after dividing by 109 + 7).
Input
The first line contains two integers m, d (1 ≤ m ≤ 2000, 0 ≤ d ≤ 9) — the parameters from the problem statement.
The second line contains positive integer a in decimal presentation (without leading zeroes).
The third line contains positive integer b in decimal presentation (without leading zeroes).
It is guaranteed that a ≤ b, the number of digits in a and b are the same and don't exceed 2000.
Output
Print the only integer a — the remainder after dividing by 109 + 7 of the number of d-magic numbers in segment [a, b] that are multiple of m.
Examples
Input
2 6
10
99
Output
8
Input
2 0
1
9
Output
4
Input
19 7
1000
9999
Output
6
Note
The numbers from the answer of the first example are 16, 26, 36, 46, 56, 76, 86 and 96.
The numbers from the answer of the second example are 2, 4, 6 and 8.
The numbers from the answer of the third example are 1767, 2717, 5757, 6707, 8797 and 9747.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long M = 2001;
const long long N = 2001;
const long long D = 10;
long long dp[N][M][2];
vector<long long> v;
long long m, d, n;
long long mod = 1e9 + 7;
long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long solve(long long idx, long long rem, long long flag) {
if (idx == n) {
return (rem == 0);
}
if (dp[idx][rem][flag] != -1) return dp[idx][rem][flag];
long long ans = 0;
if (idx % 2 == 0) {
long long up;
if (flag == 0) {
up = v[idx];
} else {
up = 9;
}
for (long long i = 0; i <= up; i++) {
if (i == d) continue;
if (idx == 0 && i == 0) continue;
if (i < v[idx]) {
ans = add(ans, solve(idx + 1, (rem * 10 + i) % m, 1));
} else {
ans = add(ans, solve(idx + 1, (rem * 10 + i) % m, flag));
}
}
} else {
if (flag == 0) {
if (d < v[idx])
ans = solve(idx + 1, (rem * 10 + d) % m, 1);
else if (d == v[idx])
ans = solve(idx + 1, (rem * 10 + d) % m, 0);
} else {
ans = solve(idx + 1, (rem * 10 + d) % m, flag);
}
}
dp[idx][rem][flag] = ans;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> m >> d;
string aa, bb;
cin >> aa;
cin >> bb;
for (auto i : bb) {
v.push_back(i - '0');
}
n = (long long)v.size();
memset(dp, -1, sizeof(dp));
long long r = solve(0, 0, 0);
memset(dp, -1, sizeof(dp));
v.clear();
for (auto i : aa) {
v.push_back(i - '0');
}
n = v.size();
if (v[n - 1] == 0) {
v[n - 1] = 9;
long long idx = n - 2;
while (idx >= 0 && v[idx] == 0) {
v[idx] = 9;
idx--;
}
v[idx]--;
} else
v[n - 1]--;
long long l = solve(0, 0, 0);
long long ans = sub(r, l);
cout << ans;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
vector<int> adj[MAXN];
int dp[MAXN][2];
int ans;
void merge(array<int, 2> &a, int x) {
if (x > a[0]) {
swap(a[0], a[1]);
a[0] = x;
return;
}
if (x > a[1]) a[1] = x;
}
void dfs(int s, int p = 0) {
array<int, 2> owo = {0, 0}, uwu = {0, 0};
dp[s][1] = 1;
for (auto v : adj[s]) {
if (v == p) continue;
dfs(v, s);
dp[s][0] = max(dp[s][0],
max(dp[v][0], dp[v][1]) + (int)adj[s].size() - 2 + (s == 0));
dp[s][1] = max(dp[s][1], 1 + dp[v][0]);
merge(owo, dp[v][0]);
merge(uwu, max(dp[v][0], dp[v][1]));
}
ans = max(ans, dp[s][0]);
ans = max(ans, dp[s][1]);
ans = max(ans, uwu[0] + uwu[1] + (int)adj[s].size() - 2);
ans = max(ans, owo[0] + owo[1] + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
ans = 0;
dfs(1);
cout << ans << '\n';
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
We'll call string s[a, b] = sasa + 1... sb (1 ≤ a ≤ b ≤ |s|) a substring of string s = s1s2... s|s|, where |s| is the length of string s.
The trace of a non-empty string t is a set of characters that the string consists of. For example, the trace of string "aab" equals {'a', 'b'}.
Let's consider an arbitrary string s and the set of its substrings with trace equal to C. We will denote the number of substrings from this set that are maximal by inclusion by r(C, s). Substring s[a, b] of length n = b - a + 1 belonging to some set is called maximal by inclusion, if there is no substring s[x, y] in this set with length greater than n, such that 1 ≤ x ≤ a ≤ b ≤ y ≤ |s|. Two substrings of string s are considered different even if they are equal but they are located at different positions of s.
Polycarpus got a challenging practical task on a stringology exam. He must do the following: given string s and non-empty sets of characters C1, C2, ..., Cm, find r(Ci, s) for each set Ci. Help Polycarpus to solve the problem as he really doesn't want to be expelled from the university and go to the army!
Input
The first line contains a non-empty string s (1 ≤ |s| ≤ 106).
The second line contains a single integer m (1 ≤ m ≤ 104). Next m lines contain descriptions of sets Ci. The i-th line contains string ci such that its trace equals Ci. It is guaranteed that all characters of each string ci are different.
Note that Ci are not necessarily different. All given strings consist of lowercase English letters.
Output
Print m integers — the i-th integer must equal r(Ci, s).
Examples
Input
aaaaa
2
a
a
Output
1
1
Input
abacaba
3
ac
ba
a
Output
1
2
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int M = 1e4 + 10;
int s[30];
short mp[1 << 26], tot;
int ans[M];
void init() {
memset(s, 0, sizeof(s));
for (int i = 0; i < 26; i++) {
s[i] = 1 << i;
}
}
int up(int aa[N], int l1, int bb[N], int l2) {
for (int i = 0; i < l1; i++) {
if (aa[i] == bb[0]) continue;
bb[l2++] = aa[i];
}
return l2;
}
void up1(int aa[N], int l1, int next) {
int mask = 0;
for (int i = 0; i < l1; i++) {
if (aa[i] == next) break;
mask |= s[aa[i]];
ans[mp[mask]]++;
}
}
char ss[N], tt[30];
int fun() {
int n = strlen(tt);
int mask = 0;
for (int i = 0; i < n; i++) {
mask |= s[tt[i] - 'a'];
}
return mask;
}
int aa[M];
int sta[2][N], top[2];
int main() {
init();
while (scanf("%s", ss) != EOF) {
int n = strlen(ss), m = 1;
for (int i = 1; i < n; i++) {
if (ss[i] == ss[i - 1])
continue;
else
ss[m++] = ss[i];
}
n = m;
int q;
scanf("%d", &q);
memset(mp, 0, sizeof(mp));
memset(ans, 0, sizeof(ans));
tot = 0;
for (int i = 0; i < q; i++) {
scanf("%s", tt);
aa[i] = fun();
if (mp[aa[i]] == 0) {
mp[aa[i]] = ++tot;
}
}
top[0] = top[1] = 0;
int id = 0;
for (int i = 0; i < n; i++) {
top[id] = 1;
sta[id][0] = ss[i] - 'a';
top[id] = up(sta[id ^ 1], top[id ^ 1], sta[id], top[id]);
if (i + 1 < n)
up1(sta[id], top[id], ss[i + 1] - 'a');
else
up1(sta[id], top[id], -1);
id ^= 1;
}
for (int i = 0; i < q; i++) {
printf("%d\n", ans[mp[aa[i]]]);
}
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
The determinant of a matrix 2 × 2 is defined as follows:
<image>
A matrix is called degenerate if its determinant is equal to zero.
The norm ||A|| of a matrix A is defined as a maximum of absolute values of its elements.
You are given a matrix <image>. Consider any degenerate matrix B such that norm ||A - B|| is minimum possible. Determine ||A - B||.
Input
The first line contains two integers a and b (|a|, |b| ≤ 109), the elements of the first row of matrix A.
The second line contains two integers c and d (|c|, |d| ≤ 109) the elements of the second row of matrix A.
Output
Output a single real number, the minimum possible value of ||A - B||. Your answer is considered to be correct if its absolute or relative error does not exceed 10 - 9.
Examples
Input
1 2
3 4
Output
0.2000000000
Input
1 0
0 1
Output
0.5000000000
Note
In the first sample matrix B is <image>
In the second sample matrix B is <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d;
scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
double l = 0, r = 1e9;
int j = 0;
while (r - l >= -1e9 && j <= 100000) {
double mid = (r + l) / 2;
double a1 = a + mid, a2 = a - mid, b1 = b + mid, b2 = b - mid, c1 = c + mid,
c2 = c - mid, d1 = d + mid, d2 = d - mid;
double l1, r1, l2, r2;
l1 = min(a1 * d1, min(a1 * d2, min(a2 * d1, a2 * d2)));
r1 = max(a1 * d1, max(a1 * d2, max(a2 * d1, a2 * d2)));
l2 = min(b1 * c1, min(b1 * c2, min(b2 * c1, b2 * c2)));
r2 = max(b1 * c1, max(b1 * c2, max(b2 * c1, b2 * c2)));
if (l1 <= r2 && l2 <= r1)
r = mid;
else
l = mid;
j++;
}
printf("%.10f\n", l);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void frepik() {}
const int N = (int)1e5 + 1;
const int logN = (int)18;
int mn = (int)1e9 + 9;
int main() {
frepik();
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]), mn = min(mn, a[i]);
if (k == 1) printf("%d", mn), exit(0);
if (k == 2) {
int p = 0;
int mx = (int)-1e9 - 1;
for (int i = 0; i < n; i++) {
if (a[i] > mx) mx = a[i], p = i;
}
if (p == 0 || p == n - 1)
printf("%d", mx);
else
printf("%d", max(a[0], a[n - 1]));
exit(0);
}
sort(a, a + n);
printf("%d", a[n - 1]);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[n], i, j;
int x = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (j = 0; j < n - 2; j++) {
if (a[j] == 1 && a[j + 1] == 0 && a[j + 2] == 1) {
a[j + 2] = 0;
x++;
}
}
printf("%d", x);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Have you ever heard of the unit "○○ tsubo" that expresses the area of land? Since ancient times, one samurai has said the area for making rice to eat in a day.
There is a land of a [m] x b [m]. Enter a and b and create a program that outputs the tsubo area S [tsubo] of the land. 1 tsubo = 3.305785 [m2], and a and b are integers less than or equal to 100.
input
a b
A and b separated by one space are given on one line.
output
Output the tsubo area S in one line. An error of 0.0001 or less is allowed.
Example
Input
15 25
Output
113.437508
### Response
```cpp
#include<stdio.h>
int main()
{
int a,b;
double t;
scanf("%d%d",&a,&b);
t=(double)(a*b)/3.305785;
printf("%4lf",t);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Bitlandians are quite weird people. They have very peculiar customs.
As is customary, Uncle J. wants to have n eggs painted for Bitruz (an ancient Bitland festival). He has asked G. and A. to do the work.
The kids are excited because just as is customary, they're going to be paid for the job!
Overall uncle J. has got n eggs. G. named his price for painting each egg. Similarly, A. named his price for painting each egg. It turns out that for each egg the sum of the money both A. and G. want for the painting equals 1000.
Uncle J. wants to distribute the eggs between the children so as to give each egg to exactly one child. Also, Uncle J. wants the total money paid to A. to be different from the total money paid to G. by no more than 500.
Help Uncle J. Find the required distribution of eggs or otherwise say that distributing the eggs in the required manner is impossible.
Input
The first line contains integer n (1 ≤ n ≤ 106) — the number of eggs.
Next n lines contain two integers ai and gi each (0 ≤ ai, gi ≤ 1000; ai + gi = 1000): ai is the price said by A. for the i-th egg and gi is the price said by G. for the i-th egg.
Output
If it is impossible to assign the painting, print "-1" (without quotes).
Otherwise print a string, consisting of n letters "G" and "A". The i-th letter of this string should represent the child who will get the i-th egg in the required distribution. Letter "A" represents A. and letter "G" represents G. If we denote the money Uncle J. must pay A. for the painting as Sa, and the money Uncle J. must pay G. for the painting as Sg, then this inequality must hold: |Sa - Sg| ≤ 500.
If there are several solutions, you are allowed to print any of them.
Examples
Input
2
1 999
999 1
Output
AG
Input
3
400 600
400 600
400 600
Output
AGA
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
string sol = "";
ll aSum = 0, gSum = 0;
for (int i = 0; i < n; i++) {
int a, g;
cin >> a >> g;
if (abs(aSum + a - gSum) <= 500) {
aSum += a;
sol += 'A';
} else {
gSum += g;
sol += 'G';
}
}
if (abs(aSum - gSum) > 500) {
cout << -1 << endl;
return;
}
cout << sol << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
A tuple of positive integers {x1, x2, ..., xk} is called simple if for all pairs of positive integers (i, j) (1 ≤ i < j ≤ k), xi + xj is a prime.
You are given an array a with n positive integers a1, a2, ..., an (not necessary distinct). You want to find a simple subset of the array a with the maximum size.
A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.
Let's define a subset of the array a as a tuple that can be obtained from a by removing some (possibly all) elements of it.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — the number of integers in the array a.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Output
On the first line print integer m — the maximum possible size of simple subset of a.
On the second line print m integers bl — the elements of the simple subset of the array a with the maximum size.
If there is more than one solution you can print any of them. You can print the elements of the subset in any order.
Examples
Input
2
2 3
Output
2
3 2
Input
2
2 2
Output
1
2
Input
3
2 1 1
Output
3
1 1 2
Input
2
83 14
Output
2
14 83
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long int arr[2000009], brr[2000009];
int main() {
int test_case = 1;
for (int cs = 1; cs <= test_case; cs++) {
for (int i = 2; i <= 2000009 - 9; i++) {
if (!arr[i]) {
for (int j = i + i; j <= 2000009 - 9; j += i) arr[j] = 1;
}
}
long long int n;
scanf("%lld", &n);
long long int a1 = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &brr[i]);
if (brr[i] == 1) a1++;
}
if (a1) {
long long int b1 = 0;
for (int i = 1; i <= n; i++) {
if (brr[i] != 1 && arr[brr[i] + 1] == 0) {
b1 = brr[i];
break;
}
}
if ((b1 + a1) < 2) {
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (arr[brr[i] + brr[j]] == 0) {
printf("2\n%lld %lld\n", brr[i], brr[j]);
return 0;
}
}
}
}
if (b1)
printf("%lld\n", a1 + 1);
else
printf("%lld\n", a1);
if (b1) printf("%lld ", b1);
while (a1--) printf("1 ");
printf("\n");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (arr[brr[i] + brr[j]] == 0) {
printf("2\n%lld %lld\n", brr[i], brr[j]);
return 0;
}
}
}
printf("1\n%lld\n", brr[1]);
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
### Response
```cpp
#include <iostream>
using namespace std;
int n, c[505], s[505], f[505];
int main() {
int i, j, t;
cin>>n;
for(i=0; i<n-1; i++) cin>>c[i]>>s[i]>>f[i];
for(i=0; i<n; i++) {
for(j=i, t=0; j<n-1; j++) t = max(s[j], (t+f[j]-1)/f[j]*f[j]) + c[j];
cout<<t<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int N = 5e3 + 100;
int n;
int a[N], na[N];
int result[N][N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i; j++) {
result[j][j + i] = a[j];
}
for (int j = 0; j < n - i - 1; j++) {
na[j] = a[j] ^ a[j + 1];
}
for (int j = 0; j < n - i - 1; j++) {
a[j] = na[j];
}
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int l = i, r = i + len - 1;
result[l][r] = max(result[l][r], max(result[l + 1][r], result[l][r - 1]));
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r), l--, r--;
printf("%d\n", result[l][r]);
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons:
* Tetrahedron. Tetrahedron has 4 triangular faces.
* Cube. Cube has 6 square faces.
* Octahedron. Octahedron has 8 triangular faces.
* Dodecahedron. Dodecahedron has 12 pentagonal faces.
* Icosahedron. Icosahedron has 20 triangular faces.
All five kinds of polyhedrons are shown on the picture below:
<image>
Anton has a collection of n polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of polyhedrons in Anton's collection.
Each of the following n lines of the input contains a string si — the name of the i-th polyhedron in Anton's collection. The string can look like this:
* "Tetrahedron" (without quotes), if the i-th polyhedron in Anton's collection is a tetrahedron.
* "Cube" (without quotes), if the i-th polyhedron in Anton's collection is a cube.
* "Octahedron" (without quotes), if the i-th polyhedron in Anton's collection is an octahedron.
* "Dodecahedron" (without quotes), if the i-th polyhedron in Anton's collection is a dodecahedron.
* "Icosahedron" (without quotes), if the i-th polyhedron in Anton's collection is an icosahedron.
Output
Output one number — the total number of faces in all the polyhedrons in Anton's collection.
Examples
Input
4
Icosahedron
Cube
Tetrahedron
Dodecahedron
Output
42
Input
3
Dodecahedron
Octahedron
Octahedron
Output
28
Note
In the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a = 0, b;
string ch;
cin >> n;
for (i = 0; i < n; i++) {
cin >> ch;
if (ch == "Tetrahedron")
a += 4;
else if (ch == "Cube")
a += 6;
else if (ch == "Octahedron")
a += 8;
else if (ch == "Dodecahedron")
a += 12;
else if (ch == "Icosahedron")
a += 20;
}
cout << a << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Allen has a LOT of money. He has n dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are 1, 5, 10, 20, 100. What is the minimum number of bills Allen could receive after withdrawing his entire balance?
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 10^9).
Output
Output the minimum number of bills that Allen could receive.
Examples
Input
125
Output
3
Input
43
Output
5
Input
1000000000
Output
10000000
Note
In the first sample case, Allen can withdraw this with a 100 dollar bill, a 20 dollar bill, and a 5 dollar bill. There is no way for Allen to receive 125 dollars in one or two bills.
In the second sample case, Allen can withdraw two 20 dollar bills and three 1 dollar bills.
In the third sample case, Allen can withdraw 100000000 (ten million!) 100 dollar bills.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int total(int n) {
int total = 0;
if (n >= 100) {
total += n / 100;
n %= 100;
}
if (n >= 20) {
total += n / 20;
n %= 20;
}
if (n >= 10) {
total += n / 10;
n %= 10;
}
if (n >= 5) {
total += n / 5;
n %= 5;
}
if (n >= 1) {
total += n;
}
return total;
}
int main() {
int n;
cin >> n;
cout << total(n) << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given a matrix consisting of digits zero and one, its size is n × m. You are allowed to rearrange its rows. What is the maximum area of the submatrix that only consists of ones and can be obtained in the given problem by the described operations?
Let's assume that the rows of matrix a are numbered from 1 to n from top to bottom and the columns are numbered from 1 to m from left to right. A matrix cell on the intersection of the i-th row and the j-th column can be represented as (i, j). Formally, a submatrix of matrix a is a group of four integers d, u, l, r (1 ≤ d ≤ u ≤ n; 1 ≤ l ≤ r ≤ m). We will assume that the submatrix contains cells (i, j) (d ≤ i ≤ u; l ≤ j ≤ r). The area of the submatrix is the number of cells it contains.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000). Next n lines contain m characters each — matrix a. Matrix a only contains characters: "0" and "1". Note that the elements of the matrix follow without any spaces in the lines.
Output
Print a single integer — the area of the maximum obtained submatrix. If we cannot obtain a matrix of numbers one, print 0.
Examples
Input
1 1
1
Output
1
Input
2 2
10
11
Output
2
Input
4 3
100
011
000
101
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[5005][5005], dp[5005][5005];
int main() {
int t, i, j, n, m, ans, sum;
char ch, str[5005];
vector<int> vec;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("\n");
gets(str);
for (j = 1; j <= m; j++) a[i][j] = str[j - 1] - '0';
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
(a[i][j] == 1) ? dp[i][j] = dp[i][j - 1] + 1 : dp[i][j] = 0;
}
ans = 0;
for (j = 1; j <= m; j++) {
for (i = 1; i <= n; i++) vec.push_back(dp[i][j]);
sort(vec.begin(), vec.end());
for (i = 1; i <= n; i++) ans = max(ans, vec[i - 1] * (n - i + 1));
vec.clear();
}
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Little Chris is very keen on his toy blocks. His teacher, however, wants Chris to solve more problems, so he decided to play a trick on Chris.
There are exactly s blocks in Chris's set, each block has a unique number from 1 to s. Chris's teacher picks a subset of blocks X and keeps it to himself. He will give them back only if Chris can pick such a non-empty subset Y from the remaining blocks, that the equality holds:
<image> "Are you kidding me?", asks Chris.
For example, consider a case where s = 8 and Chris's teacher took the blocks with numbers 1, 4 and 5. One way for Chris to choose a set is to pick the blocks with numbers 3 and 6, see figure. Then the required sums would be equal: (1 - 1) + (4 - 1) + (5 - 1) = (8 - 3) + (8 - 6) = 7.
<image>
However, now Chris has exactly s = 106 blocks. Given the set X of blocks his teacher chooses, help Chris to find the required set Y!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 5·105), the number of blocks in the set X. The next line contains n distinct space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 106), the numbers of the blocks in X.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
In the first line of output print a single integer m (1 ≤ m ≤ 106 - n), the number of blocks in the set Y. In the next line output m distinct space-separated integers y1, y2, ..., ym (1 ≤ yi ≤ 106), such that the required equality holds. The sets X and Y should not intersect, i.e. xi ≠ yj for all i, j (1 ≤ i ≤ n; 1 ≤ j ≤ m). It is guaranteed that at least one solution always exists. If there are multiple solutions, output any of them.
Examples
Input
3
1 4 5
Output
2
999993 1000000
Input
1
1
Output
1
1000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[1001000], cnt;
bool b[1001000];
vector<int> pr;
int main() {
int half = 500000, s = 1000000;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[a[i]] = true;
for (int i = 1; i <= n; i++) {
if (b[s - a[i] + 1]) {
cnt++;
} else
pr.push_back(s - a[i] + 1);
}
cnt /= 2;
for (int i = 1; i <= half; i++) {
if (cnt == 0) break;
if (!b[i] && !b[s - i + 1]) cnt--, pr.push_back(i), pr.push_back(s - i + 1);
}
sort(pr.begin(), pr.end());
printf("%d\n", pr.size());
for (int i = 0; i < pr.size(); i++) printf("%d ", pr[i]);
printf("\n");
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cstdio>
#include <functional>
#define int long long
using namespace std;
const int depth = 16;
class Segtree {
int data[1 << (depth + 1)];
public:
void init() { for (int i = 0; i < (1 << (depth + 1)); i++) data[i] = 0; }
//区間[l, r)にvを足す
void add(int l, int r, int v, int a = 0, int b = (1 << depth), int id = 0) {
if (l >= b || r <= a) return;
if (l <= a && b <= r) { data[id] += v; return; }
add(l, r, v, a, a + (b - a) / 2, id * 2 + 1);
add(l, r, v, a + (b - a) / 2, b, id * 2 + 2);
}
//要素posの値
int getNum(int pos) {
pos = (1 << depth) - 1 + pos;
int ret = data[pos];
while (pos > 0) {
pos = (pos - 1) / 2;
ret += data[pos];
}
return ret;
}
};
Segtree seg;
int getHanten(vector<double> a) {
map<double, int> pos;
int i;
int n = a.size();
seg.init();
for (i = 0; i < n; i++) {
pos[a[i]] = i;
}
for (i = 0; i < n; i++) seg.add(i, i + 1, i);
sort(a.begin(), a.end());
int ans = 0;
for (i = 0; i < n; i++) {
ans += seg.getNum(pos[a[i]]);
seg.add(pos[a[i]] + 1, n, -1);
}
return ans;
}
int n;
int a[40000], b[40000], c[40000];
int countX(double l) {
int i;
typedef pair<double, double> P;
vector<P> ys;
for (i = 0; i < n; i++) {
double y = (c[i] - a[i] * l) / (double)b[i];
double katamuki = -a[i] / (double)b[i];
ys.push_back(P(y, katamuki));
}
sort(ys.begin(), ys.end(), greater<P>());
vector<double> a;
for (i = 0; i < n; i++) {
a.push_back(ys[i].second);
}
return getHanten(a);
}
int countY(double l) {
int i;
typedef pair<double, double> P;
vector<P> xs;
for (i = 0; i < n; i++) {
double x = (c[i] - b[i] * l) / (double)a[i];
double kt = -b[i] / (double)a[i];
xs.push_back(P(x, kt));
}
sort(xs.begin(), xs.end(), greater<P>());
vector<double> a;
for (i = 0; i < n; i++) {
a.push_back(xs[i].second);
}
return getHanten(a);
}
signed main() {
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i] >> b[i] >> c[i];
int k = n * (n - 1) / 2;
double st, ed, mid;
st = -1e+9;
ed = 1e+9;
for (i = 0; i < 70; i++) {
mid = (st + ed) / 2;
if (countX(mid) >= (k - 1) / 2 + 1) { ed = mid; }
else { st = mid; }
}
double ansX = st;
st = -1e+9;
ed = 1e+9;
for (i = 0; i < 70; i++) {
mid = (st + ed) / 2;
if (countY(mid) >= (k - 1) / 2 + 1) { ed = mid; }
else { st = mid; }
}
double ansY = st;
printf("%.14f %.14f\n", ansX, ansY);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Berland has n cities, some of them are connected by bidirectional roads. For each road we know whether it is asphalted or not.
The King of Berland Valera II wants to asphalt all roads of Berland, for that he gathered a group of workers. Every day Valera chooses exactly one city and orders the crew to asphalt all roads that come from the city. The valiant crew fulfilled the King's order in a day, then workers went home.
Unfortunately, not everything is as great as Valera II would like. The main part of the group were gastarbeiters — illegal immigrants who are enthusiastic but not exactly good at understanding orders in Berlandian. Therefore, having received orders to asphalt the roads coming from some of the city, the group asphalted all non-asphalted roads coming from the city, and vice versa, took the asphalt from the roads that had it.
Upon learning of this progress, Valera II was very upset, but since it was too late to change anything, he asked you to make a program that determines whether you can in some way asphalt Berlandian roads in at most n days. Help the king.
Input
The first line contains two space-separated integers n, m <image> — the number of cities and roads in Berland, correspondingly. Next m lines contain the descriptions of roads in Berland: the i-th line contains three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 0 ≤ ci ≤ 1). The first two integers (ai, bi) are indexes of the cities that are connected by the i-th road, the third integer (ci) equals 1, if the road was initially asphalted, and 0 otherwise.
Consider the cities in Berland indexed from 1 to n, and the roads indexed from 1 to m. It is guaranteed that between two Berlandian cities there is not more than one road.
Output
In the first line print a single integer x (0 ≤ x ≤ n) — the number of days needed to asphalt all roads. In the second line print x space-separated integers — the indexes of the cities to send the workers to. Print the cities in the order, in which Valera send the workers to asphalt roads. If there are multiple solutions, print any of them.
If there's no way to asphalt all roads, print "Impossible" (without the quotes).
Examples
Input
4 4
1 2 1
2 4 0
4 3 1
3 2 0
Output
4
3 2 1 3
Input
3 3
1 2 0
2 3 0
3 1 0
Output
Impossible
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
vector<int> g[MAXN];
vector<int> g2[MAXN];
bool mark[MAXN];
vector<int> topo;
inline void addE(int x, int y) {
g[x ^ 1].push_back(y);
g2[y].push_back(x ^ 1);
g[y ^ 1].push_back(x);
g2[x].push_back(y ^ 1);
}
void dfs(int u) {
mark[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!mark[v]) dfs(v);
}
topo.push_back(u);
}
int cc;
int comp[MAXN];
void dfs2(int u) {
mark[u] = true;
comp[u] = cc;
for (int i = 0; i < g2[u].size(); i++) {
int v = g2[u][i];
if (!mark[v]) dfs2(v);
}
}
int ans[MAXN];
vector<int> fans;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
u *= 2;
v *= 2;
if (!w) {
addE(u, v);
addE(u ^ 1, v ^ 1);
} else {
addE(u, v ^ 1);
addE(u ^ 1, v);
}
}
for (int i = 0; i < n * 2; i++)
if (!mark[i]) dfs(i);
memset(mark, 0, sizeof mark);
for (int i = topo.size() - 1; i >= 0; i--) {
int u = topo[i];
if (!mark[u]) {
dfs2(u);
cc++;
}
}
for (int i = 0; i < n * 2; i++)
if (comp[i] == comp[i ^ 1]) {
cout << "Impossible" << endl;
return 0;
}
for (int i = 0; i < topo.size(); i++) {
int u = topo[i];
if (ans[u]) continue;
ans[u] = 1;
ans[u ^ 1] = 2;
}
for (int i = 0; i < n * 2; i += 2)
if (ans[i] == 2) fans.push_back(i / 2 + 1);
cout << fans.size() << endl;
for (int i = 0; i < fans.size(); i++) cout << fans[i] << ' ';
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You have a coins of value n and b coins of value 1. You always pay in exact change, so you want to know if there exist such x and y that if you take x (0 ≤ x ≤ a) coins of value n and y (0 ≤ y ≤ b) coins of value 1, then the total value of taken coins will be S.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The only line of the test case contains four integers a, b, n and S (1 ≤ a, b, n, S ≤ 10^9) — the number of coins of value n, the number of coins of value 1, the value n and the required total value.
Output
For the i-th test case print the answer on it — YES (without quotes) if there exist such x and y that if you take x coins of value n and y coins of value 1, then the total value of taken coins will be S, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
Example
Input
4
1 2 3 4
1 2 3 6
5 2 6 27
3 3 5 18
Output
YES
NO
NO
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long a, b, n, s, t, p, bal, ans;
cin >> t;
while (t--) {
cin >> a >> b >> n >> s;
p = s / n;
ans = min(p, a);
bal = s - ans * n;
if (bal <= b)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a rooted tree. Let's denote d(x) as depth of node x: depth of the root is 1, depth of any other node x is d(y) + 1, where y is a parent of x.
The tree has the following property: every node x with d(x) = i has exactly ai children. Maximum possible depth of a node is n, and an = 0.
We define fk as the number of unordered pairs of vertices in the tree such that the number of edges on the simple path between them is equal to k.
Calculate fk modulo 109 + 7 for every 1 ≤ k ≤ 2n - 2.
Input
The first line of input contains an integer n (2 ≤ n ≤ 5 000) — the maximum depth of a node.
The second line of input contains n - 1 integers a1, a2, ..., an - 1 (2 ≤ ai ≤ 109), where ai is the number of children of every node x such that d(x) = i. Since an = 0, it is not given in the input.
Output
Print 2n - 2 numbers. The k-th of these numbers must be equal to fk modulo 109 + 7.
Examples
Input
4
2 2 2
Output
14 19 20 20 16 16
Input
3
2 3
Output
8 13 6 9
Note
This the tree from the first sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr int inf32 = 0x3f3f3f3f;
constexpr long long inf64 = 0x3f3f3f3f3f3f3f3f;
constexpr int mod = 1000000007;
constexpr int i2 = 500000004;
struct mint {
int first;
mint(int first = 0) : first(first) {}
friend mint operator+(const mint a, const mint &b) {
int first = a.first + b.first;
return mint(first >= mod ? first - mod : first);
}
friend mint operator-(const mint a, const mint &b) {
int first = a.first - b.first;
return mint(first < 0 ? first + mod : first);
}
friend mint operator*(const mint a, const mint &b) {
return mint(1ll * a.first * b.first % mod);
}
friend mint &operator+=(mint &a, const mint &b) { return a = a + b; }
friend mint &operator-=(mint &a, const mint &b) { return a = a - b; }
friend mint &operator*=(mint &a, const mint &b) { return a = a * b; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n, --n;
vector<mint> a(n + 1);
for (int i = 0; i < (n); ++i) cin >> a[i].first;
vector<mint> p(n + 1, 1);
for (int i = 0; i < (n); ++i) p[i + 1] = p[i] * a[i];
vector<mint> dw(a), up(n + 1);
mint res = 0;
for (int j = 0; j < (n); ++j) res += dw[j] * p[j];
cout << res.first << ' ';
for (int i = 0; i < (n * 2 - 1); ++i) {
res = 0;
for (int j = (n)-1; j >= 0; --j) {
up[j + 1] = up[j] * a[j];
up[j + 1] = dw[j] * p[j] * (a[j] - 1) * i2 + up[j + 1];
res += up[j + 1];
}
for (int j = 0; j < (n); ++j) {
dw[j] = dw[j + 1] * a[j];
res += dw[j] * p[j];
}
up[0] = dw[n] = 0;
cout << res.first << ' ';
}
cout << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi has N blue cards and M red cards. A string is written on each card. The string written on the i-th blue card is s_i, and the string written on the i-th red card is t_i.
Takahashi will now announce a string, and then check every card. Each time he finds a blue card with the string announced by him, he will earn 1 yen (the currency of Japan); each time he finds a red card with that string, he will lose 1 yen.
Here, we only consider the case where the string announced by Takahashi and the string on the card are exactly the same. For example, if he announces `atcoder`, he will not earn money even if there are blue cards with `atcoderr`, `atcode`, `btcoder`, and so on. (On the other hand, he will not lose money even if there are red cards with such strings, either.)
At most how much can he earn on balance?
Note that the same string may be written on multiple cards.
Constraints
* N and M are integers.
* 1 \leq N, M \leq 100
* s_1, s_2, ..., s_N, t_1, t_2, ..., t_M are all strings of lengths between 1 and 10 (inclusive) consisting of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
s_2
:
s_N
M
t_1
t_2
:
t_M
Output
If Takahashi can earn at most X yen on balance, print X.
Examples
Input
3
apple
orange
apple
1
grape
Output
2
Input
3
apple
orange
apple
5
apple
apple
apple
apple
apple
Output
1
Input
1
voldemort
10
voldemort
voldemort
voldemort
voldemort
voldemort
voldemort
voldemort
voldemort
voldemort
voldemort
Output
0
Input
6
red
red
blue
yellow
yellow
red
5
red
red
yellow
green
blue
Output
1
### Response
```cpp
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
int main() {
map<string, int> f;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
f[s]++;
}
int M;
cin >> M;
for (int i = 0; i < M; i++) {
string s;
cin >> s;
f[s]--;
}
int ans = 0;
for (auto x : f) ans = max(ans, x.second);
cout << ans << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
One player came to a casino and found a slot machine where everything depends only on how he plays. The rules follow.
A positive integer a is initially on the screen. The player can put a coin into the machine and then add 1 to or subtract 1 from any two adjacent digits. All digits must remain from 0 to 9 after this operation, and the leading digit must not equal zero. In other words, it is forbidden to add 1 to 9, to subtract 1 from 0 and to subtract 1 from the leading 1. Once the number on the screen becomes equal to b, the player wins the jackpot. a and b have the same number of digits.
Help the player to determine the minimal number of coins he needs to spend in order to win the jackpot and tell how to play.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) standing for the length of numbers a and b.
The next two lines contain numbers a and b, each one on a separate line (10^{n-1} ≤ a, b < 10^n).
Output
If it is impossible to win the jackpot, print a single integer -1.
Otherwise, the first line must contain the minimal possible number c of coins the player has to spend.
min(c, 10^5) lines should follow, i-th of them containing two integers d_i and s_i (1≤ d_i≤ n - 1, s_i = ± 1) denoting that on the i-th step the player should add s_i to the d_i-th and (d_i + 1)-st digits from the left (e. g. d_i = 1 means that two leading digits change while d_i = n - 1 means that there are two trailing digits which change).
Please notice that the answer may be very big and in case c > 10^5 you should print only the first 10^5 moves. Your answer is considered correct if it is possible to finish your printed moves to win the jackpot in the minimal possible number of coins. In particular, if there are multiple ways to do this, you can output any of them.
Examples
Input
3
223
322
Output
2
1 1
2 -1
Input
2
20
42
Output
2
1 1
1 1
Input
2
35
44
Output
-1
Note
In the first example, we can make a +1 operation on the two first digits, transforming number 223 into 333, and then make a -1 operation on the last two digits, transforming 333 into 322.
It's also possible to do these operations in reverse order, which makes another correct answer.
In the last example, one can show that it's impossible to transform 35 into 44.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
int d[2][SIZE], n, g[2][SIZE];
long long cal_answer() {
long long an = 0;
for (int i = (1); i < (n); ++i) {
an += abs(g[0][i - 1] - g[1][i - 1]);
g[0][i] += g[1][i - 1] - g[0][i - 1];
}
return an;
}
int need = 100000;
void try_to_add(int id, int v) {
if (d[0][id + 1] + v >= 10 || d[0][id + 1] + v < 0) {
try_to_add(id + 1, -v);
}
d[0][id] += v;
d[0][id + 1] += v;
W(id + 1, v);
need--;
if (!need) exit(0);
}
void check(int id) {
while (d[0][id] < d[1][id]) {
try_to_add(id, 1);
}
while (d[0][id] > d[1][id]) {
try_to_add(id, -1);
}
}
int main() {
R(n);
string s1, s2;
R(s1, s2);
int dif = 0;
for (int i = 0; i < (n); ++i) {
g[0][i] = d[0][i] = s1[i] - '0';
g[1][i] = d[1][i] = s2[i] - '0';
if (i % 2 == 0)
dif += d[0][i] - d[1][i];
else
dif -= d[0][i] - d[1][i];
}
if (dif) {
W(-1);
return 0;
}
W(cal_answer());
for (int i = 0; i < (n - 1); ++i) {
check(i);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
As we all know, Dart is some kind of creature from Upside Down world. For simplicity, we call their kind pollywogs. Dart and x - 1 other pollywogs are playing a game. There are n stones in a row, numbered from 1 through n from left to right. At most 1 pollywog may be sitting on each stone at a time. Initially, the pollywogs are sitting on the first x stones (one pollywog on each stone).
<image>
Dart and his friends want to end up on the last x stones. At each second, the leftmost pollywog should jump to the right. A pollywog can jump at most k stones; more specifically, a pollywog can jump from stone number i to stones i + 1, i + 2, ... i + k. A pollywog can't jump on an occupied stone. Jumping a distance i takes ci amounts of energy from the pollywog.
Also, q stones are special Each time landing on a special stone p, takes wp amounts of energy (in addition to the energy for jump) from the pollywog. wp could be negative, in this case, it means the pollywog absorbs |wp| amounts of energy.
Pollywogs want to spend as little energy as possible (this value could be negative).
They're just pollywogs, so they asked for your help. Tell them the total change in their energy, in case they move optimally.
Input
The first line of input contains four integers, x, k, n and q (1 ≤ x ≤ k ≤ 8, k ≤ n ≤ 108, 0 ≤ q ≤ min(25, n - x)) — the number of pollywogs, the maximum length of jump, the number of stones and the number of special stones.
The next line contains k integers, c1, c2, ... ck, separated by spaces (1 ≤ ci ≤ 109) — the energetic costs of jumps.
The next q lines contain description of the special stones. Each line contains two integers p and wp (x + 1 ≤ p ≤ n, |wp| ≤ 109). All p are distinct.
Output
Print the minimum amount of energy they need, in the first and only line of output.
Examples
Input
2 3 10 2
1 2 3
5 -10
6 1000
Output
6
Input
4 7 85 3
17 5 28 4 52 46 6
59 -76
33 -69
19 2018
Output
135
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <typename T, typename Add = std::plus<T>,
typename Mul = std::multiplies<T>>
struct Matrix {
std::vector<std::vector<T>> D;
Matrix(size_t m, size_t n) {
D.resize(m);
for (size_t i = 0; i < m; ++i) {
D[i].resize(n);
}
}
size_t m() const { return D.size(); }
size_t n() const { return m() == 0 ? 0 : D[0].size(); }
std::vector<T>& operator[](int i) { return D[i]; }
Matrix<T, Add, Mul> operator*(const Matrix<T, Add, Mul>& that) const {
assert(n() == that.m());
Matrix<T, Add, Mul> r(m(), that.n());
for (size_t i = 0; i < m(); ++i) {
for (size_t j = 0; j < that.n(); ++j) {
for (size_t k = 0; k < n(); ++k) {
T tmp = Mul()(D[i][k], that.D[k][j]);
r[i][j] = k == 0 ? tmp : Add()(r[i][j], tmp);
}
}
}
return r;
}
Matrix<T, Add, Mul> operator^(int k) const {
assert(k >= 0);
assert(m() == n());
Matrix<T, Add, Mul> r(1, 1);
bool initial = true;
auto t = *this;
while (k) {
if (k & 1) {
r = initial ? t : r * t;
initial = false;
}
t = t * t;
k >>= 1;
}
return r;
}
void print() const {
for (size_t i = 0; i < m(); ++i) {
for (size_t j = 0; j < n(); ++j) {
std::cout << D[i][j] << ' ';
}
std::cout << std::endl;
}
}
};
const LL INF = 1LL << 61;
LL calcJumpCost(const bitset<10>& from, const bitset<10>& to, int Cost[]) {
assert(from.count() == to.count());
auto shift = to << 1;
auto tmp = from ^ shift;
if (tmp.count() == 0)
return 0;
else if (tmp.count() != 2)
return INF;
else {
int p = 0;
while (!from.test(p)) p++;
if (!tmp.test(p)) return INF;
tmp.reset(p);
int q = 0;
while (!tmp.test(q)) q++;
if (q < p) return INF;
return Cost[q - p];
}
}
template <typename T>
struct Min {
T operator()(T a, T b) { return min({a, b, INF}); }
};
Matrix<LL, Min<LL>, plus<LL>> buildMatrix(const vector<bitset<10>>& V,
int C[]) {
Matrix<LL, Min<LL>, plus<LL>> R(V.size(), V.size());
for (size_t i = 0; i < V.size(); i++) {
for (size_t j = 0; j < V.size(); j++) {
auto from = V[i];
auto to = V[j];
R[i][j] = calcJumpCost(from, to, C);
}
}
return R;
}
int x, k, n, q;
int C[10];
map<int, int> Special;
int main() {
scanf("%d%d%d%d", &x, &k, &n, &q);
vector<bitset<10>> V;
for (int state = 1; state < (1 << k); state++) {
auto bs = bitset<10>(state);
if (int(bs.count()) != x) continue;
V.push_back(bs);
}
for (int i = (1); i <= (k); ++i) scanf("%d", &C[i]);
LL ans = 0;
set<int> S;
for (int i = (1); i <= (q); ++i) {
int p, w;
scanf("%d%d", &p, &w);
if (p >= n - x + 1) {
ans += w;
continue;
}
for (int j = p - k; j <= p; j++) {
if (j <= 1) continue;
S.insert(j);
}
Special[p] = w;
}
S.insert(n - x + 1);
auto Mul = buildMatrix(V, C);
auto A = Mul;
A.D.resize(1);
for (size_t i = 0; i < A.n(); ++i) A[0][i] = INF;
A[0][0] = 0;
int pre = 1;
for (auto cur : S) {
if (cur == pre + 1) {
auto B = A;
for (int j = 0; j < int(V.size()); j++) {
B[0][j] = INF;
for (int i = 0; i < int(V.size()); i++) {
LL update = A[0][i];
auto from = V[i];
auto to = V[j];
update += calcJumpCost(from, to, C);
auto tmp = (from ^ (to << 1)) & (~from);
for (int k = 0; k < 10; k++) {
if (tmp.test(k) && Special.find(k + pre) != Special.end()) {
update += Special[k + pre];
break;
}
}
B[0][j] = min(B[0][j], update);
}
}
A = B;
} else {
A = A * (Mul ^ (cur - pre));
}
pre = cur;
}
cout << A[0][0] + ans << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You got a box with a combination lock. The lock has a display showing n digits. There are two buttons on the box, each button changes digits on the display. You have quickly discovered that the first button adds 1 to all the digits (all digits 9 become digits 0), and the second button shifts all the digits on the display one position to the right (the last digit becomes the first one). For example, if the display is currently showing number 579, then if we push the first button, the display will show 680, and if after that we push the second button, the display will show 068.
You know that the lock will open if the display is showing the smallest possible number that can be obtained by pushing the buttons in some order. The leading zeros are ignored while comparing numbers. Now your task is to find the desired number.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of digits on the display.
The second line contains n digits — the initial state of the display.
Output
Print a single line containing n digits — the desired state of the display containing the smallest possible number.
Examples
Input
3
579
Output
024
Input
4
2014
Output
0142
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1500;
const int INF = 100000000;
string key(string str, int n) {
int i, j, num;
if (str[0] != '0') {
num = 1 + '9' - str[0];
str[0] = '0';
for (i = 1; i < n; i++) {
str[i] += num;
if (str[i] > '9') str[i] -= 10;
}
}
return str;
}
int main() {
int n;
string a;
while (~scanf("%d", &n)) {
int i, j;
string str, str1;
a.clear();
cin >> a;
str1.clear();
for (i = 0; i < n; i++) {
str.clear();
str += a.substr(i, n - i);
if (i > 0) str += a.substr(0, i);
str = key(str, n);
if (i == 0) str1 = str;
if (i != 0) {
str1 = min(str, str1);
}
}
cout << str1 << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Hacker Zhorik wants to decipher two secret messages he intercepted yesterday. Yeah message is a sequence of encrypted blocks, each of them consists of several bytes of information.
Zhorik knows that each of the messages is an archive containing one or more files. Zhorik knows how each of these archives was transferred through the network: if an archive consists of k files of sizes l1, l2, ..., lk bytes, then the i-th file is split to one or more blocks bi, 1, bi, 2, ..., bi, mi (here the total length of the blocks bi, 1 + bi, 2 + ... + bi, mi is equal to the length of the file li), and after that all blocks are transferred through the network, maintaining the order of files in the archive.
Zhorik thinks that the two messages contain the same archive, because their total lengths are equal. However, each file can be split in blocks in different ways in the two messages.
You are given the lengths of blocks in each of the two messages. Help Zhorik to determine what is the maximum number of files could be in the archive, if the Zhorik's assumption is correct.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105) — the number of blocks in the first and in the second messages.
The second line contains n integers x1, x2, ..., xn (1 ≤ xi ≤ 106) — the length of the blocks that form the first message.
The third line contains m integers y1, y2, ..., ym (1 ≤ yi ≤ 106) — the length of the blocks that form the second message.
It is guaranteed that x1 + ... + xn = y1 + ... + ym. Also, it is guaranteed that x1 + ... + xn ≤ 106.
Output
Print the maximum number of files the intercepted array could consist of.
Examples
Input
7 6
2 5 3 1 11 4 4
7 8 2 4 1 8
Output
3
Input
3 3
1 10 100
1 100 10
Output
2
Input
1 4
4
1 1 1 1
Output
1
Note
In the first example the maximum number of files in the archive is 3. For example, it is possible that in the archive are three files of sizes 2 + 5 = 7, 15 = 3 + 1 + 11 = 8 + 2 + 4 + 1 and 4 + 4 = 8.
In the second example it is possible that the archive contains two files of sizes 1 and 110 = 10 + 100 = 100 + 10. Note that the order of files is kept while transferring archives through the network, so we can't say that there are three files of sizes 1, 10 and 100.
In the third example the only possibility is that the archive contains a single file of size 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n);
vector<long long> b(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int i = 0, j = 0;
long long sumi = 0, sumj = 0;
long long res = 0;
while (i < n && j < m) {
if ((sumi + a[i]) == (sumj + b[j])) {
i++, j++;
sumi = 0, sumj = 0;
res++;
continue;
}
if ((sumi + a[i]) < (sumj + b[j])) {
sumi += a[i];
i++;
continue;
}
sumj += b[j];
j++;
}
res += ((i != n) || (j != m));
cout << res << endl;
}
``` |
Subsets and Splits