text
stringlengths 424
69.5k
|
|---|
### Prompt
Generate a Cpp solution to the following problem:
Snuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).
Now, he will perform the following operation exactly once:
* Choose K consecutive elements in P and sort them in ascending order.
Find the number of permutations that can be produced as P after the operation.
Constraints
* 2 \leq N \leq 200000
* 2 \leq K \leq N
* 0 \leq P_i \leq N-1
* P_0,P_1,\cdots,P_{N-1} are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
P_0 P_1 \cdots P_{N-1}
Output
Print the number of permutations that can be produced as P after the operation.
Examples
Input
5 3
0 2 1 4 3
Output
2
Input
4 4
0 1 2 3
Output
1
Input
10 4
2 0 1 3 7 5 4 6 8 9
Output
6
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int n, k;
cin >> n >> k;
vector<int> p(n);
for(int i = 0; i < n; i++) cin >> p[i];
priority_queue<int> q0, q1;
vector<int> fin(n, false);
vector<int> seq(n, 1);
for(int i = 0; i < k; i++){
q0.push(p[i]);
q1.push(-p[i]);
}
for(int i = n - 2; i >= 0; i--){
if(p[i] < p[i + 1]) seq[i] = seq[i + 1] + 1;
}
ll s = 0;
for(int i = 0; i < n; i++){
if(seq[i] == k) s++;
}
ll count = 1;
for(int i = 0; i + k < n; i++){
while(fin[-q1.top()]){
q1.pop();
}
ll c = 0;
if(-q1.top() != p[i]) c = 1;
fin[p[i]] = true;
while(fin[q0.top()]){
q0.pop();
}
q0.push(p[i + k]);
q1.push(-p[i + k]);
if(q0.top() != p[i + k]) c = 1;
count += c;
}
cout << (count - max(s - (ll)1, (ll)0)) << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A linguist, Nodvic Natharus Damenhof (commonly called Dr. Usoperant), invented an artificial language Usoperant in 2007. The word usoperant means βone which tiresβ. Damenhofβs goal was to create a complex and pedantic language that would remind many difficulties in universal communications. Talking in Usoperant, you should remember the importance of choosing your words in many conversations.
For example of the complexity, you may be confused by the way to say large numbers. Usoperant has some words that indicate exponential numbers in decimal, described as 10p where p is a positive integer. In terms of English, those words might include thousand for 103 (1,000), million for 106 (1,000,000), and undecillion for 1036 (1,000,000,000,000,000,000,000,000,000,000,000,000).
You can concatinate those words to express larger numbers. When two words w1 and w2 mean numbers 10p1 and 10p2 respectively, a concatinated word w1w2 means 10p1+p2. Using the above examples in English (actually the following examples are incorrect in English), you can say 109 by millionthousand, 1012 by millionmillion and 1039 by undecillionthousand. Note that there can be multiple different expressions for a certain number. For example, 109 can also be expressed by thousandthousandthousand. It is also possible to insert separators between the adjacent components like million-thousand and thousand-thousand-thousand.
In this problem, you are given a few of such words, their representing digits and an expression of a certain number in Usoperant. Your task is to write a program to calculate the length of the shortest expression which represents the same number as the given expression.
The expressions in the input do not contain any separators like millionthousand. In case of ambiguity, the expressions should be interpreted as the largest number among possibles. The resultant expressions should always contain separators like million-thousand, so we can distinguish, for example, x-x (a concatinated word of two x's) and xx (just a single word). The separators should not be counted in the length.
Note:
In the fourth case, the word abcdefgh can be separated as abcd-efgh (representing 103 ) and abcde-fgh (representing 1010 ), and by the rule described in the problem statement, this word should be interpreted as 1010. As this number can be expressed by yy, the length of the shortest expression is two (as in the sample output). The existence of y-y (representing 1016 ) is not a problem here, because we can distinguish yy and y-y as long as we always use separators.
Input
The input consists of multiple test cases. Each test case begins with a line including an integer N (1 β€ N β€ 100). The integer N indicates the number of words in the dictionary of exponential numbers.
The following N lines give the words in the dictionary. Each line contains a word wi and an integer pi (1 β€ i β€ N, 1 β€ pi β€ 10), specifying that the word wi expresses an exponential number 10pi in Usoperant. Each wi consists of at most 100 alphabetical letters.
Then a line which contains an expression of a number in Usoperant follows. The expression consists of at most 200 alphabetical letters.
The end of the input is indicated by a line which contains only a single 0.
Output
For each test case, print a line which contains the case number and the length of the shortest expression which represents the same number as the given expression in the input.
Example
Input
3
billion 9
million 6
thousand 3
billionmillionthousand
3
oku 8
sen 3
man 4
okusenman
2
nico 2
video 4
niconicovideo
6
abcd 1
efgh 2
abcde 4
fgh 6
y 8
yy 10
abcdefgh
0
Output
Case 1: 14
Case 2: 9
Case 3: 10
Case 4: 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const int INF = 10101010;
int main(){
int cc = 0;
int n;
while(cin >>n,n){
vector<string> s(n);
vector<int> p(n),l(n);
rep(i,n){
cin >>s[i] >>p[i];
l[i] = s[i].size();
}
string t;
cin >>t;
int T = t.size();
vector<int> dp(T+1,-INF);
dp[0] = 0;
rep(i,T){
rep(j,n){
if(i+l[j] > T) continue;
if(s[j] == t.substr(i,l[j])){
dp[i+l[j]] = max(dp[i+l[j]], dp[i]+p[j]);
}
}
}
int V = dp[T];
dp = vector<int>(V+1, INF);
dp[0] = 0;
rep(i,V){
rep(j,n){
int ni = i+p[j];
if(ni > V) continue;
dp[ni] = min(dp[ni], dp[i]+l[j]);
}
}
cout << "Case " << cc+1 << ": " << dp[V] << "\n";
++cc;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 β€ t β€ 10^4) β the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 β€ a, b β€ 1000).
Output
Print t integers β the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
int tc;
cin >> tc;
while (tc--) {
cin >> n >> m;
cout << n + m << '\n';
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Kurohashi has never participated in AtCoder Beginner Contest (ABC).
The next ABC to be held is ABC N (the N-th ABC ever held). Kurohashi wants to make his debut in some ABC x such that all the digits of x in base ten are the same.
What is the earliest ABC where Kurohashi can make his debut?
Constraints
* 100 \leq N \leq 999
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
If the earliest ABC where Kurohashi can make his debut is ABC n, print n.
Examples
Input
111
Output
111
Input
112
Output
222
Input
750
Output
777
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int K;
int main(){
cin>>K;
int res=((K+110)/111)*111;
cout<<res;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
A sweet little monster Om Nom loves candies very much. One day he found himself in a rather tricky situation that required him to think a bit in order to enjoy candies the most. Would you succeed with the same task if you were on his place?
<image>
One day, when he came to his friend Evan, Om Nom didn't find him at home but he found two bags with candies. The first was full of blue candies and the second bag was full of red candies. Om Nom knows that each red candy weighs Wr grams and each blue candy weighs Wb grams. Eating a single red candy gives Om Nom Hr joy units and eating a single blue candy gives Om Nom Hb joy units.
Candies are the most important thing in the world, but on the other hand overeating is not good. Om Nom knows if he eats more than C grams of candies, he will get sick. Om Nom thinks that it isn't proper to leave candy leftovers, so he can only eat a whole candy. Om Nom is a great mathematician and he quickly determined how many candies of what type he should eat in order to get the maximum number of joy units. Can you repeat his achievement? You can assume that each bag contains more candies that Om Nom can eat.
Input
The single line contains five integers C, Hr, Hb, Wr, Wb (1 β€ C, Hr, Hb, Wr, Wb β€ 109).
Output
Print a single integer β the maximum number of joy units that Om Nom can get.
Examples
Input
10 3 5 2 3
Output
16
Note
In the sample test Om Nom can eat two candies of each type and thus get 16 joy units.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
bool smax(T& x, L y) {
return x < y ? x = y, true : false;
}
long long c, wa, wb, ha, hb;
long long mx = -1;
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cerr << "HELLO WORLD :)\n";
cin >> c >> ha >> hb >> wa >> wb;
for (long long i = 0; i <= 1e7 && i * wa <= c; i++)
smax(mx, i * ha + (c - wa * i) / wb * hb);
for (long long i = 0; i <= 1e7 && i * wb <= c; i++)
smax(mx, i * hb + (c - wb * i) / wa * ha);
return cout << (mx == -1 ? 0 : mx) << '\n', false;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Professor Vasechkin is studying evolution of worms. Recently he put forward hypotheses that all worms evolve by division. There are n forms of worms. Worms of these forms have lengths a1, a2, ..., an. To prove his theory, professor needs to find 3 different forms that the length of the first form is equal to sum of lengths of the other two forms. Help him to do this.
Input
The first line contains integer n (3 β€ n β€ 100) β amount of worm's forms. The second line contains n space-separated integers ai (1 β€ ai β€ 1000) β lengths of worms of each form.
Output
Output 3 distinct integers i j k (1 β€ i, j, k β€ n) β such indexes of worm's forms that ai = aj + ak. If there is no such triple, output -1. If there are several solutions, output any of them. It possible that aj = ak.
Examples
Input
5
1 2 3 5 7
Output
3 2 1
Input
5
1 8 1 5 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, x;
vector<int> v;
cin >> n;
bool f = true;
map<int, int> mpp;
map<int, int> mp;
map<int, string> m;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
mp[x] = i;
if (m[x] != "ase") {
m[x] = "ase";
mpp[x] = i;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
x = v[i] + v[j];
if ((m[x] == "ase") &&
(i != j && mp[v[j]] != mp[x] && mp[v[i]] != mp[x])) {
f = false;
cout << mp[x] + 1;
if (mp[v[j]] == mp[v[i]]) {
cout << " " << mp[v[j]] + 1 << " " << mpp[v[j]] + 1 << "\n";
} else {
cout << " " << mp[v[j]] + 1 << " " << mp[v[i]] + 1 << "\n";
}
break;
}
}
if (f == false) {
break;
}
}
if (f == true) {
cout << -1 << "\n";
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 β€ n β€ 200) β the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer β the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long pow(long long B, long long P) {
long long S = 1;
for (long long i = 1; i <= P; i++) S = S * B;
return S;
}
int fx4[] = {1, -1, 0, 0};
int fy4[] = {0, 0, 1, -1};
map<string, vector<string> > graph;
map<string, int> visited;
map<string, int> level;
string same(string S) {
int len = S.length();
for (int i = 0; i < len; i++) {
S[i] = toupper(S[i]);
}
return S;
}
int BFS(string source) {
visited[source] = 1;
queue<string> Q;
Q.push(source);
level[source] = 1;
int MAX = 1;
while (!Q.empty()) {
string u = Q.front();
Q.pop();
for (int i = 0; i < graph[u].size(); i++) {
string v = graph[u][i];
if (visited[v] == 0) {
visited[v] = 1;
Q.push(v);
level[v] = level[u] + 1;
if (level[v] > MAX) MAX = level[v];
}
}
}
return MAX;
}
set<string> nodes;
int main() {
FastIO();
int N;
cin >> N;
string S, X, Y;
for (int i = 0; i < N; i++) {
cin >> X >> S >> Y;
X = same(X);
Y = same(Y);
graph[Y].push_back(X);
nodes.insert(X);
nodes.insert(Y);
}
int ans = BFS("POLYCARP");
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 β€ y β€ 100, 2 β€ b β€ 100, 3 β€ r β€ 100) β the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number β the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int y, b, r;
scanf("%d%d%d", &y, &b, &r);
if (y < b && y < r) {
while (1) {
if (b >= (y + 1) && r >= (y + 2)) {
b = y + 1;
r = y + 2;
break;
} else
y--;
}
} else if (b < y && b < r) {
while (1) {
if (y >= (b - 1) && r >= (b + 1)) {
y = b - 1;
r = b + 1;
break;
} else
b--;
}
} else {
while (1) {
if (y >= (r - 2) && b >= (r - 1)) {
b = r - 1;
y = r - 2;
break;
} else
r--;
}
}
printf("%d\n", y + b + r);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Nura wants to buy k gadgets. She has only s burles for that. She can buy each gadget for dollars or for pounds. So each gadget is selling only for some type of currency. The type of currency and the cost in that currency are not changing.
Nura can buy gadgets for n days. For each day you know the exchange rates of dollar and pound, so you know the cost of conversion burles to dollars or to pounds.
Each day (from 1 to n) Nura can buy some gadgets by current exchange rate. Each day she can buy any gadgets she wants, but each gadget can be bought no more than once during n days.
Help Nura to find the minimum day index when she will have k gadgets. Nura always pays with burles, which are converted according to the exchange rate of the purchase day. Nura can't buy dollars or pounds, she always stores only burles. Gadgets are numbered with integers from 1 to m in order of their appearing in input.
Input
First line contains four integers n, m, k, s (1 β€ n β€ 2Β·105, 1 β€ k β€ m β€ 2Β·105, 1 β€ s β€ 109) β number of days, total number and required number of gadgets, number of burles Nura has.
Second line contains n integers ai (1 β€ ai β€ 106) β the cost of one dollar in burles on i-th day.
Third line contains n integers bi (1 β€ bi β€ 106) β the cost of one pound in burles on i-th day.
Each of the next m lines contains two integers ti, ci (1 β€ ti β€ 2, 1 β€ ci β€ 106) β type of the gadget and it's cost. For the gadgets of the first type cost is specified in dollars. For the gadgets of the second type cost is specified in pounds.
Output
If Nura can't buy k gadgets print the only line with the number -1.
Otherwise the first line should contain integer d β the minimum day index, when Nura will have k gadgets. On each of the next k lines print two integers qi, di β the number of gadget and the day gadget should be bought. All values qi should be different, but the values di can coincide (so Nura can buy several gadgets at one day). The days are numbered from 1 to n.
In case there are multiple possible solutions, print any of them.
Examples
Input
5 4 2 2
1 2 3 2 1
3 2 1 2 3
1 1
2 1
1 2
2 2
Output
3
1 1
2 3
Input
4 3 2 200
69 70 71 72
104 105 106 107
1 1
2 2
1 2
Output
-1
Input
4 3 1 1000000000
900000 910000 940000 990000
990000 999000 999900 999990
1 87654
2 76543
1 65432
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 2e5 + 10, INF = 0x3f3f3f3f;
int n, m, k, s;
long long a[MAXN], b[MAXN], c[MAXN];
int t[MAXN], daya[MAXN], dayb[MAXN];
int ans = -1, ansad, ansbd, ansp[MAXN];
void input() {
scanf("%d%d%d%d", &n, &m, &k, &s);
a[0] = INF;
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
if (a[i] > a[i - 1]) {
a[i] = a[i - 1];
daya[i] = daya[i - 1];
} else {
daya[i] = i;
}
}
b[0] = INF;
for (int i = 1; i <= n; i++) {
scanf("%lld", b + i);
if (b[i] > b[i - 1]) {
b[i] = b[i - 1];
dayb[i] = dayb[i - 1];
} else {
dayb[i] = i;
}
}
for (int i = 1; i <= m; i++) {
scanf("%d%lld", t + i, c + i);
}
}
bool check(int mid) {
std::multiset<std::pair<long long, int> > st;
for (int i = 1; i <= m; i++) {
st.insert(std::make_pair(c[i] * (t[i] == 1 ? a[mid] : b[mid]), i));
}
long long rst = 0;
auto it = st.begin();
for (int i = 0; i < k; i++) {
rst += (it++)->first;
}
if (rst <= s) {
ans = mid;
ansad = daya[mid];
ansbd = dayb[mid];
for (int i = 0; i < k; i++) {
ansp[i] = (--it)->second;
}
return true;
} else
return false;
}
void query() {
int left = 1, right = n;
while (left <= right) {
int mid = (left + right) >> 1;
if (check(mid)) {
right = mid - 1;
} else {
left = mid + 1;
}
}
}
int main() {
input();
query();
printf("%d\n", ans);
if (ans != -1) {
for (int i = 0; i < k; i++) {
printf("%d %d\n", ansp[i], t[ansp[i]] == 1 ? ansad : ansbd);
}
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.
A little later they found a string s, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring t of the string s.
Prefix supposed that the substring t is the beginning of the string s; Suffix supposed that the substring t should be the end of the string s; and Obelix supposed that t should be located somewhere inside the string s, that is, t is neither its beginning, nor its end.
Asterix chose the substring t so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring t aloud, the temple doors opened.
You know the string s. Find the substring t or determine that such substring does not exist and all that's been written above is just a nice legend.
Input
You are given the string s whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.
Output
Print the string t. If a suitable t string does not exist, then print "Just a legend" without the quotes.
Examples
Input
fixprefixsuffix
Output
fix
Input
abcdabc
Output
Just a legend
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
char s[1000006];
int z[1000006];
void calc_z() {
int n = (int)strlen(s);
int l = 0, r = 0;
for (int i = 1; i <= int(n); i++) {
if (i < r) {
z[i] = min(z[i - l], r - i);
}
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] > r) {
l = i;
r = i + z[i];
}
}
}
int main() {
gets(s);
calc_z();
int n = (int)strlen(s);
int len = 0;
for (int i = 1; i <= int(n - 1); i++) {
if (i + z[i] < n) {
len = max(len, z[i]);
} else {
len = max(len, z[i] - 1);
}
}
for (int i = 1; i <= int(n - 1); i++) {
if (i + z[i] == n) {
if (len >= z[i]) {
s[z[i]] = 0;
puts(s);
return 0;
}
}
}
cout << "Just a legend\n";
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You have unweighted tree of n vertices. You have to assign a positive weight to each edge so that the following condition would hold:
* For every two different leaves v_{1} and v_{2} of this tree, [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges on the simple path between v_{1} and v_{2} has to be equal to 0.
Note that you can put very large positive integers (like 10^{(10^{10})}).
It's guaranteed that such assignment always exists under given constraints. Now let's define f as the number of distinct weights in assignment.
<image> In this example, assignment is valid, because bitwise XOR of all edge weights between every pair of leaves is 0. f value is 2 here, because there are 2 distinct edge weights(4 and 5).
<image> In this example, assignment is invalid, because bitwise XOR of all edge weights between vertex 1 and vertex 6 (3, 4, 5, 4) is not 0.
What are the minimum and the maximum possible values of f for the given tree? Find and print both.
Input
The first line contains integer n (3 β€ n β€ 10^{5}) β the number of vertices in given 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 two integers β the minimum and maximum possible value of f can be made from valid assignment of given tree. Note that it's always possible to make an assignment under given constraints.
Examples
Input
6
1 3
2 3
3 4
4 5
5 6
Output
1 4
Input
6
1 3
2 3
3 4
4 5
4 6
Output
3 3
Input
7
1 2
2 7
3 4
4 7
5 6
6 7
Output
1 6
Note
In the first example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image>
In the second example, possible assignments for each minimum and maximum are described in picture below. The f value of valid assignment of this tree is always 3.
<image>
In the third example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const long long p = 998244353;
int maxans = 0;
vector<int> v[101000];
int vis[101000];
int dp[101000][2];
int minans;
void dfs(int x, int fa) {
int f = 0;
for (auto i : v[x]) {
if (i == fa) continue;
if (vis[i] != 1) {
dfs(i, x);
if (dp[i][1]) dp[x][0] = 1;
if (dp[i][0]) dp[x][1] = 1;
} else {
if (f)
maxans--;
else
f = 1;
dp[x][1] = 1;
}
}
if (dp[x][0] && dp[x][1]) minans = 3;
}
int main() {
int n;
scanf("%d", &n);
maxans = n - 1;
minans = 1;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
vis[x]++, vis[y]++;
}
for (int i = 1; i <= n; i++) {
if (vis[i] > 1) {
dfs(i, 0);
break;
}
}
cout << minans << " " << maxans << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Petya once wrote a sad love song and shared it to Vasya. The song is a string consisting of lowercase English letters. Vasya made up q questions about this song. Each question is about a subsegment of the song starting from the l-th letter to the r-th letter. Vasya considers a substring made up from characters on this segment and repeats each letter in the subsegment k times, where k is the index of the corresponding letter in the alphabet. For example, if the question is about the substring "abbcb", then Vasya repeats letter 'a' once, each of the letters 'b' twice, letter 'c" three times, so that the resulting string is "abbbbcccbb", its length is 10. Vasya is interested about the length of the resulting string.
Help Petya find the length of each string obtained by Vasya.
Input
The first line contains two integers n and q (1β€ nβ€ 100 000, 1β€ q β€ 100 000) β the length of the song and the number of questions.
The second line contains one string s β the song, consisting of n lowercase letters of English letters.
Vasya's questions are contained in the next q lines. Each line contains two integers l and r (1 β€ l β€ r β€ n) β the bounds of the question.
Output
Print q lines: for each question print the length of the string obtained by Vasya.
Examples
Input
7 3
abacaba
1 3
2 5
1 7
Output
4
7
11
Input
7 4
abbabaa
1 3
5 7
6 6
2 4
Output
5
4
1
5
Input
13 7
sonoshikumiwo
1 5
2 10
7 7
1 13
4 8
2 5
3 9
Output
82
125
9
191
62
63
97
Note
In the first example Vasya is interested in three questions. In the first question Vasya considers the substring "aba", that transforms to "abba", so the answer is equal to 4. In the second question Vasya considers "baca", that transforms to "bbaccca", so the answer is 7. In the third question Vasya considers the string "abacaba",that transforms to "abbacccabba" of length 11.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, q;
cin>>n>>q;
string s;
cin>>s;
ll ar[n];
for(ll i = 0; i < n; i++){
ll num = s[i]-97+1;
ar[i] = num;
if(i > 0)
ar[i] += ar[i-1];
}
for(ll i = 1; i <= q; i++){
ll a, b;
cin>>a>>b;
if(a>1)
cout<<(ar[b-1]-ar[a-2])<<'\n';
else
cout<<ar[b-1]<<'\n';
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
We arrange the numbers between 1 and N (1 <= N <= 10000) in increasing order and decreasing order like this:
1 2 3 4 5 6 7 8 9 . . . N
N . . . 9 8 7 6 5 4 3 2 1
Two numbers faced each other form a pair. Your task is to compute the number of pairs P such that both numbers in the pairs are prime.
Input
Input contains several test cases. Each test case consists of an integer N in one line.
Output
For each line of input, output P .
Example
Input
1
4
7
51
Output
0
2
2
6
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
using namespace std;
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10
#define MAX_M 100100
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
int n;
int is_prime[11000];
int main(){
REP(i, 11000)is_prime[i] = 1;
is_prime[0] = is_prime[1] = 0;
for (int i = 2; i <= 10000; i++){
if (is_prime[i]){
for (int j = i * 2; j <= 10000; j += i)is_prime[j] = 0;
}
}
while (cin >> n){
int ans = 0;
FOR(i, 1, n + 1){
if (is_prime[i] && is_prime[n + 1 - i])ans++;
}
cout << ans << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 β€ t β€ 3 β
10^5) β the number of queries.
The first line of each query contains one integer n (1 β€ n β€ 3 β
10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 β€ b_i β€ n).
It is guaranteed that β n β€ 3 β
10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int fen[(ll)(3e5 + 3)];
void add(int ind, int val) {
for (int i = ind; i < (ll)(3e5 + 3); i += i & (-i)) {
fen[i] = max(fen[i], val);
}
}
int su(int ind) {
int ans = (ll)(-5e5);
for (int i = ind; i > 0; i -= i & (-i)) {
ans = max(fen[i], ans);
}
return ans;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
fill(fen, fen + n + 10, (ll)(-5e5));
int ar[n], br[n], cc = 0;
vector<int> av[n + 1], bv[n + 1];
for (int i = 0; i < n; i++) {
cin >> ar[i];
av[ar[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
cin >> br[i];
bv[br[i]].push_back(i);
}
bool fl = 1;
for (int i = 1; i <= n; i++) {
if (av[i].size() != bv[i].size()) {
fl = 0;
break;
}
}
if (!fl) {
cout << "NO\n";
continue;
}
sort(br, br + n);
int la = -1;
for (int i = 0; i < n; i++) {
if (br[i] != la) {
cc = 0;
la = br[i];
} else {
cc++;
}
if (su(av[br[i]][cc] + 1) >= bv[br[i]][cc]) {
fl = 0;
break;
}
add(av[br[i]][cc] + 1, bv[br[i]][cc]);
}
if (fl) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
For the New Year, Polycarp decided to send postcards to all his n friends. He wants to make postcards with his own hands. For this purpose, he has a sheet of paper of size w Γ h, which can be cut into pieces.
Polycarp can cut any sheet of paper w Γ h that he has in only two cases:
* If w is even, then he can cut the sheet in half and get two sheets of size w/2 Γ h;
* If h is even, then he can cut the sheet in half and get two sheets of size w Γ h/2;
If w and h are even at the same time, then Polycarp can cut the sheet according to any of the rules above.
After cutting a sheet of paper, the total number of sheets of paper is increased by 1.
Help Polycarp to find out if he can cut his sheet of size w Γ h at into n or more pieces, using only the rules described above.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
Each test case consists of one line containing three integers w, h, n (1 β€ w, h β€ 10^4, 1 β€ n β€ 10^9) β the width and height of the sheet Polycarp has and the number of friends he needs to send a postcard to.
Output
For each test case, output on a separate line:
* "YES", if it is possible to cut a sheet of size w Γ h into at least n pieces;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
5
2 2 3
3 3 2
5 10 2
11 13 1
1 4 4
Output
YES
NO
YES
YES
YES
Note
In the first test case, you can first cut the 2 Γ 2 sheet into two 2 Γ 1 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 1 Γ 1. We can choose any three of them and send them to our friends.
In the second test case, a 3 Γ 3 sheet cannot be cut, so it is impossible to get two sheets.
In the third test case, you can cut a 5 Γ 10 sheet into two 5 Γ 5 sheets.
In the fourth test case, there is no need to cut the sheet, since we only need one sheet.
In the fifth test case, you can first cut the 1 Γ 4 sheet into two 1 Γ 2 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 1 Γ 1.
### Response
```cpp
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <string>
#include <algorithm>
#include <set>
#include <queue>
using namespace std;
void solve() {
long long w,h,n;
cin >> w >> h >> n;
int cnt = 0;
while (w % 2 == 0) {
cnt++;
w /= 2;
}
while (h % 2 == 0) {
cnt++;
h /= 2;
}
if (pow(2, cnt) >= n)cout << "YES" << endl;
else cout << "NO" << endl;
}
int main()
{
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 β€ k < n β€ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int mod = 1000000007;
char s[N];
long long fact[N];
long long fpow(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
if (b & 1) return a * fpow(a * a % mod, b / 2) % mod;
return fpow(a * a % mod, b / 2);
}
long long combination(long long n, long long m) {
if (n < m) return 0;
if (n == m || m == 0) return 1;
return fact[n] * fpow(fact[m], mod - 2) % mod * fpow(fact[n - m], mod - 2) %
mod;
}
int main() {
int n, k;
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = fact[i - 1] * i % mod;
long long ans = 0;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
long long pre = 0;
for (int i = n; i >= 1; i--) {
long long x = s[i] - '0';
int len = n - i + 1;
ans = (ans + combination(n - len, k) * fpow(10, len - 1) % mod * x) % mod;
if (len >= 2)
pre = (pre + combination(n - 1 - (len - 1), k - 1) * fpow(10, len - 2)) %
mod;
ans = (ans + pre * x) % mod;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) Γ 1000 = 8000 yen.
Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .
Constraints
* $2 \leq n \leq 200,000$
* $1 \leq R_t \leq 10^9$
Input
The first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.
Output
Print the maximum value in a line.
Examples
Input
6
5
3
1
3
4
3
Output
3
Input
3
4
3
2
Output
-1
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n,num[200000];
cin>>n;
for(int i=0;i<n;i++){
cin>>num[i];
}
int maxn = -2000000000,minn = num[0];
for(int j=1;j<n;j++){
maxn = max(maxn,num[j]-minn);
minn = min(minn,num[j]);
}
cout<<maxn<<endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Bearland is a dangerous place. Limak canβt travel on foot. Instead, he has k magic teleportation stones. Each stone can be used at most once. The i-th stone allows to teleport to a point (axi, ayi). Limak can use stones in any order.
There are n monsters in Bearland. The i-th of them stands at (mxi, myi).
The given k + n points are pairwise distinct.
After each teleportation, Limak can shoot an arrow in some direction. An arrow will hit the first monster in the chosen direction. Then, both an arrow and a monster disappear. Itβs dangerous to stay in one place for long, so Limak can shoot only one arrow from one place.
A monster should be afraid if itβs possible that Limak will hit it. How many monsters should be afraid of Limak?
Input
The first line of the input contains two integers k and n (1 β€ k β€ 7, 1 β€ n β€ 1000) β the number of stones and the number of monsters.
The i-th of following k lines contains two integers axi and ayi ( - 109 β€ axi, ayi β€ 109) β coordinates to which Limak can teleport using the i-th stone.
The i-th of last n lines contains two integers mxi and myi ( - 109 β€ mxi, myi β€ 109) β coordinates of the i-th monster.
The given k + n points are pairwise distinct.
Output
Print the number of monsters which should be afraid of Limak.
Examples
Input
2 4
-2 -1
4 5
4 2
2 1
4 -1
1 -1
Output
3
Input
3 8
10 20
0 0
20 40
300 600
30 60
170 340
50 100
28 56
90 180
-4 -8
-1 -2
Output
5
Note
In the first sample, there are two stones and four monsters. Stones allow to teleport to points ( - 2, - 1) and (4, 5), marked blue in the drawing below. Monsters are at (4, 2), (2, 1), (4, - 1) and (1, - 1), marked red. A monster at (4, - 1) shouldn't be afraid because it's impossible that Limak will hit it with an arrow. Other three monsters can be hit and thus the answer is 3.
<image>
In the second sample, five monsters should be afraid. Safe monsters are those at (300, 600), (170, 340) and (90, 180).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point(long long x, long long y) : x(x), y(y) {}
Point() : x(0), y(0) {}
};
Point pos[7];
Point targets[1010];
vector<int> in[7][1010];
int match[7];
int N, K;
void read(int n, Point *p) {
for (int i = 0; i < n; ++i) {
cin >> p[i].x >> p[i].y;
}
}
bool dfs(const vector<int> &v, int mask);
bool dfs_kill(const vector<int> &v, int i, vector<int> &nv, int mask) {
if (i == v.size()) {
set<int> unv(nv.begin(), nv.end());
for (int j = 0; j < K; ++j) {
if (match[j] != -1 && unv.count(match[j])) {
unv.erase(match[j]);
}
}
return dfs(vector<int>(unv.begin(), unv.end()), mask);
}
for (int j = 0; j < K; ++j) {
if (mask >> j & 1) {
if (in[j][v[i]].size() > __builtin_popcount(mask) - 1) {
continue;
}
match[j] = v[i];
for (int k = 0; k < in[j][v[i]].size(); ++k) {
nv.emplace_back(in[j][v[i]][k]);
}
if (dfs_kill(v, i + 1, nv, mask & ~(1 << j))) {
return true;
}
for (int k = 0; k < in[j][v[i]].size(); ++k) {
nv.pop_back();
}
match[j] = -1;
}
}
return false;
}
bool dfs(const vector<int> &v, int mask) {
if (__builtin_popcount(mask) < v.size()) return false;
if (v.size() == 0) {
return true;
}
vector<int> nv;
if (dfs_kill(v, 0, nv, mask)) return true;
return false;
}
inline Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
inline long long det(const Point &a, const Point &b) {
return a.x * b.y - a.y * b.x;
}
inline long long dot(const Point &a, const Point &b) {
return a.x * b.x + a.y * b.y;
}
inline bool online(const Point &p, const Point &a, const Point &b) {
return det(b - a, p - a) == 0 && dot(a - p, b - p) < 0;
}
int main() {
while (cin >> K >> N) {
read(K, pos);
read(N, targets);
for (int i = 0; i < K; ++i) {
for (int j = 0; j < N; ++j) {
in[i][j].clear();
for (int k = 0; k < N; ++k)
if (k != j && online(targets[k], pos[i], targets[j])) {
in[i][j].emplace_back(k);
}
}
}
int res = 0;
for (int i = 0; i < N; ++i) {
memset(match, -1, sizeof match);
if (dfs(vector<int>(1, i), (1 << K) - 1)) {
res++;
}
}
cout << res << endl;
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
AtCoDeer is thinking of painting an infinite two-dimensional grid in a checked pattern of side K. Here, a checked pattern of side K is a pattern where each square is painted black or white so that each connected component of each color is a K Γ K square. Below is an example of a checked pattern of side 3:
cba927b2484fad94fb5ff7473e9aadef.png
AtCoDeer has N desires. The i-th desire is represented by x_i, y_i and c_i. If c_i is `B`, it means that he wants to paint the square (x_i,y_i) black; if c_i is `W`, he wants to paint the square (x_i,y_i) white. At most how many desires can he satisfy at the same time?
Constraints
* 1 β€ N β€ 10^5
* 1 β€ K β€ 1000
* 0 β€ x_i β€ 10^9
* 0 β€ y_i β€ 10^9
* If i β j, then (x_i,y_i) β (x_j,y_j).
* c_i is `B` or `W`.
* N, K, x_i and y_i are integers.
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1 c_1
x_2 y_2 c_2
:
x_N y_N c_N
Output
Print the maximum number of desires that can be satisfied at the same time.
Examples
Input
4 3
0 1 W
1 2 W
5 3 B
5 4 B
Output
4
Input
2 1000
0 0 B
0 1 W
Output
2
Input
6 2
1 2 B
2 1 W
2 2 B
1 0 B
0 6 W
4 5 W
Output
4
### Response
```cpp
#include<cstdio>
#include<algorithm>
#include<cstring>
const int MAXN = 100000;
const int MAXK = 1000;
int x[MAXN + 5], y[MAXN + 5], c[MAXN + 5];
int y1[10 * MAXK + 5];
int main()
{
int N,K,Max=0,cnt = 0;
scanf("%d%d",&N,&K);
for(int i=1;i<=N;i++)
{
char ch;
scanf("%d%d %c",&x[i],&y[i],&ch);
x[i]%=(2*K);
y[i]%=(2*K);
if(ch=='W' ) c[i] = 1;
else c[i]=0;
}
for(int i=0;i<=K;i++) {
cnt = 0;
memset(y1,0,sizeof(y1));
for(int j=1;j<=N;j++) {
bool p = ( i <= x[j] && x[j] < i+K );
bool q = ( 0 <= y[j] && y[j] < K );
if( p ^ q == c[j] )
{
cnt++;
y1[y[j]] ++;
}
else
{
y1[y[j]] --;
}
}
for(int j=0;j<=K;j++)
{
Max=std::max(Max,std::max(cnt,N-cnt));
if( j != K )
cnt = cnt - y1[j] - y1[K+j];
}
}
printf("%d\n",Max);
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Generous sponsors of the olympiad in which Chloe and Vladik took part allowed all the participants to choose a prize for them on their own. Christmas is coming, so sponsors decided to decorate the Christmas tree with their prizes.
They took n prizes for the contestants and wrote on each of them a unique id (integer from 1 to n). A gift i is characterized by integer ai β pleasantness of the gift. The pleasantness of the gift can be positive, negative or zero. Sponsors placed the gift 1 on the top of the tree. All the other gifts hung on a rope tied to some other gift so that each gift hung on the first gift, possibly with a sequence of ropes and another gifts. Formally, the gifts formed a rooted tree with n vertices.
The prize-giving procedure goes in the following way: the participants come to the tree one after another, choose any of the remaining gifts and cut the rope this prize hang on. Note that all the ropes which were used to hang other prizes on the chosen one are not cut. So the contestant gets the chosen gift as well as the all the gifts that hang on it, possibly with a sequence of ropes and another gifts.
Our friends, Chloe and Vladik, shared the first place on the olympiad and they will choose prizes at the same time! To keep themselves from fighting, they decided to choose two different gifts so that the sets of the gifts that hang on them with a sequence of ropes and another gifts don't intersect. In other words, there shouldn't be any gift that hang both on the gift chosen by Chloe and on the gift chosen by Vladik. From all of the possible variants they will choose such pair of prizes that the sum of pleasantness of all the gifts that they will take after cutting the ropes is as large as possible.
Print the maximum sum of pleasantness that Vladik and Chloe can get. If it is impossible for them to choose the gifts without fighting, print Impossible.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of gifts.
The next line contains n integers a1, a2, ..., an ( - 109 β€ ai β€ 109) β the pleasantness of the gifts.
The next (n - 1) lines contain two numbers each. The i-th of these lines contains integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β the description of the tree's edges. It means that gifts with numbers ui and vi are connected to each other with a rope. The gifts' ids in the description of the ropes can be given in arbirtary order: vi hangs on ui or ui hangs on vi.
It is guaranteed that all the gifts hang on the first gift, possibly with a sequence of ropes and another gifts.
Output
If it is possible for Chloe and Vladik to choose prizes without fighting, print single integer β the maximum possible sum of pleasantness they can get together.
Otherwise print Impossible.
Examples
Input
8
0 5 -1 4 3 2 6 5
1 2
2 4
2 5
1 3
3 6
6 7
6 8
Output
25
Input
4
1 -5 1 1
1 2
1 4
2 3
Output
2
Input
1
-1
Output
Impossible
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000, MAX_VAL = 1000000000;
const long long INF = (long long)(MAX_N) * (long long)(MAX_VAL) + 1ll;
struct Vertex {
int a;
long long s, maxim, ans;
list<int> edge;
};
int n, a[MAX_N + 1];
Vertex vertexs[MAX_N + 1];
void DFS(int v, int p = 0) {
vertexs[v].s = vertexs[v].a;
vertexs[v].maxim = -INF;
vertexs[v].ans = -INF;
long long ans1 = -2 * INF, ans2 = -2 * INF;
for (auto i : vertexs[v].edge) {
if (i != p) {
DFS(i, v);
vertexs[v].s += vertexs[i].s;
vertexs[v].maxim = max(vertexs[v].maxim, vertexs[i].maxim);
vertexs[v].ans = max(vertexs[v].ans, vertexs[i].ans);
ans2 = max(ans2, vertexs[i].maxim);
if (ans2 > ans1) {
swap(ans1, ans2);
}
}
}
vertexs[v].maxim = max(vertexs[v].maxim, vertexs[v].s);
vertexs[v].ans = max(vertexs[v].ans, ans1 + ans2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
vertexs[i].a = a[i];
}
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
vertexs[u].edge.push_back(v);
vertexs[v].edge.push_back(u);
}
DFS(1);
if (vertexs[1].ans > -INF) {
cout << vertexs[1].ans << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters + and 1 into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not. Let's call a regular bracket sequence "RBS".
You are given a sequence s of n characters (, ), and/or ?. There is exactly one character ( and exactly one character ) in this sequence.
You have to replace every character ? with either ) or ( (different characters ? can be replaced with different brackets). You cannot reorder the characters, remove them, insert other characters, and each ? must be replaced.
Determine if it is possible to obtain an RBS after these replacements.
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
Each test case consists of one line containing s (2 β€ |s| β€ 100) β a sequence of characters (, ), and/or ?. There is exactly one character ( and exactly one character ) in this sequence.
Output
For each test case, print YES if it is possible to obtain a regular bracket sequence, or NO otherwise}.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
5
()
(?)
(??)
??()
)?(?
Output
YES
NO
YES
YES
NO
Note
In the first test case, the sequence is already an RBS.
In the third test case, you can obtain an RBS as follows: ()() or (()).
In the fourth test case, you can obtain an RBS as follows: ()().
### Response
```cpp
#include<bits/stdc++.h>
#define maxe 1000000000
#define MOD 1000000007
#define hurry ios_base::sync_with_stdio(false);cin.tie(NULL);
// #pragma GCC target ("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
// #pragma optimization_level 3
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//data type
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define bigint int64_t
#define getunique(v) {sort(all(v)); v.erase(unique(all(v)), v.end());}
//set
#define si set<int>
#define spl set< pair<ll,ll> >
#define spi set< pair<int,int> >
#define spp set< pair<pair<ll,ll>,ll> >
//pair
#define pll pair<ll,ll>
#define pi pai<int,int>
//vector
#define vvi vector< vector<int> > v;
#define vi vector<int> v;
#define vpii vector< pair<int,int> >
#define vpl vector< pair<ll,ll> >
#define all(v) v.begin(),v.end()
#define MINIMUM(a) *min_element(a.begin(), a.end())
#define MAXIMUM(a) *max_element(a.begin(), a.end())
#define pb push_back
#define mp make_pair
#define sz(a) sizeof(a)
#define forn(i,n) for(ll (i) = 0 ; (i) < (n) ; ++(i))
#define for1(i,n) for(ll (i) = 1 ; (i) <= (n) ; ++(i))
using namespace std;
#define ps(y,x) fixed<<setprecision(y)<<x;
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define FORD(i,a,b) for(int i=a;i>=b;--i)
#define REP(i,n) FOR(i,0,(int)n-1)
#define FOREACH_FN(v, fn) for_each(ALL(v), myobject);
#define SORT(a) sort(a.begin(),a.end())
#define RSORT(a) sort(a.rbegin(),a.rend())
#define REV(a) reverse(a.begin(),a.end())
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
/// Trace
#define trace1(a) cerr << #a << ": " << a << endl;
#define trace2(a,b) cerr << #a << ": " << a << " | " << #b << ": " << b << endl;
#define trace3(a,b,c) cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << endl;
#define trace4(a,b,c,d) cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;
#define trace5(a,b,c,d,e) cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;
#define trace6(a,b,c,d,e,f) cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " << #f << ": " << f << endl;
#define deb(x) cout << #x << "=" << x << endl;
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define ppc __builtin_popcount
#define ppcll __builtin_popcountll
#define W(t) while(t--)
#define forn(i,n) for(ll (i) = 0 ; (i) < (n) ; ++(i))
#define for1(i,n) for(ll (i) = 1 ; (i) <= (n) ; ++(i))
#define forr(i,n) for(ll (i) = (n)-1 ; (i)>=0 ; --(i))
#define forab(i,a,b,c) for(ll (i) = a ; (i) <= (b) ; (i)+=(c))
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define mp make_pair
#define pb push_back
int READ_INT(){int temp;cin>>temp;return temp;} // read an int
ll READ_LONG(){ll temp;cin>>temp;return temp;} // read a long long
string READ_STRING(){string temp;cin>>temp;return temp;} // read a string
///templates///////
const long double p = 3.14159265358979323846;
const long long INF=3e+5;
const int N =2e+5;
#define mod 998244353;
long long int inverse(long long int i){
if(i==1) return 1;
return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
}
ll POW(ll a,ll b)
{
if(b==0) return 1;
if(b==1) return a%MOD;
ll temp=POW(a,b/2);
if(b%2==0) return (temp*temp)%MOD;
else return (((temp*temp)%MOD)*a)%MOD;
}
/*vector<int> isprime(N,1);
vector<int> primes;
void seive()
{
for (int i = 2; i <= N; i++) {
if (isprime[i] && (long long)i * i <= N) {
for (int j = i * i; j <= N; j += i)
isprime[j] = 0;
}
}
for(int i=2;i<=N;i++)
{
if(isprime[i])
primes.pb(i);
}
}*/
// Returns factorial of n
void bootcoder()
{
//check N (space)
// check integer overflow
// check corner cases
string s;
cin>>s;
int n=s.length();
if(s[0]==')' || s[n-1]=='(' || (n-2)&1)
cout<<"NO";
else
cout<<"YES";
cout<<"\n";
}
int main()
{
hurry;
#ifndef ONLINE_JUDGE
freopen("inputs.txt", "r",stdin);
freopen("oss.txt","w",stdout);
#endif
int test;
cin>>test;
//test=1;
W(test)
{
bootcoder();
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
It is well known that the planet suffers from the energy crisis. Little Petya doesn't like that and wants to save the world. For this purpose he needs every accumulator to contain the same amount of energy. Initially every accumulator has some amount of energy: the i-th accumulator has ai units of energy. Energy can be transferred from one accumulator to the other. Every time x units of energy are transferred (x is not necessarily an integer) k percent of it is lost. That is, if x units were transferred from one accumulator to the other, amount of energy in the first one decreased by x units and in other increased by <image> units.
Your task is to help Petya find what maximum equal amount of energy can be stored in each accumulator after the transfers.
Input
First line of the input contains two integers n and k (1 β€ n β€ 10000, 0 β€ k β€ 99) β number of accumulators and the percent of energy that is lost during transfers.
Next line contains n integers a1, a2, ... , an β amounts of energy in the first, second, .., n-th accumulator respectively (0 β€ ai β€ 1000, 1 β€ i β€ n).
Output
Output maximum possible amount of energy that can remain in each of accumulators after the transfers of energy.
The absolute or relative error in the answer should not exceed 10 - 6.
Examples
Input
3 50
4 2 1
Output
2.000000000
Input
2 90
1 11
Output
1.909090909
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int v[n];
for (int i = 0; i < n; ++i) scanf("%d", &v[i]);
double l = 0.0, e = 1000.0;
double m;
for (int itr = 0; itr < 500; itr++) {
m = (l + e) / 2.0;
double x = 0.0, y = 0.0;
for (int i = 0; i < n; ++i) {
if (v[i] < m)
x += (m - v[i]);
else
y += (v[i] - m);
}
if (y - y * k / 100 >= x)
l = m;
else
e = m;
}
printf("%.7lf\n", m);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a tree consisting of n vertices, and m simple vertex paths. Your task is to find how many pairs of those paths intersect at exactly one vertex. More formally you have to find the number of pairs (i, j) (1 β€ i < j β€ m) such that path_i and path_j have exactly one vertex in common.
Input
First line contains a single integer n (1 β€ n β€ 3 β
10^5).
Next n - 1 lines describe the tree. Each line contains two integers u and v (1 β€ u, v β€ n) describing an edge between vertices u and v.
Next line contains a single integer m (1 β€ m β€ 3 β
10^5).
Next m lines describe paths. Each line describes a path by it's two endpoints u and v (1 β€ u, v β€ n). The given path is all the vertices on the shortest path from u to v (including u and v).
Output
Output a single integer β the number of pairs of paths that intersect at exactly one vertex.
Examples
Input
5
1 2
1 3
1 4
3 5
4
2 3
2 4
3 4
3 5
Output
2
Input
1
3
1 1
1 1
1 1
Output
3
Input
5
1 2
1 3
1 4
3 5
6
2 3
2 4
3 4
3 5
1 1
1 2
Output
7
Note
<image>
The tree in the first example and paths look like this. Pairs (1,4) and (3,4) intersect at one vertex.
In the second example all three paths contain the same single vertex, so all pairs (1, 2), (1, 3) and (2, 3) intersect at one vertex.
The third example is the same as the first example with two additional paths. Pairs (1,4), (1,5), (2,5), (3,4), (3,5), (3,6) and (5,6) intersect at one vertex.
### Response
```cpp
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<random>
#include<ctime>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
#include<unordered_map>
#include<map>
#include<bitset>
#include<stack>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N=6e5+5,M=1e3+5;
const ll INF=1e18+5;
inline ll read()
{
ll sum=0,fh=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')fh=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=sum*10+c-'0';
c=getchar();
}
return sum*fh;
}
inline int read2()
{
char c=getchar();
while(c!='a'&&c!='b'&&c!='c'&&c!='?')c=getchar();
return c=='?'?0:c-'a'+1;
}
inline int read3()
{
char c=getchar();
while(c<'a'||c>'z')
{
c=getchar();
}
return c-'a';
}
inline void write(ll x)
{
if(x<0)putchar('-'),x=-x;
if(x>9)write(x/10);
putchar(x%10+'0');
}
/*namespace INPUT_SPACE{
const int BS=(1<<24)+5;char Buffer[BS],*HD,*TL;
char gc() { if(HD==TL) TL=(HD=Buffer)+fread(Buffer,1,BS,stdin);return (HD==TL)?EOF:*HD++; }
inline ull read()
{
ull x,ch;while(((ch=gc())<'0'||ch>'9'));
x=ch^'0';
while((ch=gc())>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^'0');
return x;
}
}using INPUT_SPACE::read;
char sws[30000011],tt[21];int ssl,ttl;
inline int write(int x)
{
if(!x) sws[++ssl]='0';for(ttl=0;x;x/=10) tt[++ttl]=char(x%10+'0');
for(;ttl;ttl--) sws[++ssl]=tt[ttl];return sws[++ssl]='\n';
}*/
inline int gcd(int x,int y)
{
return y==0?x:gcd(y,x%y);
}
inline ll ab(ll x)
{
return x<0?-x:x;
}
inline ll fpow(ll qwe,ll asd,ll zxc)
{
if(asd<0)return 0;
ll a=qwe,b=1,c=asd;
while(c)
{
if(c&1)b=b*a%zxc;
a=a*a%zxc;
c>>=1;
}
return b;
}
int n,m;
struct miaow2
{
int son[2];
int fa,qfa;
int fz;
int sz,sum;
}t[N];
#define ls(x) t[x].son[0]
#define rs(x) t[x].son[1]
#define son(x,k) t[x].son[k]
#define fa(x) t[x].fa
#define qfa(x) t[x].qfa
#define fz(x) t[x].fz
#define sz(x) t[x].sz
#define sum(x) t[x].sum
inline int fx(int x)
{
if(!fa(x))return -1;
return rs(fa(x))==x;
}
inline void upd(int x)
{
sum(x)=sz(x)+(ls(x)?sum(ls(x)):0)+(rs(x)?sum(rs(x)):0);
}
inline void pd(int x)
{
if(!fz(x))return;
swap(ls(x),rs(x));
fz(x)=0;
if(ls(x))fz(ls(x))^=1;
if(rs(x))fz(rs(x))^=1;
}
inline void rot(int x)
{
if(!fa(x))return;
int y=fa(x),k=fx(x);
if(fa(y))
{
fa(x)=fa(y);
son(fa(y),fx(y))=x;
}
else swap(qfa(x),qfa(y)),fa(x)=0;
fa(y)=x;
if(son(x,k^1))fa(son(x,k^1))=y;
son(y,k)=son(x,k^1);
son(x,k^1)=y;
upd(y);
upd(x);
}
inline void pd2(int x)
{
if(fa(x))pd2(fa(x));
pd(x);
}
inline void splay(int x)
{
pd2(x);
if(!fa(x))return;
int y=fa(x);
while(y)
{
if(!fa(y))
{
rot(x);
return;
}
int z=fa(y);
if(fx(x)==fx(y))rot(y);
else rot(x);
rot(x);
y=fa(x);
}
}
inline void access(int x)
{
splay(x);
if(rs(x))
{
qfa(rs(x))=x;
fa(rs(x))=0;
rs(x)=0;
upd(x);
}
int y=qfa(x);
while(y)
{
splay(y);
//cout<<y<<"."<<fz(y)<<endl;
if(rs(y))
{
qfa(rs(y))=y;
fa(rs(y))=0;
rs(y)=0;
}
rs(y)=x;
fa(x)=y;
qfa(x)=0;
x=y;
y=qfa(x);
}
}
inline void sc()
{
for(int i=1;i<=n;++i)
{
cout<<i<<" ls:"<<ls(i)<<" rs:"<<rs(i)<<" fa:"<<fa(i)<<" qfa:"<<qfa(i)<<" sz:"<<sz(i)<<" sum:"<<sum(i)<<" fz:"<<fz(i)<<endl;
}
cout<<endl;
}
inline int hg(int x)
{
access(x);
//sc();
splay(x);
fz(x)=1;
}
inline int lctcx(int l,int r)
{
//cout<<"cx:"<<l<<" "<<r<<endl;
//sc();
hg(l);
//sc();
access(r);
splay(r);
//cout<<"cx:"<<ls(r)<<" "<<rs(r)<<" "<<ls(rs(r))<<" "<<rs(rs(r))<<endl;
//sc();
return sum(r);
}
inline void lctxg(int x,int y)
{
hg(x);
sz(x)+=y;
upd(x);
}
#define pi pair<ll,ll>
struct miaow
{
int f,t,l;
ll c;
miaow(int f=0,int t=0,ll c=0,int l=0):f(f),t(t),c(c),l(l){}
}imap[N*2+5];
int str[N*2+5]={0},cou=2;
inline void jb(int f,int t,ll c=0)
{
//cout<<f<<" "<<t<<" "<<c<<endl;
imap[cou]=miaow(f,t,c,str[f]);str[f]=cou++;
imap[cou]=miaow(t,f,c,str[t]);str[t]=cou++;
}
//ll a[N];
int dfn[N],dfnl[N],dfnr[N],dfncou=0,dep[N];
pi sx[N];
inline void dfs(int o,int fa,int d)
{
sx[o]=pi(-d,o);
dep[o]=d;
dfn[++dfncou]=o;
dfnl[o]=dfncou;
for(int i=str[o];i;i=imap[i].l)
{
int tt=imap[i].t;
if(tt==fa)continue;
qfa(tt)=o;
dfs(tt,o,d+1);
dfn[++dfncou]=o;
}
dfnr[o]=dfncou;
return;
}
struct meow
{
int imi,l,r;
meow(int imii=0,int ll=0,int rr=0)
{
imi=imii,l=ll,r=rr;
}
};
inline meow meg(meow& qwe,meow& asd)
{
if(qwe.imi<asd.imi)return qwe;
if(qwe.imi>asd.imi)return asd;
return meow(qwe.imi,min(qwe.l,asd.l),max(qwe.r,asd.r));
}
struct nya
{
int l,r;
meow imx;
}tt[N*4+5];
#define l(x) tt[x].l
#define r(x) tt[x].r
#define imx(x) tt[x].imx
#define lss(x) (x*2)
#define rss(x) (x*2+1)
inline void tcsh(int l,int r,int o)
{
l(o)=l,r(o)=r;
if(l==r)
{
imx(o)=meow(dep[dfn[l]],l,r);
return;
}
int mid=(l+r)>>1;
tcsh(l,mid,lss(o)),tcsh(mid+1,r,rss(o));
imx(o)=meg(imx(lss(o)),imx(rss(o)));
}
inline meow cx(int l,int r,int o)
{
//cout<<l<<" "<<r<<" "<<o<<endl;
if(l<=l(o)&&r>=r(o))return imx(o);
meow qwe(1e9,0,0),asd(1e9,0,0);
int mid=(l(o)+r(o))>>1;
if(l<=mid)qwe=cx(l,min(mid,r),lss(o));
if(r>mid)asd=cx(max(mid+1,l),r,rss(o));
return meg(qwe,asd);
}
/*inline void xg(int l,int r,int o,int x)
{
if(l>r)return;
if(l<=l(o)&&r>=r(o))
{
bj(o)+=x;
imx(o)+=x;
return;
}
int mid=(l(o)+r(o))>>1;
if(l<=mid)xg(l,min(mid,r),ls(o),x);
if(r>mid)xg(max(l,mid+1),r,rs(o),x);
if(imx(ls(o))>imx(rs(o)))imx(o)=imx(ls(o))+bj(o),sum(o)=sum(ls(o));
else if(imx(ls(o))<imx(rs(o)))imx(o)=imx(rs(o))+bj(o),sum(o)=sum(rs(o));
else imx(o)=imx(ls(o))+bj(o),sum(o)=sum(ls(o))+sum(rs(o));
}*/
/*inline void xg(int k,int o,int x)
{
//if(l>r)return;
if(l(o)==r(o))
{
mat(o,0,0)=0;
mat(o,0,1)=x;
mat(o,1,0)=-x;
mat(o,1,1)=0;
return;
return;
}
int mid=(l(o)+r(o))>>1;
if(k<=mid)xg(k,ls(o),x);
else xg(k,rs(o),x);
upd(o);
}*/
/*inline int cx(int k,int o)
{
if(l(o)==r(o))return imx(o);
int x=imx(o),mid=(l(o)+r(o))>>1;
if(k<=mid)return min(x,cx(k,ls(o)));
else return min(x,cx(k,rs(o)));
}*/
struct meow2
{
int l,r,lca,lcal,lcar;
meow2(int ll=0,int rr=0,int lca=0,int lcal=0,int lcar=0):lca(lca),lcal(lcal),lcar(lcar)
{
l=ll,r=rr;
}
};
vector<meow2> dcz[N];
int djs[N];
map<pi,int> djs2;
ll ans;
inline void csh()
{
n=read();//,m=read();
//cout<<"?"<<endl;
for(int i=1;i<n;++i)
{
int f=read(),t=read();
jb(f,t);
}
//cout<<"?"<<endl;
dfs(1,0,1);
//cout<<"?"<<endl;
sort(sx+1,sx+n+1);
//cout<<"?"<<endl;
tcsh(1,dfncou,1);
//cout<<"?"<<endl;
//for(int i=1;i<=dfncou;++i)cout<<dfn[i]<<" ";cout<<endl;
//for(int i=1;i<=n;++i)cout<<i<<" "<<dfnl[i]<<" "<<dfnr[i]<<endl;
m=read();
for(int i=1;i<=m;++i)
{
//cout<<"?"<<i<<endl;
int l=read(),r=read();
if(l==r)
{
//cout<<"!1"<<endl;
dcz[l].push_back(meow2(l,r,l));
//cout<<l<<" "<<r<<" "<<l<<" "<<"0 0"<<endl;
continue;
}
if(dfnl[l]>dfnl[r])swap(l,r);
if(dfnl[l]<dfnl[r]&&dfnr[l]>dfnr[r])
{
//cout<<"!2"<<endl;
meow qwe=cx(dfnr[r],dfnr[l],1);
dcz[l].push_back(meow2(l,r,l,0,dfn[qwe.l-1]));
//cout<<l<<" "<<r<<" "<<l<<" "<<"0 "<<dfn[qwe.l-1]<<endl;
}
else
{
//cout<<"!3"<<" "<<dfnr[l]<<" "<<dfnl[r]<<endl;
meow qwe=cx(dfnr[l],dfnl[r],1);
//cout<<"!3"<<" "<<dfnr[l]<<" "<<dfnl[r]<<endl;
//cout<<qwe.l<<" "<<qwe.r<<" "<<qwe.imi<<endl;
dcz[dfn[qwe.l]].push_back(meow2(l,r,dfn[qwe.l],dfn[qwe.l-1],dfn[qwe.r+1]));
//cout<<l<<" "<<r<<" "<<dfn[qwe.l]<<" "<<dfn[qwe.l-1]<<" "<<dfn[qwe.r+1]<<endl;
}
}
}
inline void solve()
{
for(int i=1;i<=n;++i)
{
int o=sx[i].second;
//cout<<"!"<<o<<endl;
int js=0;
for(int j=0;j<dcz[o].size();++j)
{
int l=dcz[o][j].l,r=dcz[o][j].r,lcal=dcz[o][j].lcal,lcar=dcz[o][j].lcar;
//cout<<l<<" "<<r<<" "<<lcal<<" "<<lcar<<endl;
if(l==r)
{
ans+=js;
js+=1;
}
else if(l==o)
{
ans+=js-djs[lcar];
ans+=lctcx(l,r);
js+=1;
djs[lcar]+=1;
}
else
{
//cout<<"?1 "<<ans<<endl;
ans+=js-djs[lcal]-djs[lcar]+djs2[pi(lcal,lcar)];
//cout<<"?2 "<<ans<<endl;
ans+=lctcx(l,r);
//cout<<"?3 "<<ans<<endl;
js+=1;
djs[lcal]+=1,djs[lcar]+=1;
djs2[pi(lcal,lcar)]+=1;
}
}
for(int j=0;j<dcz[o].size();++j)
{
int l=dcz[o][j].l,r=dcz[o][j].r,lcal=dcz[o][j].lcal,lcar=dcz[o][j].lcar;
if(l==r)
{
lctxg(l,1);
}
else if(l==o)
{
lctxg(l,1);
lctxg(lcar,-1);
}
else
{
lctxg(o,1);
lctxg(lcal,-1);
lctxg(lcar,-1);
}
}
}
}
int main()
{
//freopen("qwq.txt","r",stdin);
//freopen("qaq.txt","w",stdout);
csh();
solve();
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Dr. Asimov, a robotics researcher, loves to research, but hates houseworks and his house were really dirty. So, he has developed a cleaning robot.
As shown in the following figure, his house has 9 rooms, where each room is identified by an alphabet:
<image>
The robot he developed operates as follows:
* If the battery runs down, the robot stops.
* If not so, the robot chooses a direction from four cardinal points with the equal probability, and moves to the room in that direction. Then, the robot clean the room and consumes 1 point of the battery.
* However, if there is no room in that direction, the robot does not move and remains the same room. In addition, there is a junk room in the house where the robot can not enter, and the robot also remains when it tries to enter the junk room. The robot also consumes 1 point of the battery when it remains the same place.
A battery charger for the robot is in a room. It would be convenient for Dr. Asimov if the robot stops at the battery room when its battery run down.
Your task is to write a program which computes the probability of the robot stopping at the battery room.
Constraints
* Judge data includes at most 100 data sets.
* n β€ 15
* s, t, b are distinct.
Input
The input consists of several datasets. Each dataset consists of:
n
s t b
n is an integer that indicates the initial battery point. s, t, b are alphabets respectively represent the room where the robot is initially, the battery room, and the junk room.
The input ends with a dataset which consists of single 0 for n. Your program should not output for this dataset.
Output
For each dataset, print the probability as a floating point number in a line. The answer may not have an error greater than 0.000001.
Example
Input
1
E A C
1
E B C
2
E A B
0
Output
0.00000000
0.25000000
0.06250000
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
double dp[3][3][16];//[x][y][n]
char s,t,b;
int n;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
cout.precision(8);
cout << fixed;
while(cin>>n,n){
fill(dp[0][0],dp[3][0],0);
cin>>s>>t>>b;
s-='A';
t-='A';
b-='A';
dp[s%3][s/3][n]=1;
for(;n>0;n--){
for(int x=0;x<3;x++){
for(int y=0;y<3;y++){
for(int i=0;i<4;i++){
if((0<=x+dx[i]&&x+dx[i]<3)&&(0<=y+dy[i]&&y+dy[i]<3)&&!((x+dx[i])==(b%3)&&(y+dy[i])==(b/3))){
dp[x+dx[i]][y+dy[i]][n-1]+=dp[x][y][n]/4;
}else{
dp[x][y][n-1]+=dp[x][y][n]/4;
}
}
}
}
}
cout << dp[t%3][t/3][0] << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are many caves deep in mountains found in the countryside. In legend, each cave has a treasure hidden within the farthest room from the cave's entrance. The Shogun has ordered his Samurais to explore these caves with Karakuri dolls (robots) and to find all treasures. These robots move in the caves and log relative distances and directions between rooms.
Each room in a cave is mapped to a point on an integer grid (x, y >= 0). For each cave, the robot always starts from its entrance, runs along the grid and returns to the entrance (which also serves as the exit). The treasure in each cave is hidden in the farthest room from the entrance, using Euclid distance for measurement, i.e. the distance of the room at point (x, y) from the entrance (0, 0) is defined as the square root of (x*x+y*y). If more than one room has the same farthest distance from the entrance, the treasure is hidden in the room having the greatest value of x. While the robot explores a cave, it records how it has moved. Each time it takes a new direction at a room, it notes the difference (dx, dy) from the last time it changed its direction. For example, suppose the robot is currently in the room at point (2, 4). If it moves to room (6, 4), the robot records (4, 0), i.e. dx=6-2 and dy=4-4. The first data is defined as the difference from the entrance. The following figure shows rooms in the first cave of the Sample Input. In the figure, the farthest room is the square root of 61 distant from the entrance.
<image>
Based on the records that the robots bring back, your job is to determine the rooms where treasures are hidden.
Input
In the first line of the input, an integer N showing the number of caves in the input is given. Integers dxi and dyi are i-th data showing the differences between rooms. Note that since the robot moves along the grid, either dxi or dyi is zero. An integer pair dxi = dyi = 0 signals the end of one cave's data which means the robot finished the exploration for the cave and returned back to the entrance. The coordinates are limited to (0,0)-(1000,1000).
Output
Print the position (x, y) of the treasure room on a line for each cave.
Example
Input
3
1 0
0 1
-1 0
1 0
0 5
-1 0
0 -1
5 0
0 1
0 -1
1 0
0 -4
-3 0
0 3
2 0
0 -2
-1 0
0 1
0 -1
1 0
0 2
-2 0
0 -3
3 0
0 4
-4 0
0 -5
-2 0
0 0
1 0
-1 0
0 0
2 0
0 1
-1 0
0 1
-1 0
0 -2
0 0
Output
6 5
1 0
2 1
### Response
```cpp
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int n;
cin>>n;
rep(i,n){
int dx,dy;
int x=0,y=0;
int mx=0,my=0,ma=0;
while(cin>>dx>>dy,dx||dy){
x+=dx;
y+=dy;
if(x*x+y*y>ma){
mx=x;my=y;
ma=x*x+y*y;
}else if(x*x+y*y==ma){
if(mx<x){
mx=x;my=y;
}
}
}
cout<<mx<<" "<<my<<endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There is an array a of 2^{30} integers, indexed from 0 to 2^{30}-1. Initially, you know that 0 β€ a_i < 2^{30} (0 β€ i < 2^{30}), but you do not know any of the values. Your task is to process queries of two types:
* 1 l r x: You are informed that the bitwise xor of the subarray [l, r] (ends inclusive) is equal to x. That is, a_l β a_{l+1} β β¦ β a_{r-1} β a_r = x, where β is the bitwise xor operator. In some cases, the received update contradicts past updates. In this case, you should ignore the contradicting update (the current update).
* 2 l r: You are asked to output the bitwise xor of the subarray [l, r] (ends inclusive). If it is still impossible to know this value, considering all past updates, then output -1.
Note that the queries are encoded. That is, you need to write an online solution.
Input
The first line contains a single integer q (1 β€ q β€ 2 β
10^5) β the number of queries.
Each of the next q lines describes a query. It contains one integer t (1 β€ t β€ 2) β the type of query.
The given queries will be encoded in the following way: let last be the answer to the last query of the second type that you have answered (initially, last = 0). If the last answer was -1, set last = 1.
* If t = 1, three integers follow, l', r', and x' (0 β€ l', r', x' < 2^{30}), meaning that you got an update. First, do the following: l = l' β last, r = r' β last, x = x' β last
and, if l > r, swap l and r.
This means you got an update that the bitwise xor of the subarray [l, r] is equal to x (notice that you need to ignore updates that contradict previous updates).
* If t = 2, two integers follow, l' and r' (0 β€ l', r' < 2^{30}), meaning that you got a query. First, do the following: l = l' β last, r = r' β last
and, if l > r, swap l and r.
For the given query, you need to print the bitwise xor of the subarray [l, r]. If it is impossible to know, print -1. Don't forget to change the value of last.
It is guaranteed there will be at least one query of the second type.
Output
After every query of the second type, output the bitwise xor of the given subarray or -1 if it is still impossible to know.
Examples
Input
12
2 1 2
2 1 1073741822
1 0 3 4
2 0 0
2 3 3
2 0 3
1 6 7 3
2 4 4
1 0 2 1
2 0 0
2 4 4
2 0 0
Output
-1
-1
-1
-1
5
-1
6
3
5
Input
4
1 5 5 9
1 6 6 5
1 6 5 10
2 6 5
Output
12
Note
In the first example, the real queries (without being encoded) are:
* 12
* 2 1 2
* 2 0 1073741823
* 1 1 2 5
* 2 1 1
* 2 2 2
* 2 1 2
* 1 2 3 6
* 2 1 1
* 1 1 3 0
* 2 1 1
* 2 2 2
* 2 3 3
* The answers for the first two queries are -1 because we don't have any such information on the array initially.
* The first update tells us a_1 β a_2 = 5. Note that we still can't be certain about the values a_1 or a_2 independently (for example, it could be that a_1 = 1, a_2 = 4, and also a_1 = 3, a_2 = 6).
* After we receive all three updates, we have enough information to deduce a_1, a_2, a_3 independently.
In the second example, notice that after the first two updates we already know that a_5 β a_6 = 12, so the third update is contradicting, and we ignore it.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr long long infValue =
std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template <typename T>
constexpr long long maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const long long INF = infValue<long long>;
const long long MOD = 998244353ll;
const double EPS = 1e-6;
const long long MAX = maxValue<long long>;
using pr = pair<long long, long long>;
vector<long long> g[601000];
map<long long, long long> v;
long long lv = 1;
long long p[601000], s[601000], vp[601000];
void make_set(long long v) {
p[v] = v;
s[v] = 1;
vp[v] = 0;
}
long long find_set(long long v) {
if (p[v] == v) return v;
long long sp = p[v];
p[v] = find_set(p[v]);
vp[v] ^= vp[sp];
return p[v];
}
void merge_set(long long vs, long long us, long long x) {
long long u = find_set(us);
long long v = find_set(vs);
if (v != u) {
if (s[v] > s[u]) swap(v, u), swap(vs, us);
p[u] = v;
s[v] += s[u];
vp[u] = vp[us] ^ x ^ vp[vs];
}
}
void add(long long l, long long r, long long x) { merge_set(l, r, x); }
long long query(long long l, long long r) {
long long lp = find_set(l);
long long rp = find_set(r);
if (lp != rp) return -1;
return vp[l] ^ vp[r];
}
long long q, last;
long long l, r, x;
int main(void) {
scanf("%d", &q);
while (q--) {
long long t = 0;
scanf("%d", &t);
scanf("%lld %lld", &l, &r), l ^= last, r ^= last;
if (l > r) swap(l, r);
if (v.count(l) == 0) make_set(lv), v[l] = lv++;
if (v.count(r) == 0) make_set(lv), v[r] = lv++;
if (v.count(++r) == 0) make_set(lv), v[r] = lv++;
l = v[l], r = v[r];
if (t == 1) {
scanf("%lld", &x), x ^= last;
if (query(l, r) == -1) add(l, r, x);
} else {
long long q = query(l, r);
if (q >= 0)
last = q;
else
last = 1;
printf("%lld\n", q);
}
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Nowadays it is becoming increasingly difficult to park a car in cities successfully. Let's imagine a segment of a street as long as L meters along which a parking lot is located. Drivers should park their cars strictly parallel to the pavement on the right side of the street (remember that in the country the authors of the tasks come from the driving is right side!). Every driver when parking wants to leave for themselves some extra space to move their car freely, that's why a driver is looking for a place where the distance between his car and the one behind his will be no less than b meters and the distance between his car and the one in front of his will be no less than f meters (if there's no car behind then the car can be parked at the parking lot segment edge; the same is true for the case when there're no cars parked in front of the car). Let's introduce an axis of coordinates along the pavement. Let the parking lot begin at point 0 and end at point L. The drivers drive in the direction of the coordinates' increasing and look for the earliest place (with the smallest possible coordinate) where they can park the car. In case there's no such place, the driver drives on searching for his perfect peaceful haven. Sometimes some cars leave the street and free some space for parking. Considering that there never are two moving cars on a street at a time write a program that can use the data on the drivers, entering the street hoping to park there and the drivers leaving it, to model the process and determine a parking lot space for each car.
Input
The first line contains three integers L, b ΠΈ f (10 β€ L β€ 100000, 1 β€ b, f β€ 100). The second line contains an integer n (1 β€ n β€ 100) that indicates the number of requests the program has got. Every request is described on a single line and is given by two numbers. The first number represents the request type. If the request type is equal to 1, then in that case the second number indicates the length of a car (in meters) that enters the street looking for a place to park. And if the request type is equal to 2, then the second number identifies the number of such a request (starting with 1) that the car whose arrival to the parking lot was described by a request with this number, leaves the parking lot. It is guaranteed that that car was parked at the moment the request of the 2 type was made. The lengths of cars are integers from 1 to 1000.
Output
For every request of the 1 type print number -1 on the single line if the corresponding car couldn't find place to park along the street. Otherwise, print a single number equal to the distance between the back of the car in its parked position and the beginning of the parking lot zone.
Examples
Input
30 1 2
6
1 5
1 4
1 5
2 2
1 5
1 4
Output
0
6
11
17
23
Input
30 1 1
6
1 5
1 4
1 5
2 2
1 5
1 4
Output
0
6
11
17
6
Input
10 1 1
1
1 12
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30, maxn = 100000 + 1000;
int n, m, b, f, a, type, cnt = 0, ans[maxn], ansr[maxn];
struct node {
int v, vl, vr, len;
node() {}
node(int _v, int _vl, int _vr, int _len) {
v = _v, vl = _vl, vr = _vr, len = _len;
}
node operator+(const node &A) {
node ret;
ret.v = max(v, A.v);
ret.v = max(ret.v, vr + A.vl);
ret.vl = vl, ret.vr = A.vr;
if (vl == len) ret.vl += A.vl;
if (A.vr == A.len) ret.vr += vr;
ret.len = len + A.len;
return ret;
}
};
struct Segment_Tree {
int tot, root, tree[maxn << 1][2], lazy[maxn << 1];
node val[maxn << 1];
void clear() { tot = tree[0][0] = tree[0][1] = 0; }
Segment_Tree() { clear(); }
void update(int o) { val[o] = val[tree[o][0]] + val[tree[o][1]]; }
void build(int &o, int l, int r) {
o = ++tot, lazy[o] = -1;
if (l == r) {
val[o] = node(1, 1, 1, 1);
return;
}
int mid = (l + r) >> 1;
build(tree[o][0], l, mid);
build(tree[o][1], mid + 1, r);
update(o);
}
void Setlazy(int o, int v) {
val[o].v = val[o].vl = val[o].vr = val[o].len * v;
lazy[o] = v;
}
void Lazydown(int o) {
if (lazy[o] != -1) {
Setlazy(tree[o][0], lazy[o]);
Setlazy(tree[o][1], lazy[o]);
lazy[o] = -1;
}
}
void Update(int o, int l, int r, int L, int R, int v) {
if (L <= l && R >= r) {
Setlazy(o, v);
return;
}
int mid = (l + r) >> 1;
Lazydown(o);
if (mid >= L) Update(tree[o][0], l, mid, L, R, v);
if (mid < R) Update(tree[o][1], mid + 1, r, L, R, v);
update(o);
}
int Query(int o, int l, int r, int v) {
int mid = (l + r) >> 1;
if (val[o].vl >= v) return l;
Lazydown(o);
if (val[tree[o][0]].v >= v) return Query(tree[o][0], l, mid, v);
if (val[tree[o][0]].vr + val[tree[o][1]].vl >= v)
return mid - val[tree[o][0]].vr + 1;
return Query(tree[o][1], mid + 1, r, v);
}
} tree;
void Init() {
scanf("%d%d%d", &n, &b, &f);
tree.build(tree.root, -b, n + f - 1);
}
void Solve() {
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &type, &a);
cnt++;
if (type == 1) {
if (tree.val[tree.root].v < a + b + f) {
printf("-1\n");
continue;
}
ans[cnt] = tree.Query(tree.root, -b, n + f - 1, a + b + f) + b;
tree.Update(tree.root, -b, n + f - 1, ans[cnt], ans[cnt] + a - 1, 0);
printf("%d\n", ans[cnt]);
ansr[cnt] = ans[cnt] + a - 1;
} else
tree.Update(tree.root, -b, n + f - 1, ans[a], ansr[a], 1);
}
}
int main() {
Init();
Solve();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Let's call an array a consisting of n positive (greater than 0) integers beautiful if the following condition is held for every i from 1 to n: either a_i = 1, or at least one of the numbers a_i - 1 and a_i - 2 exists in the array as well.
For example:
* the array [5, 3, 1] is beautiful: for a_1, the number a_1 - 2 = 3 exists in the array; for a_2, the number a_2 - 2 = 1 exists in the array; for a_3, the condition a_3 = 1 holds;
* the array [1, 2, 2, 2, 2] is beautiful: for a_1, the condition a_1 = 1 holds; for every other number a_i, the number a_i - 1 = 1 exists in the array;
* the array [1, 4] is not beautiful: for a_2, neither a_2 - 2 = 2 nor a_2 - 1 = 3 exists in the array, and a_2 β 1;
* the array [2] is not beautiful: for a_1, neither a_1 - 1 = 1 nor a_1 - 2 = 0 exists in the array, and a_1 β 1;
* the array [2, 1, 3] is beautiful: for a_1, the number a_1 - 1 = 1 exists in the array; for a_2, the condition a_2 = 1 holds; for a_3, the number a_3 - 2 = 1 exists in the array.
You are given a positive integer s. Find the minimum possible size of a beautiful array with the sum of elements equal to s.
Input
The first line contains one integer t (1 β€ t β€ 5000) β the number of test cases.
Then t lines follow, the i-th line contains one integer s (1 β€ s β€ 5000) for the i-th test case.
Output
Print t integers, the i-th integer should be the answer for the i-th testcase: the minimum possible size of a beautiful array with the sum of elements equal to s.
Example
Input
4
1
8
7
42
Output
1
3
3
7
Note
Consider the example test:
1. in the first test case, the array [1] meets all conditions;
2. in the second test case, the array [3, 4, 1] meets all conditions;
3. in the third test case, the array [1, 2, 4] meets all conditions;
4. in the fourth test case, the array [1, 4, 6, 8, 10, 2, 11] meets all conditions.
### Response
```cpp
// Start Time:
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define MX 1000000
#define ll long long
#define pb push_back
#define pi acos(-1.0)
#define PQ priority_queue
#define mod 1000000007
#define eps 1/1000000000
#define pii pair<int,int>
#define pll pair<ll,ll>
#define endl "\n"
#define Fast ios::sync_with_stdio(0) //cin.tie(0); cout.tie(0)
#define bug(a) cout<<#a<<":"<<a<<endl
#define TC(tc) cout<<"Case "<<tc++<<": "
#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define Mul(a,b) (a%mod * b%mod)%mod
#define Add(a,b) (a%mod + b%mod)%mod
#define mem(a,b) memset(a, b, sizeof(a))
#define double_print(x,a) cout<<fixed<<setprecision(x)<<a<<endl
ll tc=1;
int main()
{
Fast;
ll t;
cin>>t;
while(t--)
{
ll s;
cin>>s;
ll sum=1;
ll cnt=1;
ll val=1;
while(sum<s)
{
val+=2;
sum+=val;
cnt++;
}
cout<<cnt<<endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
There are n cities and m two-way roads in Berland, each road connecting two distinct cities.
Recently the Berland government has made a tough decision to transfer ownership of the roads to private companies. In total, there are 100500 private companies in Berland, numbered by integers from 1 to 100500. After the privatization, every road should belong to exactly one company.
The anti-monopoly committee demands that after the privatization each company can own at most two roads. The urbanists of Berland also stated their opinion: each city should be adjacent to the roads owned by at most k companies.
Help the government to distribute the roads between the companies so that both conditions are satisfied. That is, each company gets at most two roads, and each city has roads of at most k distinct companies adjacent to it.
Input
Input contains one or several test cases. The first line contains an integer t (1 β€ t β€ 300) β the number of test cases in the input. Solve test cases separately, test cases are completely independent and do not affect each other.
The following lines describe the test cases. Each case starts with a line consisting of three space-separated integers n, m and k (2 β€ n β€ 600, 1 β€ m β€ 600, 1 β€ k β€ n - 1) β the number of cities, the number of roads and the maximum diversity of the roads adjacent to a city.
Then m lines follow, each having a pair of space-separated integers a_i, b_i (1 β€ a_i, b_i β€ n; a_i β b_i). It means that the i-th road connects cities a_i and b_i. All roads are two-way. There is at most one road between a pair of the cities.
The sum of n values for all test cases doesn't exceed 600. The sum of m values for all test cases doesn't exceed 600.
Output
Print t lines: the i-th line should contain the answer for the i-th test case. For a test case, print a sequence of integers c_1, c_2, ..., c_m separated by space, where c_i (1 β€ c_i β€ 100500) is the company which owns the i-th road in your plan. If there are multiple solutions, output any of them. If there is no solution for a test case, print c_1=c_2=β¦=c_m=0.
Example
Input
3
3 3 2
1 2
2 3
3 1
4 5 2
1 2
1 3
1 4
2 3
2 4
4 6 2
1 2
1 3
1 4
2 3
2 4
3 4
Output
1 2 3
2 1 1 2 3
0 0 0 0 0 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const signed long long llf = (signed long long)(~0ull >> 1);
const signed int inf = (signed)(~0u >> 1);
template <typename T>
T __abs(T x) {
return (x < 0) ? (-x) : (x);
}
template <typename T>
void pfill(T* pst, const T* ped, T val) {
for (; pst != ped; *(pst++) = val)
;
}
template <typename T>
void pcopy(T* pst, const T* ped, T* pv) {
for (; pst != ped; *(pst++) = *(pv++))
;
}
typedef class Edge {
public:
int ed, nx, cap, f;
Edge() {}
Edge(int ed, int nx, int cap, int f) : ed(ed), nx(nx), cap(cap), f(f) {}
} Edge;
typedef class MapManager {
public:
int* h;
vector<Edge> es;
MapManager() {}
MapManager(int n) {
h = new int[(n + 1)];
pfill(h, h + n + 1, -1);
}
void addEdge(int u, int v, int cap, int f) {
es.push_back(Edge(v, h[u], cap, f));
h[u] = (signed)es.size() - 1;
}
void addArc(int u, int v, int cap) {
addEdge(u, v, cap, 0);
addEdge(v, u, cap, cap);
}
Edge& operator[](int p) { return es[p]; }
void clear() {
delete[] h;
es.clear();
}
} MapManager;
const int N = 605;
int n, m, K;
int s = 0, t;
int mxcap;
int deg[N];
MapManager g;
inline void init() {
scanf("%d%d%d", &n, &m, &K);
pfill(deg, deg + n + 1, 0);
g = MapManager(n + m + 1);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
deg[u]++, deg[v]++;
g.addArc(0, i, 1);
g.addArc(i, u + m, 1);
g.addArc(i, v + m, 1);
}
t = n + m + 1, mxcap = 0;
for (int i = 1; i <= n; i++)
if (deg[i] > K) g.addArc(i + m, t, (deg[i] - K) << 1), mxcap += deg[i] - K;
mxcap <<= 1;
}
int cur[N << 1], _div[N << 1];
int dfs(int p, int mf) {
if (p == t || !mf) return mf;
int f, flow = 0;
for (int &i = cur[p], e; ~i; i = g[i].nx) {
e = g[i].ed;
if (g[i].f < g[i].cap && _div[e] == _div[p] + 1 &&
(f = dfs(e, min(mf, g[i].cap - g[i].f))) > 0) {
g[i].f += f;
g[i ^ 1].f -= f;
mf -= f;
flow += f;
if (!mf) break;
}
}
return flow;
}
queue<int> que;
bool bfs() {
pfill(_div, _div + t + 1, -1);
_div[s] = 0;
que.push(s);
while (!que.empty()) {
int e = que.front();
que.pop();
for (int i = g.h[e], eu; ~i; i = g[i].nx) {
eu = g[i].ed;
if (g[i].cap == g[i].f) continue;
if (~_div[eu]) continue;
_div[eu] = _div[e] + 1;
que.push(eu);
}
}
return _div[t] != -1;
}
int dinic() {
int rt = 0;
while (bfs()) {
pcopy(cur, cur + t + 1, g.h);
rt += dfs(s, inf);
}
return rt;
}
int lab[N];
vector<int> mat[N];
inline void solve() {
int flow = dinic(), used = 0;
if (flow != mxcap) {
for (int i = 1; i <= m; i++) printf("0 ");
putchar('\n');
return;
}
for (int i = 1; i <= n; i++) mat[i].clear();
for (int i = 1; i <= m; i++)
for (int j = g.h[i]; ~j; j = g[j].nx)
if (g[j].cap == g[j].f && g[j].ed > m) {
mat[g[j].ed - m].push_back(i);
break;
}
pfill(lab + 1, lab + m + 1, 0);
for (int i = 1, a, b; i <= n; i++)
while (!mat[i].empty()) {
a = mat[i].back();
mat[i].pop_back();
b = mat[i].back();
mat[i].pop_back();
lab[a] = lab[b] = ++used;
}
for (int i = 1; i <= m; i++) {
if (!lab[i]) lab[i] = ++used;
printf("%d ", lab[i]);
}
putchar('\n');
}
inline void clear() { g.clear(); }
int T;
int main() {
scanf("%d", &T);
while (T--) {
init();
solve();
clear();
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 β€ k β€ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 β€ x β€ 10^9;~ 0 β€ y < x;~ y β€ n β€ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer β maximum non-negative integer k such that 0 β€ k β€ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 β
1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int t;
cin >> t;
while (t--) {
int n, x, y;
cin >> x >> y >> n;
int r1, r2;
r1 = n / x;
r2 = r1 - 1;
int res1 = (r1 * x) + y;
int res2 = (r2 * x + y);
if (res1 <= n)
cout << (r1 * x) + y << '\n';
else if (res2 <= n)
cout << (r2 * x) + y << '\n';
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You have an initially empty cauldron, and you want to brew a potion in it. The potion consists of two ingredients: magic essence and water. The potion you want to brew should contain exactly k\ \% magic essence and (100 - k)\ \% water.
In one step, you can pour either one liter of magic essence or one liter of water into the cauldron. What is the minimum number of steps to brew a potion? You don't care about the total volume of the potion, only about the ratio between magic essence and water in it.
A small reminder: if you pour e liters of essence and w liters of water (e + w > 0) into the cauldron, then it contains (e)/(e + w) β
100\ \% (without rounding) magic essence and (w)/(e + w) β
100\ \% water.
Input
The first line contains the single t (1 β€ t β€ 100) β the number of test cases.
The first and only line of each test case contains a single integer k (1 β€ k β€ 100) β the percentage of essence in a good potion.
Output
For each test case, print the minimum number of steps to brew a good potion. It can be proved that it's always possible to achieve it in a finite number of steps.
Example
Input
3
3
100
25
Output
100
1
4
Note
In the first test case, you should pour 3 liters of magic essence and 97 liters of water into the cauldron to get a potion with 3\ \% of magic essence.
In the second test case, you can pour only 1 liter of essence to get a potion with 100\ \% of magic essence.
In the third test case, you can pour 1 liter of magic essence and 3 liters of water.
### Response
```cpp
#include <stdio.h>
#include <iostream>
using namespace std;
int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
int main() {
int t, k;
cin >> t;
for(int i = 0; i < t; i++){
cin >> k;
int e = 100 - k;
int gcd_n = gcd(e, k);
cout << 100/gcd_n << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Valerian was captured by Shapur. The victory was such a great one that Shapur decided to carve a scene of Valerian's defeat on a mountain. So he had to find the best place to make his victory eternal!
He decided to visit all n cities of Persia to find the best available mountain, but after the recent war he was too tired and didn't want to traverse a lot. So he wanted to visit each of these n cities at least once with smallest possible traverse. Persian cities are connected with bidirectional roads. You can go from any city to any other one using these roads and there is a unique path between each two cities.
All cities are numbered 1 to n. Shapur is currently in the city 1 and he wants to visit all other cities with minimum possible traverse. He can finish his travels in any city.
Help Shapur find how much He should travel.
Input
First line contains a single natural number n (1 β€ n β€ 105) β the amount of cities.
Next n - 1 lines contain 3 integer numbers each xi, yi and wi (1 β€ xi, yi β€ n, 0 β€ wi β€ 2 Γ 104). xi and yi are two ends of a road and wi is the length of that road.
Output
A single integer number, the minimal length of Shapur's travel.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
3
1 2 3
2 3 4
Output
7
Input
3
1 2 3
1 3 3
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long SET(long long N, long long pos) {
return N = N | ((long long)1 << pos);
}
long long RESET(long long N, long long pos) {
return N = N & ~((long long)1 << pos);
}
bool CHECK(long long N, long long pos) {
return (bool)(N & ((long long)1 << pos));
}
template <typename T>
inline T __lcm(T a, T b) {
return (a * b) / __gcd(a, b);
}
struct node {
long long i, x, y;
};
long long dx[] = {0, 1, 0, -1, -1, 1, -1, 1};
long long dy[] = {1, 0, -1, 0, 1, 1, -1, -1};
long long dist[1000000];
vector<pair<long long, long long> > adj[1000000];
void dijkstra(long long source) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push(make_pair(0, source));
dist[source] = 0;
while (!pq.empty()) {
long long u = pq.top().second;
pq.pop();
for (long long i = 0; i < adj[u].size(); i++) {
long long v = adj[u][i].first;
long long weight = adj[u][i].second;
if (dist[v] > dist[u] + weight) {
dist[v] = dist[u] + weight;
pq.push(make_pair(dist[v], v));
}
}
}
}
void solve() {
long long n;
cin >> n;
long long ans = 0;
for (long long i = 0; i <= n; i++) {
dist[i] = 10000000000;
}
for (long long i = 0; i < n - 1; i++) {
long long x, y, w;
cin >> x >> y >> w;
ans += 2 * w;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
}
dijkstra(1);
long long maxi = 0;
for (long long i = 1; i <= n; i++) {
maxi = max(maxi, dist[i]);
}
ans -= maxi;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And yet, the notion of a giveaway is foreign to him. The combination of these features makes the Robo-Wallace the perfect footballer β as soon as the ball gets to him, he can just aim and hit the goal. He followed this tactics in the first half of the match, but he hit the goal rarely. The opposing team has a very good goalkeeper who catches most of the balls that fly directly into the goal. But Robo-Wallace is a quick thinker, he realized that he can cheat the goalkeeper. After all, they are playing in a football box with solid walls. Robo-Wallace can kick the ball to the other side, then the goalkeeper will not try to catch the ball. Then, if the ball bounces off the wall and flies into the goal, the goal will at last be scored.
Your task is to help Robo-Wallace to detect a spot on the wall of the football box, to which the robot should kick the ball, so that the ball bounces once and only once off this wall and goes straight to the goal. In the first half of the match Robo-Wallace got a ball in the head and was severely hit. As a result, some of the schemes have been damaged. Because of the damage, Robo-Wallace can only aim to his right wall (Robo-Wallace is standing with his face to the opposing team's goal).
The football box is rectangular. Let's introduce a two-dimensional coordinate system so that point (0, 0) lies in the lower left corner of the field, if you look at the box above. Robo-Wallace is playing for the team, whose goal is to the right. It is an improvised football field, so the gate of Robo-Wallace's rivals may be not in the middle of the left wall.
<image>
In the given coordinate system you are given:
* y1, y2 β the y-coordinates of the side pillars of the goalposts of robo-Wallace's opponents;
* yw β the y-coordinate of the wall to which Robo-Wallace is aiming;
* xb, yb β the coordinates of the ball's position when it is hit;
* r β the radius of the ball.
A goal is scored when the center of the ball crosses the OY axis in the given coordinate system between (0, y1) and (0, y2). The ball moves along a straight line. The ball's hit on the wall is perfectly elastic (the ball does not shrink from the hit), the angle of incidence equals the angle of reflection. If the ball bounces off the wall not to the goal, that is, if it hits the other wall or the goal post, then the opposing team catches the ball and Robo-Wallace starts looking for miscalculation and gets dysfunctional. Such an outcome, if possible, should be avoided. We assume that the ball touches an object, if the distance from the center of the ball to the object is no greater than the ball radius r.
Input
The first and the single line contains integers y1, y2, yw, xb, yb, r (1 β€ y1, y2, yw, xb, yb β€ 106; y1 < y2 < yw; yb + r < yw; 2Β·r < y2 - y1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross any wall, doesn't touch the wall that Robo-Wallace is aiming at. The goal posts can't be located in the field corners.
Output
If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number xw β the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made with the permissible absolute error, equal to 10 - 8.
It is recommended to print as many characters after the decimal point as possible.
Examples
Input
4 10 13 10 3 1
Output
4.3750000000
Input
1 4 6 2 2 1
Output
-1
Input
3 10 15 17 9 2
Output
11.3333333333
Note
Note that in the first and third samples other correct values of abscissa xw are also possible.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int mod = (int)1e9 + 7;
const long double INF = (long double)(1e3);
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int main() {
double vamdlsfmvldf, y2, yw, xb, yb, r;
while (cin >> vamdlsfmvldf >> y2 >> yw >> xb >> yb >> r) {
double yr = yw - r;
double my1 = yr + (yr - vamdlsfmvldf);
double my2 = yr + (yr - y2);
double aim_y = my1 - r;
double inc_y = (aim_y - yb) / xb;
double xw = (aim_y - yr) / inc_y;
double a = PI / 2 - atan2(aim_y - yb, xb);
double d = r / sin(a);
if (aim_y - d < my2)
puts("-1");
else
printf("%.10f\n", xw);
}
}
``` |
### Prompt
Please create a solution in CPP 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 main() {
long long int n;
cin >> n;
int arr[5];
arr[0] = 1;
arr[1] = 5;
arr[2] = 10;
arr[3] = 20;
arr[4] = 100;
long long int i = 4;
long long int val = 0;
while (n != 0) {
val += n / arr[i];
n = n % arr[i];
i -= 1;
}
cout << val;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
There is a river of width n. The left bank of the river is cell 0 and the right bank is cell n + 1 (more formally, the river can be represented as a sequence of n + 2 cells numbered from 0 to n + 1). There are also m wooden platforms on a river, the i-th platform has length c_i (so the i-th platform takes c_i consecutive cells of the river). It is guaranteed that the sum of lengths of platforms does not exceed n.
You are standing at 0 and want to reach n+1 somehow. If you are standing at the position x, you can jump to any position in the range [x + 1; x + d]. However you don't really like the water so you can jump only to such cells that belong to some wooden platform. For example, if d=1, you can jump only to the next position (if it belongs to the wooden platform). You can assume that cells 0 and n+1 belong to wooden platforms.
You want to know if it is possible to reach n+1 from 0 if you can move any platform to the left or to the right arbitrary number of times (possibly, zero) as long as they do not intersect each other (but two platforms can touch each other). It also means that you cannot change the relative order of platforms.
Note that you should move platforms until you start jumping (in other words, you first move the platforms and then start jumping).
For example, if n=7, m=3, d=2 and c = [1, 2, 1], then one of the ways to reach 8 from 0 is follow:
<image> The first example: n=7.
Input
The first line of the input contains three integers n, m and d (1 β€ n, m, d β€ 1000, m β€ n) β the width of the river, the number of platforms and the maximum distance of your jump, correspondingly.
The second line of the input contains m integers c_1, c_2, ..., c_m (1 β€ c_i β€ n, β_{i=1}^{m} c_i β€ n), where c_i is the length of the i-th platform.
Output
If it is impossible to reach n+1 from 0, print NO in the first line. Otherwise, print YES in the first line and the array a of length n in the second line β the sequence of river cells (excluding cell 0 and cell n + 1).
If the cell i does not belong to any platform, a_i should be 0. Otherwise, it should be equal to the index of the platform (1-indexed, platforms are numbered from 1 to m in order of input) to which the cell i belongs.
Note that all a_i equal to 1 should form a contiguous subsegment of the array a of length c_1, all a_i equal to 2 should form a contiguous subsegment of the array a of length c_2, ..., all a_i equal to m should form a contiguous subsegment of the array a of length c_m. The leftmost position of 2 in a should be greater than the rightmost position of 1, the leftmost position of 3 in a should be greater than the rightmost position of 2, ..., the leftmost position of m in a should be greater than the rightmost position of m-1.
See example outputs for better understanding.
Examples
Input
7 3 2
1 2 1
Output
YES
0 1 0 2 2 0 3
Input
10 1 11
1
Output
YES
0 0 0 0 0 0 0 0 0 1
Input
10 1 5
2
Output
YES
0 0 0 0 1 1 0 0 0 0
Note
Consider the first example: the answer is [0, 1, 0, 2, 2, 0, 3]. The sequence of jumps you perform is 0 β 2 β 4 β 5 β 7 β 8.
Consider the second example: it does not matter how to place the platform because you always can jump from 0 to 11.
Consider the third example: the answer is [0, 0, 0, 0, 1, 1, 0, 0, 0, 0]. The sequence of jumps you perform is 0 β 5 β 6 β 11.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long N = 3e5 + 7;
long long n, m, d;
long long arr[N], plank[N], pos[N], st[N];
void solve() {
cin >> n >> m >> d;
for (long long i = 0; i < m; i++) cin >> plank[i];
for (long long i = 0; i < m; i++) {
long long x = plank[i];
if (i != 0)
pos[i] = pos[i - 1] + x;
else
pos[i] = x;
st[i] = pos[i] - plank[i] + 1;
}
pos[m] = n + 1;
st[m] = n + 1;
for (long long i = m - 1; i >= 0; i--) {
if (st[i + 1] - d > pos[i]) {
long long x = (st[i + 1] - d);
pos[i] = x;
st[i] = pos[i] - plank[i] + 1;
}
}
for (long long i = 0; i < m; i++)
for (long long j = st[i]; j < pos[i] + 1; j++) arr[j] = i + 1;
if (st[0] > d)
cout << "NO";
else {
cout << "YES" << '\n';
for (long long i = 1; i < n + 1; i++) cout << arr[i] << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given a permutation p of numbers 1, 2, ..., n. Let's define f(p) as the following sum:
<image>
Find the lexicographically m-th permutation of length n in the set of permutations having the maximum possible value of f(p).
Input
The single line of input contains two integers n and m (1 β€ m β€ cntn), where cntn is the number of permutations of length n with maximum possible value of f(p).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem B1 (3 points), the constraint 1 β€ n β€ 8 will hold.
* In subproblem B2 (4 points), the constraint 1 β€ n β€ 50 will hold.
Output
Output n number forming the required permutation.
Examples
Input
2 2
Output
2 1
Input
3 2
Output
1 3 2
Note
In the first example, both permutations of numbers {1, 2} yield maximum possible f(p) which is equal to 4. Among them, (2, 1) comes second in lexicographical order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAXN = 100;
long long pd[MAXN];
long long perm[MAXN];
int main() {
long long n, m;
pd[1] = 1;
for (int i = 2; i < 60; ++i) pd[i] = pd[i - 1] * 2;
while (cin >> n >> m) {
long long a = 0, b = n - 1;
m--;
for (int i = 0; i < n; ++i) {
long long x = b - a;
if (pd[x] > m) {
perm[a++] = i + 1;
} else {
perm[b--] = i + 1;
m -= pd[x];
}
}
for (int i = 0; i < n; ++i) {
cout << perm[i] << " ";
}
cout << endl;
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Input
The only line of input contains three integers a1, a2, a3 (1 β€ a1, a2, a3 β€ 20), separated by spaces.
Output
Output a single integer.
Examples
Input
2 3 2
Output
5
Input
13 14 1
Output
14
Input
14 5 9
Output
464
Input
17 18 3
Output
53
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a, b, c, n;
scanf("%d%d%d", &a, &b, &n);
for (int i = 0; i < n; i++) {
c = a + b;
a = b;
b = c;
}
printf("%d\n", a);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Bessie the cow and her best friend Elsie each received a sliding puzzle on Pi Day. Their puzzles consist of a 2 Γ 2 grid and three tiles labeled 'A', 'B', and 'C'. The three tiles sit on top of the grid, leaving one grid cell empty. To make a move, Bessie or Elsie can slide a tile adjacent to the empty cell into the empty cell as shown below:
<image>
In order to determine if they are truly Best Friends For Life (BFFLs), Bessie and Elsie would like to know if there exists a sequence of moves that takes their puzzles to the same configuration (moves can be performed in both puzzles). Two puzzles are considered to be in the same configuration if each tile is on top of the same grid cell in both puzzles. Since the tiles are labeled with letters, rotations and reflections are not allowed.
Input
The first two lines of the input consist of a 2 Γ 2 grid describing the initial configuration of Bessie's puzzle. The next two lines contain a 2 Γ 2 grid describing the initial configuration of Elsie's puzzle. The positions of the tiles are labeled 'A', 'B', and 'C', while the empty cell is labeled 'X'. It's guaranteed that both puzzles contain exactly one tile with each letter and exactly one empty position.
Output
Output "YES"(without quotes) if the puzzles can reach the same configuration (and Bessie and Elsie are truly BFFLs). Otherwise, print "NO" (without quotes).
Examples
Input
AB
XC
XB
AC
Output
YES
Input
AB
XC
AC
BX
Output
NO
Note
The solution to the first sample is described by the image. All Bessie needs to do is slide her 'A' tile down.
In the second sample, the two puzzles can never be in the same configuration. Perhaps Bessie and Elsie are not meant to be friends after all...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 2e9 + 1;
const double eps = 1e-9;
const int N = 1e5 + 5;
map<string, int> mp;
void fnd(string s) {
if (mp.count(s)) return;
mp[s] = 1;
string t1, t2;
for (int i = 0; i < 4; ++i) {
if (s[i] == 'X') {
swap(s[i], s[(i + 1) % 4]);
t1 = s;
swap(s[i], s[(i + 1) % 4]);
swap(s[i], s[(i + 3) % 4]);
t2 = s;
swap(s[i], s[(i + 3) % 4]);
fnd(t1);
fnd(t2);
}
}
}
string s1, s2;
string t1, t2;
int main() {
cin >> s1 >> s2 >> t1 >> t2;
reverse(s2.begin(), s2.end());
reverse(t2.begin(), t2.end());
s1 += s2;
fnd(s1);
t1 += t2;
if (mp.count(t1)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers β 4, 8, 15, 16, 23, 42 β and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 β€ i, j β€ 6, i and j are not necessarily distinct), and you will get the value of a_i β
a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 β€ i, j β€ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query β one line containing one integer a_i β
a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately β otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 5e3;
using namespace std;
long long x, y, pre, suc;
int main() {
for (int i = 0; i < 7; i++) suc |= (1 << i);
for (int i = 7; i < 14; i++) pre |= (1 << i);
cout << "?";
for (int i = 0; i < 100; i++) cout << " " << i;
cout << "\n";
cin >> x;
x &= pre;
fflush(stdout);
cout << "?";
for (int i = 1; i <= 100; i++) cout << " " << (i << 7);
cout << "\n";
cin >> y;
y &= suc;
fflush(stdout);
cout << "! " << (x ^ y);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
A number is called 2050-number if it is 2050, 20500, ..., (2050 β
10^k for integer k β₯ 0).
Given a number n, you are asked to represent n as the sum of some (not necessarily distinct) 2050-numbers. Compute the minimum number of 2050-numbers required for that.
Input
The first line contains a single integer T (1β€ Tβ€ 1 000) denoting the number of test cases.
The only line of each test case contains a single integer n (1β€ nβ€ 10^{18}) denoting the number to be represented.
Output
For each test case, output the minimum number of 2050-numbers in one line.
If n cannot be represented as the sum of 2050-numbers, output -1 instead.
Example
Input
6
205
2050
4100
20500
22550
25308639900
Output
-1
1
2
1
2
36
Note
In the third case, 4100 = 2050 + 2050.
In the fifth case, 22550 = 20500 + 2050.
### Response
```cpp
/*
author: Maksim1744
created: 23.04.2021 17:35:34
*/
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define sum(a) ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
template<typename T> vector<T>& operator-- (vector<T> &v){for (auto& i : v) --i; return v;}
template<typename T> vector<T>& operator++ (vector<T> &v){for (auto& i : v) ++i; return v;}
template<typename T> istream& operator>>(istream& is, vector<T> &v){for (auto& i : v) is >> i; return is;}
template<typename T> ostream& operator<<(ostream& os, vector<T> v){for (auto& i : v) os << i << ' '; return os;}
template<typename T, typename U> pair<T,U>& operator-- (pair<T, U> &p){--p.first; --p.second; return p;}
template<typename T, typename U> pair<T,U>& operator++ (pair<T, U> &p){++p.first; ++p.second; return p;}
template<typename T, typename U> istream& operator>>(istream& is, pair<T, U> &p){is >> p.first >> p.second; return is;}
template<typename T, typename U> ostream& operator<<(ostream& os, pair<T, U> p){os << p.first << ' ' << p.second; return os;}
template<typename T, typename U> pair<T,U> operator-(pair<T,U> a, pair<T,U> b){return mp(a.first-b.first, a.second-b.second);}
template<typename T, typename U> pair<T,U> operator+(pair<T,U> a, pair<T,U> b){return mp(a.first+b.first, a.second+b.second);}
template<typename T, typename U> void umin(T& a, U b){if (a > b) a = b;}
template<typename T, typename U> void umax(T& a, U b){if (a < b) a = b;}
#ifdef HOME
#define SHOW_COLORS
#include "C:/C++ libs/print.cpp"
#else
#define show(...) void(0)
#define mclock void(0)
#define shows void(0)
#define debug if (false)
#endif
void test_case(int test) {
ll n;
cin >> n;
int k = 2050;
if (n % k != 0) {
cout << -1 << '\n';
return;
}
n /= k;
int s = 0;
while (n) {
s += n % 10;
n /= 10;
}
cout << s << '\n';
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int T;
cin >> T;
for (int test = 1; test <= T; ++test) {
test_case(test);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Arya has n opponents in the school. Each day he will fight with all opponents who are present this day. His opponents have some fighting plan that guarantees they will win, but implementing this plan requires presence of them all. That means if one day at least one of Arya's opponents is absent at the school, then Arya will beat all present opponents. Otherwise, if all opponents are present, then they will beat Arya.
For each opponent Arya knows his schedule β whether or not he is going to present on each particular day. Tell him the maximum number of consecutive days that he will beat all present opponents.
Note, that if some day there are no opponents present, Arya still considers he beats all the present opponents.
Input
The first line of the input contains two integers n and d (1 β€ n, d β€ 100) β the number of opponents and the number of days, respectively.
The i-th of the following d lines contains a string of length n consisting of characters '0' and '1'. The j-th character of this string is '0' if the j-th opponent is going to be absent on the i-th day.
Output
Print the only integer β the maximum number of consecutive days that Arya will beat all present opponents.
Examples
Input
2 2
10
00
Output
2
Input
4 1
0100
Output
1
Input
4 5
1101
1111
0110
1011
1111
Output
2
Note
In the first and the second samples, Arya will beat all present opponents each of the d days.
In the third sample, Arya will beat his opponents on days 1, 3 and 4 and his opponents will beat him on days 2 and 5. Thus, the maximum number of consecutive winning days is 2, which happens on days 3 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, i, j, k, l, m, n, p, q;
long long a, b, c, d;
string s, s1, ans;
while (cin >> n >> m) {
ans = "";
for (i = 0; i < n; i++) ans += '1';
long long rem = 0;
long long cnt = 0;
for (i = 0; i < m; i++) {
cin >> s;
if (s != ans) {
cnt++;
} else {
rem = max(rem, cnt);
cnt = 0;
}
}
cout << max(rem, cnt) << endl;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There is a given string S consisting of N symbols. Your task is to find the number of ordered pairs of integers i and j such that
1. 1 β€ i, j β€ N
2. S[i] = S[j], that is the i-th symbol of string S is equal to the j-th.
Input
The single input line contains S, consisting of lowercase Latin letters and digits. It is guaranteed that string S in not empty and its length does not exceed 105.
Output
Print a single number which represents the number of pairs i and j with the needed property. Pairs (x, y) and (y, x) should be considered different, i.e. the ordered pairs count.
Examples
Input
great10
Output
7
Input
aaaaaaaaaa
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100005];
int a[100]{}, n;
long long x = 0;
scanf("%s", s), n = strlen(s);
for (int i = 0; i < n; i++) a[s[i] - '0']++;
for (int i = 0; i < 100; i++) x += 1LL * a[i] * a[i];
printf("%I64d\n", x);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Polycarpus likes studying at school a lot and he is always diligent about his homework. Polycarpus has never had any problems with natural sciences as his great-great-grandfather was the great physicist Seinstein. On the other hand though, Polycarpus has never had an easy time with history.
Everybody knows that the World history encompasses exactly n events: the i-th event had continued from the year ai to the year bi inclusive (ai < bi). Polycarpus easily learned the dates when each of n events started and ended (Polycarpus inherited excellent memory from his great-great-granddad). But the teacher gave him a more complicated task: Polycaprus should know when all events began and ended and he should also find out for each event whether it includes another event. Polycarpus' teacher thinks that an event j includes an event i if aj < ai and bi < bj. Your task is simpler: find the number of events that are included in some other event.
Input
The first input line contains integer n (1 β€ n β€ 105) which represents the number of events. Next n lines contain descriptions of the historical events, one event per line. The i + 1 line contains two integers ai and bi (1 β€ ai < bi β€ 109) β the beginning and the end of the i-th event. No two events start or finish in the same year, that is, ai β aj, ai β bj, bi β aj, bi β bj for all i, j (where i β j). Events are given in arbitrary order.
Output
Print the only integer β the answer to the problem.
Examples
Input
5
1 10
2 9
3 8
4 7
5 6
Output
4
Input
5
1 100
2 50
51 99
52 98
10 60
Output
4
Input
1
1 1000000000
Output
0
Note
In the first example the fifth event is contained in the fourth. Similarly, the fourth event is contained in the third, the third β in the second and the second β in the first.
In the second example all events except the first one are contained in the first.
In the third example only one event, so the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> a[100001];
long long int u[100001 + 1];
int FIND(int x) {
if (u[x] != u[u[x]]) u[x] = FIND(u[x]);
return u[x];
}
bool UNION(int x, int y) {
int px = FIND(x), py = FIND(y);
if (px == py) return false;
u[px] = py;
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
long long int x, y;
cin >> n;
for (int i = 0; i < n; i++) {
u[i] = i;
cin >> x >> y;
a[i].first = x;
a[i].second = y;
}
sort(a, a + n);
int cnt = 0;
for (int i = 1; i < n; i++) {
if (a[i].second < a[FIND(i - 1)].second) UNION(i, i - 1);
}
unordered_set<int> hs;
for (int i = 0; i < n; i++) {
int curr = u[i];
if (hs.find(curr) != hs.end()) cnt++;
hs.insert(curr);
}
cout << cnt;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Problem
A graph is given in which N vertices, each numbered from 1 to N, are connected by N-1 undirected edges. For each vertex, output the shortest number of steps to start from that vertex and visit all vertices.
However, one step is to follow one side from one vertex and move to another vertex.
Constraints
* 2 β€ N β€ 105
* 1 β€ ui, vi β€ N (1 β€ i β€ N-1)
* ui β vi
* The graph given is concatenated
Input
The input is given in the following format.
N
u1 v1
..
..
..
uNβ1 vNβ1
The first line is given one integer N.
In the following N-1 line, the integers ui and vi representing the vertex numbers at both ends of the i-th side are given on the i-th line, separated by blanks.
Output
Output the shortest number of steps to visit all vertices starting from vertex i on the i-th line from vertex 1 to vertex N.
Examples
Input
2
1 2
Output
1
1
Input
6
1 2
1 3
3 4
3 5
5 6
Output
7
6
8
7
7
6
### Response
```cpp
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
#define int long long
vector<int>v[200009];
int dp[300003];
int ans[300003];
int n , mod=1000000007 , m ;
void dfs( int now , int pre ) {
dp[now] = 0;
r(i,v[now].size()){
int nex = v[now][i];
if( pre == nex )continue;
dfs( nex , now );
dp[now] = max( dp[now] , dp[nex] + 1 ) % mod;
}
}
void dfs2( int now , int pre , int x ) {
ans[now] = max( dp[now] , x) % mod;
vector<int> l , r;
int N = v[now].size() + 1;
l.push_back( 0 );
r( i , v[now].size() ){
int nex = v[now][i];
int w = nex==pre ? x : dp[nex]+1 ;
l.push_back( w );
r.push_back( w );
}
r.push_back( 0 );
for( int i = 1 ; i < N ; i++ ){
l[i] = max( l[i] , l[i-1] ) % mod;
}
for( int i = N-2 ; i >= 0 ; i-- ){
r[i] = max( r[i] , r[i+1] );
}
for( int i = 0 ; i < v[now].size() ; i++ ){
if( v[now][i] == pre )continue;
dfs2( v[now][i] , now , max(l[i],r[i+1])+1 );
}
}
signed main(){
cin>>n;
r(i,n-1){
int a,b;
cin>>a>>b;a--;b--;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(0,0);
dfs2(0,0,0);
r(i,n) cout<<(n-1)*2-ans[i]<<endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Recently Monocarp got a job. His working day lasts exactly m minutes. During work, Monocarp wants to drink coffee at certain moments: there are n minutes a_1, a_2, ..., a_n, when he is able and willing to take a coffee break (for the sake of simplicity let's consider that each coffee break lasts exactly one minute).
However, Monocarp's boss doesn't like when Monocarp takes his coffee breaks too often. So for the given coffee break that is going to be on minute a_i, Monocarp must choose the day in which he will drink coffee during the said minute, so that every day at least d minutes pass between any two coffee breaks. Monocarp also wants to take these n coffee breaks in a minimum possible number of working days (he doesn't count days when he is not at work, and he doesn't take coffee breaks on such days). Take into account that more than d minutes pass between the end of any working day and the start of the following working day.
For each of the n given minutes determine the day, during which Monocarp should take a coffee break in this minute. You have to minimize the number of days spent.
Input
The first line contains three integers n, m, d (1 β€ n β€ 2β
10^{5}, n β€ m β€ 10^{9}, 1 β€ d β€ m) β the number of coffee breaks Monocarp wants to have, the length of each working day, and the minimum number of minutes between any two consecutive coffee breaks.
The second line contains n distinct integers a_1, a_2, ..., a_n (1 β€ a_i β€ m), where a_i is some minute when Monocarp wants to have a coffee break.
Output
In the first line, write the minimum number of days required to make a coffee break in each of the n given minutes.
In the second line, print n space separated integers. The i-th of integers should be the index of the day during which Monocarp should have a coffee break at minute a_i. Days are numbered from 1. If there are multiple optimal solutions, you may print any of them.
Examples
Input
4 5 3
3 5 1 2
Output
3
3 1 1 2
Input
10 10 1
10 5 7 4 6 3 2 1 9 8
Output
2
2 1 1 2 2 1 2 1 1 2
Note
In the first example, Monocarp can take two coffee breaks during the first day (during minutes 1 and 5, 3 minutes will pass between these breaks). One break during the second day (at minute 2), and one break during the third day (at minute 3).
In the second example, Monocarp can determine the day of the break as follows: if the minute when he wants to take a break is odd, then this break is on the first day, if it is even, then this break is on the second day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, d, a[200005], ans[200005], i, val;
multiset<pair<long long int, long long int> > s;
cin >> n >> m >> d;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
s.insert({a[i], i});
}
long long int days = 1;
while (!s.empty()) {
auto it = s.begin();
val = it->first;
ans[it->second] = days;
s.erase(it);
while (1) {
auto it2 = s.upper_bound({val + d, n});
if (it2 == s.end()) break;
ans[it2->second] = days;
val = it2->first;
s.erase(it2);
}
days++;
}
cout << days - 1 << endl;
for (i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Two players play a simple game. Each player is provided with a box with balls. First player's box contains exactly n1 balls and second player's box contains exactly n2 balls. In one move first player can take from 1 to k1 balls from his box and throw them away. Similarly, the second player can take from 1 to k2 balls from his box in his move. Players alternate turns and the first player starts the game. The one who can't make a move loses. Your task is to determine who wins if both players play optimally.
Input
The first line contains four integers n1, n2, k1, k2. All numbers in the input are from 1 to 50.
This problem doesn't have subproblems. You will get 3 points for the correct submission.
Output
Output "First" if the first player wins and "Second" otherwise.
Examples
Input
2 2 1 2
Output
Second
Input
2 1 1 1
Output
First
Note
Consider the first sample test. Each player has a box with 2 balls. The first player draws a single ball from his box in one move and the second player can either take 1 or 2 balls from his box in one move. No matter how the first player acts, the second player can always win if he plays wisely.
### Response
```cpp
#include <bits/stdc++.h>
int f[60][60][3], n1, n2, k1, k2;
int Max(int a, int b) {
if (a > b) return a;
return b;
}
int Gen(int x, int y, int pl) {
if (f[x][y][pl] != -1) return f[x][y][pl];
int v = 0, p = 0;
if (pl == 1) {
for (int i = x - 1; i >= Max(0, x - k1); i--)
if (Gen(i, y, 3 - pl))
v = 1;
else
p = 1;
if (v)
f[x][y][pl] = 1;
else
f[x][y][pl] = 0;
} else {
for (int i = y - 1; i >= Max(0, y - k2); i--)
if (Gen(x, i, 3 - pl))
v = 1;
else
p = 1;
if (p)
f[x][y][pl] = 0;
else
f[x][y][pl] = 1;
}
return f[x][y][pl];
}
int main() {
scanf("%d%d%d%d", &n1, &n2, &k1, &k2);
for (int i = 0; i < 60; i++)
for (int j = 0; j < 60; j++) f[i][j][2] = f[i][j][1] = -1;
for (int i = 1; i <= n2; i++) f[0][i][2] = 0;
for (int i = 1; i <= n1; i++) f[i][0][2] = 1;
if (Gen(n1, n2, 1))
printf("First");
else
printf("Second");
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
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 c=1,a,b;
int main(){
cin>>a>>b;
while(a>=b){
a/=b;
c++;
}
cout<<c<<endl;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int n; cin >> n;
int p[n+1], a[n+1], b[n+1];
for(int i=1; i<=n; i++){
cin >> p[i];
a[i] = i*n;
b[i] = n*(n-i+1);
}
for(int i=1; i<=n; i++){
b[p[i]] += i-1;
}
for(int i=1; i<=n; i++)
cout << a[i] << " ";
cout << endl;
for(int i=1; i<=n; i++)
cout << b[i] << " ";
cout << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
<image>
Recently, a wild Krakozyabra appeared at Jelly Castle. It is, truth to be said, always eager to have something for dinner.
Its favorite meal is natural numbers (typically served with honey sauce), or, to be more precise, the zeros in their corresponding decimal representations. As for other digits, Krakozyabra dislikes them; moreover, they often cause it indigestion! So, as a necessary precaution, Krakozyabra prefers to sort the digits of a number in non-descending order before proceeding to feast. Then, the leading zeros of the resulting number are eaten and the remaining part is discarded as an inedible tail.
For example, if Krakozyabra is to have the number 57040 for dinner, its inedible tail would be the number 457.
Slastyona is not really fond of the idea of Krakozyabra living in her castle. Hovewer, her natural hospitality prevents her from leaving her guest without food. Slastyona has a range of natural numbers from L to R, which she is going to feed the guest with. Help her determine how many distinct inedible tails are going to be discarded by Krakozyabra by the end of the dinner.
Input
In the first and only string, the numbers L and R are given β the boundaries of the range (1 β€ L β€ R β€ 1018).
Output
Output the sole number β the answer for the problem.
Examples
Input
1 10
Output
9
Input
40 57
Output
17
Input
157 165
Output
9
Note
In the first sample case, the inedible tails are the numbers from 1 to 9. Note that 10 and 1 have the same inedible tail β the number 1.
In the second sample case, each number has a unique inedible tail, except for the pair 45, 54. The answer to this sample case is going to be (57 - 40 + 1) - 1 = 17.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1000000007;
template <typename T, typename F>
T foo(T t, T g, F f) {
return t;
}
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
auto fraclt = [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
return (long long)a.first * b.second < (long long)b.first * a.second;
};
struct cmpfrac {
bool operator()(const std::pair<int, int>& a,
const std::pair<int, int>& b) const {
return (long long)a.first * b.second < (long long)b.first * a.second;
}
};
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
int logceil(long long first) {
int b = 0;
while (first) {
first >>= 1;
++b;
}
return b;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector<vector<T>>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, t))) {}
};
template <typename T>
struct bounded_priority_queue {
inline bounded_priority_queue(unsigned int X) : A(X), B(0) {}
inline void push(unsigned int L, T V) {
B = max(B, L);
A[L].push(V);
}
inline const T& top() const { return A[B].front(); }
inline void pop() {
A[B].pop();
while (B > 0 && A[B].empty()) --B;
}
inline bool empty() const { return A[B].empty(); }
inline void clear() {
B = 0;
for (auto& a : A) a = queue<T>();
}
private:
vector<queue<T>> A;
unsigned int B;
};
constexpr long long toomuch = 1000000000000000000LL;
class TaskC {
public:
vector<int> L, R;
vector<int> DIG, Q, S;
int ans;
bool is_below_r(vector<int>& DIG, int i) {
if (DIG[R[i]] > 0) {
DIG[R[i]]--;
for (int j = i + 1; j < 18; ++j) {
for (int k = 0; k < R[j]; ++k) {
if (DIG[k] > 0) return true;
}
if (DIG[R[j]] == 0) return false;
DIG[R[j]]--;
}
return true;
}
return false;
}
bool is_within_range() {
int i = 0;
while (L[i] == R[i]) {
if (Q[L[i]] == 0) return false;
Q[L[i]]--;
i++;
}
for (int j = L[i] + 1; j < R[i]; ++j) {
if (Q[j]) return true;
}
if (Q[L[i]] > 0) {
S = Q;
S[L[i]]--;
for (int j = i + 1; j < 18; ++j) {
for (int k = L[j] + 1; k < 10; ++k) {
if (S[k] > 0) return true;
}
if (S[L[j]] == 0) return is_below_r(Q, i);
S[L[j]]--;
}
return true;
}
return is_below_r(Q, i);
}
void gen(int d, int rem) {
if (d == 9) {
DIG[9] = rem;
Q = DIG;
if (is_within_range()) ++ans;
return;
}
for (int i = 0; i <= rem; ++i) {
DIG[d] = i;
gen(d + 1, rem - i);
}
}
void split(long long first, vector<int>& tar) {
for (int i = 17; i >= 0; --i) {
tar[i] = first % 10;
first /= 10;
}
}
void solve(istream& cin, ostream& cout) {
DIG.resize(10);
long long a, b;
cin >> a >> b;
if (a == b) {
cout << 1 << endl;
return;
}
if (a == toomuch - 1 && b == toomuch) {
cout << 2 << endl;
return;
}
bool ismax = b == toomuch;
if (ismax) --b;
L.resize(18);
R.resize(18);
split(a, L);
split(b, R);
ans = 0;
gen(0, 18);
if (ismax && a > toomuch / 10) {
++ans;
}
cout << ans << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
TaskC solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Given is a string S. Each character in S is either a digit (`0`, ..., `9`) or `?`.
Among the integers obtained by replacing each occurrence of `?` with a digit, how many have a remainder of 5 when divided by 13? An integer may begin with 0.
Since the answer can be enormous, print the count modulo 10^9+7.
Constraints
* S is a string consisting of digits (`0`, ..., `9`) and `?`.
* 1 \leq |S| \leq 10^5
Input
Input is given from Standard Input in the following format:
S
Output
Print the number of integers satisfying the condition, modulo 10^9+7.
Examples
Input
??2??5
Output
768
Input
?44
Output
1
Input
7?4
Output
0
Input
?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???
Output
153716888
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int N = 13, M = 1e9 + 7;
vector<int> DP(N);
DP.at(0) = 1;
string S;
cin >> S;
for (int i = 0; i < S.size(); i++) {
vector<int> V(N);
for (int j = 0; j < N; j++) {
for (int k = 0; k < 10; k++) {
if (S.at(i) == '?' || S.at(i) == '0' + k) {
(V.at((j * 10 + k) % 13) += DP.at(j)) %= M;
}
}
}
DP = V;
}
cout << DP.at(5) << "\n";
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
[3R2 - Standby for Action](https://www.youtube.com/watch?v=P2ZVC9aoiKo)
Our dear Cafe's owner, JOE Miller, will soon take part in a new game TV-show "1 vs. n"!
The game goes in rounds, where in each round the host asks JOE and his opponents a common question. All participants failing to answer are eliminated. The show ends when only JOE remains (we assume that JOE never answers a question wrong!).
For each question JOE answers, if there are s (s > 0) opponents remaining and t (0 β€ t β€ s) of them make a mistake on it, JOE receives \displaystylet/s dollars, and consequently there will be s - t opponents left for the next question.
JOE wonders what is the maximum possible reward he can receive in the best possible scenario. Yet he has little time before show starts, so can you help him answering it instead?
Input
The first and single line contains a single integer n (1 β€ n β€ 10^5), denoting the number of JOE's opponents in the show.
Output
Print a number denoting the maximum prize (in dollars) JOE could have.
Your answer will be considered correct if it's absolute or relative error won't exceed 10^{-4}. In other words, if your answer is a and the jury answer is b, then it must hold that (|a - b|)/(max(1, b)) β€ 10^{-4}.
Examples
Input
1
Output
1.000000000000
Input
2
Output
1.500000000000
Note
In the second example, the best scenario would be: one contestant fails at the first question, the other fails at the next one. The total reward will be \displaystyle 1/2 + 1/1 = 1.5 dollars.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long M = (int)1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
double res = 0;
for (int i = 1; i <= n; i++) {
res += 1.0 / i;
}
cout << fixed << setprecision(16) << res;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
The Smart Beaver has recently designed and built an innovative nanotechnologic all-purpose beaver mass shaving machine, "Beavershave 5000". Beavershave 5000 can shave beavers by families! How does it work? Very easily!
There are n beavers, each of them has a unique id from 1 to n. Consider a permutation a1, a2, ..., an of n these beavers. Beavershave 5000 needs one session to shave beavers with ids from x to y (inclusive) if and only if there are such indices i1 < i2 < ... < ik, that ai1 = x, ai2 = x + 1, ..., aik - 1 = y - 1, aik = y. And that is really convenient. For example, it needs one session to shave a permutation of beavers 1, 2, 3, ..., n.
If we can't shave beavers from x to y in one session, then we can split these beavers into groups [x, p1], [p1 + 1, p2], ..., [pm + 1, y] (x β€ p1 < p2 < ... < pm < y), in such a way that the machine can shave beavers in each group in one session. But then Beavershave 5000 needs m + 1 working sessions to shave beavers from x to y.
All beavers are restless and they keep trying to swap. So if we consider the problem more formally, we can consider queries of two types:
* what is the minimum number of sessions that Beavershave 5000 needs to shave beavers with ids from x to y, inclusive?
* two beavers on positions x and y (the beavers ax and ay) swapped.
You can assume that any beaver can be shaved any number of times.
Input
The first line contains integer n β the total number of beavers, 2 β€ n. The second line contains n space-separated integers β the initial beaver permutation.
The third line contains integer q β the number of queries, 1 β€ q β€ 105. The next q lines contain the queries. Each query i looks as pi xi yi, where pi is the query type (1 is to shave beavers from xi to yi, inclusive, 2 is to swap beavers on positions xi and yi). All queries meet the condition: 1 β€ xi < yi β€ n.
* to get 30 points, you need to solve the problem with constraints: n β€ 100 (subproblem B1);
* to get 100 points, you need to solve the problem with constraints: n β€ 3Β·105 (subproblems B1+B2).
Note that the number of queries q is limited 1 β€ q β€ 105 in both subproblem B1 and subproblem B2.
Output
For each query with pi = 1, print the minimum number of Beavershave 5000 sessions.
Examples
Input
5
1 3 4 2 5
6
1 1 5
1 3 4
2 2 3
1 1 5
2 1 5
1 1 5
Output
2
1
3
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 50;
const int INF = 0x3f3f3f3f;
int a[maxn], id[maxn];
struct node {
int l, r, sum;
} tree[maxn << 2];
void push_up(int i) { tree[i].sum = tree[i << 1].sum + tree[i << 1 | 1].sum; }
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
tree[i].sum = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
push_up(i);
}
void updata(int i, int x, int k) {
if (tree[i].l == tree[i].r && tree[i].l == x) {
tree[i].sum = k;
return;
}
int mid = (tree[i].l + tree[i].r) >> 1;
if (x <= mid)
updata(i << 1, x, k);
else
updata(i << 1 | 1, x, k);
push_up(i);
}
int query(int i, int x, int y) {
if (tree[i].l >= x && tree[i].r <= y) return tree[i].sum;
int mid = (tree[i].l + tree[i].r) >> 1;
if (y <= mid)
return query(i << 1, x, y);
else if (x > mid)
return query(i << 1 | 1, x, y);
else
return query(i << 1, x, mid) + query(i << 1 | 1, mid + 1, y);
}
int main() {
int n;
scanf("%d", &n);
memset(id, 0, sizeof(id));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
id[a[i]] = i;
}
build(1, 0, maxn - 30);
for (int i = 1; i <= n; i++)
if (id[a[i] + 1] < id[a[i]]) updata(1, a[i], 1);
int m;
scanf("%d", &m);
while (m--) {
int op, l, r;
scanf("%d%d%d", &op, &l, &r);
if (op == 1) {
int ans = query(1, l, r);
if (query(1, r, r) == 0) ans++;
printf("%d\n", ans);
} else {
swap(id[a[l]], id[a[r]]);
swap(a[l], a[r]);
for (int i = -1; i <= 1; i++) {
int k = a[l] + i;
if (id[k + 1] < id[k])
updata(1, k, 1);
else
updata(1, k, 0);
k = a[r] + i;
if (id[k + 1] < id[k])
updata(1, k, 1);
else
updata(1, k, 0);
}
}
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
It is a holiday season, and Koala is decorating his house with cool lights! He owns n lights, all of which flash periodically.
After taking a quick glance at them, Koala realizes that each of his lights can be described with two parameters a_i and b_i. Light with parameters a_i and b_i will toggle (on to off, or off to on) every a_i seconds starting from the b_i-th second. In other words, it will toggle at the moments b_i, b_i + a_i, b_i + 2 β
a_i and so on.
You know for each light whether it's initially on or off and its corresponding parameters a_i and b_i. Koala is wondering what is the maximum number of lights that will ever be on at the same time. So you need to find that out.
<image> Here is a graphic for the first example.
Input
The first line contains a single integer n (1 β€ n β€ 100), the number of lights.
The next line contains a string s of n characters. The i-th character is "1", if the i-th lamp is initially on. Otherwise, i-th character is "0".
The i-th of the following n lines contains two integers a_i and b_i (1 β€ a_i, b_i β€ 5) β the parameters of the i-th light.
Output
Print a single integer β the maximum number of lights that will ever be on at the same time.
Examples
Input
3
101
3 3
3 2
3 1
Output
2
Input
4
1111
3 4
5 2
3 1
3 2
Output
4
Input
6
011100
5 3
5 5
2 4
3 5
4 2
1 5
Output
6
Note
For first example, the lamps' states are shown in the picture above. The largest number of simultaneously on lamps is 2 (e.g. at the moment 2).
In the second example, all lights are initially on. So the answer is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long double eps = 1e-6;
const long long maxn = 1e5;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
vector<pair<long long, long long>> v(n);
for (long long i = 0; i < n; ++i) cin >> v[i].first >> v[i].second;
long long ans = 0;
for (long long t = 0; t <= maxn; ++t) {
long long cnt = 0;
for (long long i = 0; i < n; ++i) {
if (t < v[i].second)
cnt += (s[i] == '1');
else if (((t - v[i].second) / v[i].first) % 2 == (long long)(s[i] - '0'))
++cnt;
}
ans = max(ans, cnt);
}
cout << ans;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Heidi is terrified by your estimate and she found it unrealistic that her friends would collaborate to drive her into debt. She expects that, actually, each person will just pick a random friend to send Heidi to. (This randomness assumption implies, however, that she can now visit the same friend an arbitrary number of times...) Moreover, if a person only has one friend in common with Heidi (i.e., if that person is in a leaf of the tree), then that person will not send Heidi back (so that Heidi's travel will end at some point).
Heidi also found unrealistic the assumption that she can make all the travels in one day. Therefore now she assumes that every time she travels a route between two friends, she needs to buy a new ticket. She wants to know: how much should she expect to spend on the trips?
For what it's worth, Heidi knows that Jenny has at least two friends.
Input
The first line contains the number of friends n (3 β€ n β€ 105). The next n - 1 lines each contain three space-separated integers u, v and c (0 β€ u, v β€ n - 1, 1 β€ c β€ 104) meaning that u and v are friends and the cost for traveling between u and v is c (paid every time!).
It is again guaranteed that the social network of the input forms a tree.
Output
Assume that the expected cost of the trips is written as an irreducible fraction a / b (that is, a and b are coprime). Then Heidi, the weird cow that she is, asks you to output <image>. (Output a single integer between 0 and 109 + 6.)
Examples
Input
3
0 1 10
0 2 20
Output
15
Input
4
0 1 3
0 2 9
0 3 27
Output
13
Input
7
0 1 3
0 5 7
1 2 2
1 3 1
1 4 5
5 6 8
Output
400000019
Input
11
1 0 6646
2 0 8816
3 2 9375
4 2 5950
5 1 8702
6 2 2657
7 2 885
8 7 2660
9 2 5369
10 6 3798
Output
153869806
Input
6
0 1 8
0 2 24
1 3 40
1 4 16
4 5 8
Output
39
Note
In the first example, with probability 1 / 2 Heidi will go to 1 from 0, and with probability 1 / 2 she will go to 2. In the first case the cost would be 10, and in the second it would be 20. After reaching 1 or 2 she will stop, as 1 and 2 are leaves of the social tree. Hence, the expected cost she has to pay is 10Β·1 / 2 + 20Β·1 / 2 = 15.
In the third example, the expected cost is 81 / 5. You should output 400000019.
In her travels, Heidi has learned an intriguing fact about the structure of her social network. She tells you the following: The mysterious determinant that you might be wondering about is such that it does not cause strange errors in your reasonable solution... Did we mention that Heidi is a weird cow?
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = pow(10, 9) + 7;
const long long N = 100005 * 2;
long long n;
struct qq {
long long x, y, z, last;
} e[N];
long long num, last[N];
long long k[N], b[N], f[N];
int d[N];
void init(long long x, long long y, long long z) {
num++;
e[num].x = x;
e[num].y = y;
e[num].z = z;
e[num].last = last[x];
last[x] = num;
}
long long pow(long long x, long long y) {
if (y == 1) return x;
long long lalal = pow(x, y >> 1);
lalal = lalal * lalal % MOD;
if (y & 1) lalal = lalal * x % MOD;
return lalal;
}
long long Q[N];
void dfs(long long x) {
Q[++Q[0]] = x;
for (long long u = last[x]; u != -1; u = e[u].last) {
long long y = e[u].y;
if (y == f[x]) continue;
f[y] = x;
dfs(y);
}
}
int main() {
ios::sync_with_stdio(false);
num = 0;
memset(last, -1, sizeof(last));
cin >> n;
for (long long u = 1; u < n; u++) {
long long x, y, z;
cin >> x >> y >> z;
x++;
y++;
init(x, y, z);
init(y, x, z);
k[x]++;
k[y]++;
d[x]++;
d[y]++;
b[x] += z;
b[y] += z;
}
dfs(1);
for (long long u = Q[0]; u >= 2; u--) {
long long x = Q[u];
if (d[x] == 1) continue;
long long tmp = pow(k[x], MOD - 2);
k[f[x]] = (k[f[x]] - tmp) % MOD;
b[f[x]] = (b[f[x]] + b[x] * tmp % MOD) % MOD;
}
long long ans = (b[1] * pow(k[1], MOD - 2) % MOD + MOD) % MOD;
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 β€ n β€ 100). Each of the n lines following it has an integral score s (0 β€ s β€ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
while(cin >> n, n) {
int dat[n];
for(int i=0; i<n; i++) cin >> dat[i];
sort(dat, dat+n);
int ave = 0;
for(int i=1; i<n-1; i++) ave += dat[i];
ave /= n-2;
cout << ave << endl;
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given an integer sequence of length N: A_1,A_2,...,A_N. Let us perform Q operations in order. The i-th operation is described by two integers X_i and Y_i. In this operation, we will choose one of the following two actions and perform it:
* Swap the values of A_{X_i} and A_{Y_i}
* Do nothing
There are 2^Q ways to perform these operations. Find the sum of the inversion numbers of the final sequences for all of these ways to perform operations, modulo 10^9+7.
Here, the inversion number of a sequence P_1,P_2,...,P_M is the number of pairs of integers (i,j) such that 1\leq i < j\leq M and P_i > P_j.
Constraints
* 1 \leq N \leq 3000
* 0 \leq Q \leq 3000
* 0 \leq A_i \leq 10^9(1\leq i\leq N)
* 1 \leq X_i,Y_i \leq N(1\leq i\leq Q)
* X_i\neq Y_i(1\leq i\leq Q)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N Q
A_1
:
A_N
X_1 Y_1
:
X_Q Y_Q
Output
Print the sum of the inversion numbers of the final sequences, modulo 10^9+7.
Examples
Input
3 2
1
2
3
1 2
1 3
Output
6
Input
5 3
3
2
3
1
4
1 5
2 3
4 2
Output
36
Input
9 5
3
1
4
1
5
9
2
6
5
3 5
8 9
7 9
3 2
3 8
Output
425
### Response
```cpp
#include <bits/stdc++.h>
const int N = 3005, mod = 1000000007, i2 = mod + 1 >> 1;
typedef long long LL;
int n, q, dp[N][N], tmp[N][N], x, y, A[N];
void copy(int x, int y) { tmp[x][y] = dp[x][y]; }
void update(int X, int Y) {
int tx = X, ty = Y;
if (tx == x) tx = y; else if (tx == y) tx = x;
if (ty == x) ty = y; else if (ty == y) ty = x;
dp[X][Y] = (LL) i2 * (tmp[X][Y] + tmp[tx][ty]) % mod;
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> q;
for (int i = 1; i <= n; ++i) std::cin >> A[i];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dp[i][j] = A[i] > A[j];
for (int i = 1; i <= q; ++i) {
std::cin >> x >> y;
for (int j = 1; j <= n; ++j)
copy(x, j), copy(j, x), copy(y, j), copy(j, y);
for (int j = 1; j <= n; ++j)
update(x, j), update(j, x), update(y, j), update(j, y);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
ans += dp[i][j] - mod, ans += ans >> 31 & mod;
for (int i = 1; i <= q; ++i)
ans += ans - mod, ans += ans >> 31 & mod;
std::cout << ans << '\n';
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Hakone Ekiden is one of the Japanese New Year's traditions. In Hakone Ekiden, 10 runners from each team aim for the goal while connecting the sashes at each relay station. In the TV broadcast, the ranking change from the previous relay station is displayed along with the passing order of each team at the relay station. So, look at it and tell us how many possible passage orders for each team at the previous relay station. The number of possible transit orders can be very large, so answer by the remainder divided by 1,000,000,007.
Input
The input is given in the form:
> n
> c1
> c2
> ...
> cn
>
The number n (1 β€ n β€ 200) representing the number of teams is on the first line, and the ranking changes from the previous relay station in order from the first place on the following n lines. If it is'`U`', the ranking is up, if it is'`-`', the ranking is not changed) is written.
Output
Please output in one line by dividing the number of passages that could have been the previous relay station by 1,000,000,007.
Examples
Input
3
-
U
D
Output
1
Input
5
U
U
-
D
D
Output
5
Input
8
U
D
D
D
D
D
D
D
Output
1
Input
10
U
D
U
D
U
D
U
D
U
D
Output
608
Input
2
D
U
Output
0
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
#define reep(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,n) reep((i),0,(n))
long long MOD = 1000000007LL;
long long dp[210][210][210];
int main() {
int n;
cin >> n;
dp[0][0][0] = 1;
vector<char> v(n);
rep(i, n) {
cin >> v[i];
if(v[i] == '-') {
n--;
i--;
}
}
v.erase(v.begin()+n, v.end());
rep(i, n) {
char t = v[i];
rep(j, n) {
rep(k, n) {
if(t == 'U') {
if(j>0) (dp[i + 1][j][k] += j*dp[i][j][k]%MOD) %= MOD;
(dp[i + 1][j + 1][k + 1] += dp[i][j][k]) %= MOD;
}
else {
if(j - 1 >= 0 && k - 1 >= 0) (dp[i + 1][j - 1][k - 1] += j*k*dp[i][j][k]) %= MOD;
if(j>0) (dp[i + 1][j][k] += k*dp[i][j][k]) %= MOD;
}
}
}
}
rep(i,n+1){
rep(j,n){
rep(k,n){
// cout<<i<<" "<<j<<" "<<k<<" "<<dp[i][j][k]<<endl;
}
}
}
cout << dp[n][0][0] << endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There is a long plate s containing n digits. Iahub wants to delete some digits (possibly none, but he is not allowed to delete all the digits) to form his "magic number" on the plate, a number that is divisible by 5. Note that, the resulting number may contain leading zeros.
Now Iahub wants to count the number of ways he can obtain magic number, modulo 1000000007 (109 + 7). Two ways are different, if the set of deleted positions in s differs.
Look at the input part of the statement, s is given in a special form.
Input
In the first line you're given a string a (1 β€ |a| β€ 105), containing digits only. In the second line you're given an integer k (1 β€ k β€ 109). The plate s is formed by concatenating k copies of a together. That is n = |a|Β·k.
Output
Print a single integer β the required number of ways modulo 1000000007 (109 + 7).
Examples
Input
1256
1
Output
4
Input
13990
2
Output
528
Input
555
2
Output
63
Note
In the first case, there are four possible ways to make a number that is divisible by 5: 5, 15, 25 and 125.
In the second case, remember to concatenate the copies of a. The actual plate is 1399013990.
In the third case, except deleting all digits, any choice will do. Therefore there are 26 - 1 = 63 possible ways to delete digits.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long Pow(long long a, long long b, long long m) {
long long ret = 1;
for (; b; b >>= 1) {
if (b & 1) {
ret *= a;
ret %= m;
}
a *= a;
a %= m;
}
return ret;
}
long long copies;
string s;
int main() {
cin >> s >> copies;
long long plus =
((Pow(2, s.length() * copies, 1000000007) - 1) *
Pow((Pow(2, s.length(), 1000000007) - 1 + 1000000007) % 1000000007,
1000000007 - 2, 1000000007) %
1000000007 +
1000000007) %
1000000007;
int ans = 0;
for (int i = 0; i < s.length(); i++)
if (s[i] == '0' || s[i] == '5')
ans = (ans + Pow(2, i, 1000000007) * plus) % 1000000007;
cout << ans << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Are you going to Scarborough Fair?
Parsley, sage, rosemary and thyme.
Remember me to one who lives there.
He once was the true love of mine.
Willem is taking the girl to the highest building in island No.28, however, neither of them knows how to get there.
Willem asks his friend, Grick for directions, Grick helped them, and gave them a task.
Although the girl wants to help, Willem insists on doing it by himself.
Grick gave Willem a string of length n.
Willem needs to do m operations, each operation has four parameters l, r, c1, c2, which means that all symbols c1 in range [l, r] (from l-th to r-th, including l and r) are changed into c2. String is 1-indexed.
Grick wants to know the final string after all the m operations.
Input
The first line contains two integers n and m (1 β€ n, m β€ 100).
The second line contains a string s of length n, consisting of lowercase English letters.
Each of the next m lines contains four parameters l, r, c1, c2 (1 β€ l β€ r β€ n, c1, c2 are lowercase English letters), separated by space.
Output
Output string s after performing m operations described above.
Examples
Input
3 1
ioi
1 1 i n
Output
noi
Input
5 3
wxhak
3 3 h x
1 5 x a
1 3 w g
Output
gaaak
Note
For the second example:
After the first operation, the string is wxxak.
After the second operation, the string is waaak.
After the third operation, the string is gaaak.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
const long long INF = 1e18 + 7;
const double eps = 1e-9;
int n, a[MAXN], m;
string s;
string d[MAXN], f[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
cin >> s;
for (int i = 1; i <= m; i++) {
int l = 0, r = 0;
char c1, c2;
cin >> l >> r >> c1 >> c2;
for (int j = l - 1; j < r; j++) {
if (s[j] == c1) s[j] = c2;
}
}
cout << s;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Polycarp often uses his smartphone. He has already installed n applications on it. Application with number i takes up a_i units of memory.
Polycarp wants to free at least m units of memory (by removing some applications).
Of course, some applications are more important to Polycarp than others. He came up with the following scoring system β he assigned an integer b_i to each application:
* b_i = 1 β regular application;
* b_i = 2 β important application.
According to this rating system, his phone has b_1 + b_2 + β¦ + b_n convenience points.
Polycarp believes that if he removes applications with numbers i_1, i_2, β¦, i_k, then he will free a_{i_1} + a_{i_2} + β¦ + a_{i_k} units of memory and lose b_{i_1} + b_{i_2} + β¦ + b_{i_k} convenience points.
For example, if n=5, m=7, a=[5, 3, 2, 1, 4], b=[2, 1, 1, 2, 1], then Polycarp can uninstall the following application sets (not all options are listed below):
* applications with numbers 1, 4 and 5. In this case, it will free a_1+a_4+a_5=10 units of memory and lose b_1+b_4+b_5=5 convenience points;
* applications with numbers 1 and 3. In this case, it will free a_1+a_3=7 units of memory and lose b_1+b_3=3 convenience points.
* applications with numbers 2 and 5. In this case, it will free a_2+a_5=7 memory units and lose b_2+b_5=2 convenience points.
Help Polycarp, choose a set of applications, such that if removing them will free at least m units of memory and lose the minimum number of convenience points, or indicate that such a set does not exist.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and m (1 β€ n β€ 2 β
10^5, 1 β€ m β€ 10^9) β the number of applications on Polycarp's phone and the number of memory units to be freed.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the number of memory units used by applications.
The third line of each test case contains n integers b_1, b_2, β¦, b_n (1 β€ b_i β€ 2) β the convenience points of each application.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5.
Output
For each test case, output on a separate line:
* -1, if there is no set of applications, removing which will free at least m units of memory;
* the minimum number of convenience points that Polycarp will lose if such a set exists.
Example
Input
5
5 7
5 3 2 1 4
2 1 1 2 1
1 3
2
1
5 10
2 3 2 3 2
1 2 1 2 1
4 10
5 1 3 4
1 2 1 2
4 5
3 2 1 2
2 1 2 1
Output
2
-1
6
4
3
Note
In the first test case, it is optimal to remove applications with numbers 2 and 5, freeing 7 units of memory. b_2+b_5=2.
In the second test case, by removing the only application, Polycarp will be able to clear only 2 of memory units out of the 3 needed.
In the third test case, it is optimal to remove applications with numbers 1, 2, 3 and 4, freeing 10 units of memory. b_1+b_2+b_3+b_4=6.
In the fourth test case, it is optimal to remove applications with numbers 1, 3 and 4, freeing 12 units of memory. b_1+b_3+b_4=4.
In the fifth test case, it is optimal to remove applications with numbers 1 and 2, freeing 5 units of memory. b_1+b_2=3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
#define int long long
#define fi(i,n) for(int i=0;i<n;i++)
#define f(i, a, b) for(int i=a;i<b;i++)
#define vi vector<int>
#define pb push_back
#define MOD 1000000007
#define pii pair<int, int>
#define ff first
#define ss second
#define setzero(a) memset(a,0,sizeof(a))
#define prDouble(x) cout<<fixed<<setprecision(10)<<x;
#define SetBits(x) __builtin_popcount(x)
#define in_range(x, y, r, c) (x >= 0 && x < r && y >= 0 && y < c)
ll digits(ll n)
{
return floor(log10(double(n))) + 1;
}
void faster()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
ll modularExponentiation(ll x,ll n,ll M)
{
ll result = 1;
while(n>0)
{
if(n % 2 ==1)
{
result = ((result%M)*(x%M))%M;
}
x = ((x%M)*(x%M))%M;
n = n/2;
}
return result%M;
}
bool ispower(int n)
{
if(n%2==1)
return false;
while(n>0)
{
if(n%2 == 1)
return false;
n = n/2;
}
return true;
}
// {1,{2,3}} {2,3}
//4 4
int32_t main()
{
faster();
int t;
cin>>t;
while(t--)
{
int n,m;
cin>>n>>m;
int points[n];
fi(i,n)cin>>points[i];
vector<int>one_penalty,two_penalty;
vector<pair<int,pair<int,int>>>dp(2*n + 1);//dp[i] will store max ans till i and penalty
fi(i,n)
{
int x;
cin>>x;
if(x==1)
one_penalty.push_back(points[i]);
else
two_penalty.push_back(points[i]);
}
int si1 = one_penalty.size();
int si2 = two_penalty.size();
sort(one_penalty.begin(),one_penalty.end());
sort(two_penalty.begin(),two_penalty.end());
if(si1 - 1>=0)
{
dp[1].first = one_penalty[si1 - 1];
dp[1].second.first = si1 - 2;
dp[1].second.second = si2 -1;
}
else
{
dp[1].first = -1;
dp[1].second.first = -1;
dp[1].second.second = -1;
}
dp[0].first = 0;
dp[0].second.first = si1 - 1;
dp[0].second.second = si2 - 1;
//cout<<dp[1].first<<" ";
int ans = -1;
if(dp[1].first>=m)
{
ans = 1;
cout<<ans<<endl;
continue;
}
for(int i = 2; i<=2*n; i++)
{
int ma1 = -1;
int ma2 = -1;
int pre1 = dp[i - 1].first;
int pre1first = dp[i - 1].second.first;
int pre1second = dp[i - 1].second.second;
//cout<<pre1<<" "<<pre1first<<" "<<pre1second<<endl;
if(pre1first>=0 && pre1 != -1)
{
ma1 = pre1 +one_penalty[pre1first];
}
int pre2 = dp[i - 2].first;
int pre2first = dp[i - 2].second.first;
int pre2second = dp[i - 2].second.second;
if(pre2second>=0 && pre2 != -1)
{
ma2 = pre2 + two_penalty[pre2second];
}
if(ma1 == -1 && ma2 == -1)
{
dp[i].first = -1;
dp[i].second.first = -1;
dp[i].second.first = -1;
}
else if(ma1>ma2)
{
dp[i].first = ma1;
dp[i].second.first = dp[i - 1].second.first - 1;
dp[i].second.second = dp[i -1].second.second;
}
else
{
dp[i].first =ma2;
dp[i].second.first = dp[i - 2].second.first;
dp[i].second.second = dp[i - 2].second.second - 1;
}
//cout<<dp[i].first<<" ";
if(dp[i].first >= m)
{
ans = i;
break;
}
//cout<<dp[i].first<<" ";
}
cout<<ans<<endl;
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
### Response
```cpp
#include <cstdio>
int main()
{
int n, m;
scanf("%d%d", &n, &m);
puts(n == m ? "Yes" : "No");
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are n candy boxes in front of Tania. The boxes are arranged in a row from left to right, numbered from 1 to n. The i-th box contains r_i candies, candies have the color c_i (the color can take one of three values βββ red, green, or blue). All candies inside a single box have the same color (and it is equal to c_i).
Initially, Tanya is next to the box number s. Tanya can move to the neighbor box (that is, with a number that differs by one) or eat candies in the current box. Tanya eats candies instantly, but the movement takes one second.
If Tanya eats candies from the box, then the box itself remains in place, but there is no more candies in it. In other words, Tanya always eats all the candies from the box and candies in the boxes are not refilled.
It is known that Tanya cannot eat candies of the same color one after another (that is, the colors of candies in two consecutive boxes from which she eats candies are always different). In addition, Tanya's appetite is constantly growing, so in each next box from which she eats candies, there should be strictly more candies than in the previous one.
Note that for the first box from which Tanya will eat candies, there are no restrictions on the color and number of candies.
Tanya wants to eat at least k candies. What is the minimum number of seconds she will need? Remember that she eats candies instantly, and time is spent only on movements.
Input
The first line contains three integers n, s and k (1 β€ n β€ 50, 1 β€ s β€ n, 1 β€ k β€ 2000) β number of the boxes, initial position of Tanya and lower bound on number of candies to eat. The following line contains n integers r_i (1 β€ r_i β€ 50) β numbers of candies in the boxes. The third line contains sequence of n letters 'R', 'G' and 'B', meaning the colors of candies in the correspondent boxes ('R' for red, 'G' for green, 'B' for blue). Recall that each box contains candies of only one color. The third line contains no spaces.
Output
Print minimal number of seconds to eat at least k candies. If solution doesn't exist, print "-1".
Examples
Input
5 3 10
1 2 3 4 5
RGBRR
Output
4
Input
2 1 15
5 6
RG
Output
-1
Note
The sequence of actions of Tanya for the first example:
* move from the box 3 to the box 2;
* eat candies from the box 2;
* move from the box 2 to the box 3;
* eat candy from the box 3;
* move from the box 3 to the box 4;
* move from the box 4 to the box 5;
* eat candies from the box 5.
Since Tanya eats candy instantly, the required time is four seconds.
### Response
```cpp
#include <bits/stdc++.h>
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
const double PI = acos(-1), EPS = 1e-7;
const int OO = 0x3f3f3f3f, N = 2e5 + 5, mod = 1e9 + 7;
using namespace std;
long long gcd(long long x, long long y) { return (!y) ? x : gcd(y, x % y); }
long long lcm(long long x, long long y) { return ((x / gcd(x, y)) * y); }
void file() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n, s, k;
vector<int> v;
string ss;
int dp[55][2005];
int solve(int idx, int kk) {
if (kk <= 0) return 0;
int &ret = dp[idx][kk];
if (~ret) return ret;
ret = OO;
for (int i = 0; i < n; i++) {
if (i != idx && v[i] > v[idx] && ss[i] != ss[idx])
ret = min(ret, solve(i, kk - v[i]) + abs(i - idx));
}
return ret;
}
int main() {
file();
cin >> n >> s >> k;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
cin >> ss;
memset(dp, -1, sizeof(dp));
int ans = OO;
for (int i = 0; i < n; i++) {
ans = min(ans, solve(i, k - v[i]) + abs(s - i - 1));
}
if (ans == OO) ans = -1;
cout << ans << '\n';
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 β€ T β€ 3 β
10^4) β the number of testcases.
Each of the next T lines contains three integers h, c and t (1 β€ c < h β€ 10^6; c β€ t β€ h) β the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer β the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class Time {
chrono::high_resolution_clock::time_point start;
public:
Time() { start = chrono::high_resolution_clock::now(); }
~Time() {
cout << "\nTime: "
<< chrono::duration_cast<chrono::duration<double>>(
chrono::high_resolution_clock::now() - start)
.count()
<< "s\n";
}
};
void fIO() {
freopen("output.txt", "w", stdout);
freopen("input.txt", "r", stdin);
}
void testCase() {
long long int h, c, t;
cin >> h >> c >> t;
if (t <= (h + c) / 2) {
cout << "2\n";
return;
}
long long int k = (h - t) / (2 * t - h - c);
if (abs(k * c + (k + 1) * h - t * (2 * k + 1)) * (2 * k + 3) <=
abs((k + 1) * c + (k + 2) * h - t * (2 * k + 3)) * (2 * k + 1)) {
cout << 2 * k + 1 << '\n';
} else {
cout << 2 * k + 3 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
cin >> t;
for (; t; --t) {
testCase();
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Zart PMP is qualified for ICPC World Finals in Harbin, China. After team excursion to Sun Island Park for snow sculpture art exposition, PMP should get back to buses before they leave. But the park is really big and he does not know how to find them.
The park has n intersections numbered 1 through n. There are m bidirectional roads that connect some pairs of these intersections. At k intersections, ICPC volunteers are helping the teams and showing them the way to their destinations. Locations of volunteers are fixed and distinct.
When PMP asks a volunteer the way to bus station, he/she can tell him the whole path. But the park is fully covered with ice and snow and everywhere looks almost the same. So PMP can only memorize at most q intersections after each question (excluding the intersection they are currently standing). He always tells volunteers about his weak memory and if there is no direct path of length (in number of roads) at most q that leads to bus station, the volunteer will guide PMP to another volunteer (who is at most q intersections away, of course). ICPC volunteers know the area very well and always tell PMP the best way. So if there exists a way to bus stations, PMP will definitely find it.
PMP's initial location is intersection s and the buses are at intersection t. There will always be a volunteer at intersection s. Your job is to find out the minimum q which guarantees that PMP can find the buses.
Input
The first line contains three space-separated integers n, m, k (2 β€ n β€ 105, 0 β€ m β€ 2Β·105, 1 β€ k β€ n) β the number of intersections, roads and volunteers, respectively. Next line contains k distinct space-separated integers between 1 and n inclusive β the numbers of cities where volunteers are located.
Next m lines describe the roads. The i-th of these lines contains two space-separated integers ui, vi (1 β€ ui, vi β€ n, ui β vi) β two intersections that i-th road connects. There will be at most one road between any two intersections.
Last line of input contains two space-separated integers s, t (1 β€ s, t β€ n, s β t) β the initial location of PMP and the location of the buses. It might not always be possible to reach t from s.
It is guaranteed that there is always a volunteer at intersection s.
Output
Print on the only line the answer to the problem β the minimum value of q which guarantees that PMP can find the buses. If PMP cannot reach the buses at all, output -1 instead.
Examples
Input
6 6 3
1 3 6
1 2
2 3
4 2
5 6
4 5
3 4
1 6
Output
3
Input
6 5 3
1 5 6
1 2
2 3
3 4
4 5
6 3
1 5
Output
3
Note
The first sample is illustrated below. Blue intersections are where volunteers are located. If PMP goes in the path of dashed line, it can reach the buses with q = 3:
<image>
In the second sample, PMP uses intersection 6 as an intermediate intersection, thus the answer is 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, t, tot;
int b[500005], e[500005], h[500005], v[500005], d[500005], p[500005], q[500005];
void Add(int x, int y) {
b[++tot] = y;
e[tot] = h[x];
h[x] = tot;
}
void Spfa(int L) {
memset(p, 0, sizeof(p));
for (int i = 0; i < n; i++) d[i] = 200000000;
d[s] = 0;
q[1] = s;
int l = 0, r = 1;
while (l < r) {
l++;
p[q[l]] = 0;
for (int go = h[q[l]]; go; go = e[go])
if (d[b[go]] > d[q[l]] + 1 && d[q[l]] + 1 <= L) {
d[b[go]] = d[q[l]] + 1;
if (v[b[go]]) d[b[go]] = 0;
if (!p[b[go]]) {
p[b[go]] = 1;
q[++r] = b[go];
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int x, y;
for (int i = 0; i < k; i++) {
scanf("%d", &x);
v[--x] = 1;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
Add(--x, --y);
Add(y, x);
}
scanf("%d%d", &s, &t);
s--;
t--;
int l = 1, r = n + 1, mid;
while (l < r) {
mid = (l + r) / 2;
Spfa(mid);
if (d[t] <= mid)
r = mid;
else
l = mid + 1;
}
if (l != n + 1)
printf("%d", l);
else
puts("-1");
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
The phantom thief "Lupin IV" is told by the beautiful "Fujiko Mine", a descendant of the Aizu clan, that the military funds left by the Aizu clan are sleeping in Aizuwakamatsu city. According to a report by Lupine's longtime companion, "Ishikawa Koshiemon," military funds are stored in several warehouses in a Senryobako box. There is no lookout in the warehouse, but it is tightly locked. However, Koshiemon says that if he uses the secret "steel slashing" technique taught by his father, he can instantly break the warehouse.
<image>
The remaining problem is the transportation of Senryobako. Lupine and Yuemon, who have no physical strength, cannot carry a Senryobako. So, I asked the reliable man "Infinity" to carry it. In order to carry out all the Senryobako, Lupine made the following plan.
First, drive Lupine to the first warehouse and drop off Koshiemon and Daisuke.
* Koshiemon breaks the warehouse
* Daisuke carries out all Senryobako
* While holding the Senryobako, head to the next warehouse decided by Lupine
Repeat this and carry out the Senryobako to the last warehouse. Meanwhile, Lupine prepares a helicopter and carries a thousand boxes with them in the last warehouse and escapes. Daisuke can carry anything heavy, but the speed of movement slows down depending on the weight of the luggage. Lupine must take this into consideration when deciding the order in which to break the warehouse.
Instead of Lupine, create a program that outputs the order of breaking the warehouse so that the travel time from breaking the first warehouse to reaching the last warehouse is minimized. However,
* All the warehouses face the street that runs straight north from Tsuruga Castle. The number of warehouses is at most 15, and the distance from the castle is at most 10,000 meters or less.
* Each Senryobako weighs 20 kilograms. The number of Senryobako in each warehouse is less than 10,000.
* To move from warehouse to warehouse, use the underground passage that is installed underground along the street.
* Daisuke travels at 2,000 / (70 + w) meters per minute to carry w kilograms of luggage.
The input data is given the number of the warehouse (integer of 100 or less), the distance from the castle (meters), and the number of Senryobako stored in the warehouse for each warehouse.
Input
The input is given in the following format:
n
s1 d1 v1
s2 d2 v2
::
sn dn vn
The number of warehouses n (n β€ 15) is given in the first line, and the information of the i-th warehouse is given in the following n lines. As information on the warehouse, the number si (1 β€ si β€ 100), the distance from the castle di (1 β€ di β€ 10000), and the number of Senryobako vi (1 β€ vi β€ 10000) are given in one line.
Output
Please output the order of breaking the warehouse on one line. Please separate the warehouse numbers with a blank.
Examples
Input
2
1 100 1
2 200 2
Output
1 2
Input
3
11 100 1
13 200 20
12 300 3
Output
11 12 13
Input
5
13 199 1
51 1000 1
37 350 10
27 300 2
99 200 1000
Output
51 37 27 13 99
### Response
```cpp
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
//const int INF = 1e8;
using namespace std;
//i???????????????????????????
bool getBit(int num, int i){
return ((num & (1 << i)) != 0);
}
//i?????????1?????????
int setBit(int num, int i){
return num | (1 << i);
}
//i?????????0?????????
int clearBit(int num, int i){
int mask = ~(1 << i);
return num & mask;
}
//i?????????v??Β§???????????????
int updateBit(int num, int i, int v){
int mask = ~(1 << i);
return (num & mask) | (v << i);
}
const int MAX_N = 16;
double dp[1 << MAX_N][MAX_N], speed[1 << MAX_N];
int pres[1 << MAX_N][MAX_N];
int main(){
int n;
cin >> n;
int id[MAX_N], dis[MAX_N], num[MAX_N];
rep(i,n){
cin >> id[i] >> dis[i] >> num[i];
}
const int N = 1 << n;
rep(s,N){
int c = 0;
rep(i,n){
pres[s][i] = -1;
dp[s][i] = 1e11;
if(getBit(s,i)) c += num[i];
}
speed[s] = 2000.0 / (70 + 20 * c);
}
rep(i,n) dp[1 << i][i] = 0;
range(s,1,N){
rep(i,n){
rep(j,n){ //i -> j????Β§????
//????????Β°????????\????????Β¨????????? || ?????????????????Β§????Β¨??????????
if((not getBit(s,i) || getBit(s,j))) continue;
double time = dp[s][i] + abs(dis[i] - dis[j]) / speed[s];
int next_s = setBit(s,j);
if(dp[next_s][j] > time){
dp[next_s][j] = time;
pres[next_s][j] = i;
}
}
}
}
int cur = 0;
range(i,1,n){
if(dp[N - 1][cur] > dp[N - 1][i]){
cur = i;
}
}
vector<int> v;
int s = N - 1;
while(cur != -1){
v.emplace_back(id[cur]);
int next = pres[s][cur];
s = clearBit(s,cur);
cur = next;
}
for(int i = v.size() - 1; i >= 0; i--){
cout << v[i] << (i == 0 ? '\n' : ' ');
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Yeah, we failed to make up a New Year legend for this problem.
A permutation of length n is an array of n integers such that every integer from 1 to n appears in it exactly once.
An element y of permutation p is reachable from element x if x = y, or p_x = y, or p_{p_x} = y, and so on.
The decomposition of a permutation p is defined as follows: firstly, we have a permutation p, all elements of which are not marked, and an empty list l. Then we do the following: while there is at least one not marked element in p, we find the leftmost such element, list all elements that are reachable from it in the order they appear in p, mark all of these elements, then cyclically shift the list of those elements so that the maximum appears at the first position, and add this list as an element of l. After all elements are marked, l is the result of this decomposition.
For example, if we want to build a decomposition of p = [5, 4, 2, 3, 1, 7, 8, 6], we do the following:
1. initially p = [5, 4, 2, 3, 1, 7, 8, 6] (bold elements are marked), l = [];
2. the leftmost unmarked element is 5; 5 and 1 are reachable from it, so the list we want to shift is [5, 1]; there is no need to shift it, since maximum is already the first element;
3. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1]];
4. the leftmost unmarked element is 4, the list of reachable elements is [4, 2, 3]; the maximum is already the first element, so there's no need to shift it;
5. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3]];
6. the leftmost unmarked element is 7, the list of reachable elements is [7, 8, 6]; we have to shift it, so it becomes [8, 6, 7];
7. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3], [8, 6, 7]];
8. all elements are marked, so [[5, 1], [4, 2, 3], [8, 6, 7]] is the result.
The New Year transformation of a permutation is defined as follows: we build the decomposition of this permutation; then we sort all lists in decomposition in ascending order of the first elements (we don't swap the elements in these lists, only the lists themselves); then we concatenate the lists into one list which becomes a new permutation. For example, the New Year transformation of p = [5, 4, 2, 3, 1, 7, 8, 6] is built as follows:
1. the decomposition is [[5, 1], [4, 2, 3], [8, 6, 7]];
2. after sorting the decomposition, it becomes [[4, 2, 3], [5, 1], [8, 6, 7]];
3. [4, 2, 3, 5, 1, 8, 6, 7] is the result of the transformation.
We call a permutation good if the result of its transformation is the same as the permutation itself. For example, [4, 3, 1, 2, 8, 5, 6, 7] is a good permutation; and [5, 4, 2, 3, 1, 7, 8, 6] is bad, since the result of transformation is [4, 2, 3, 5, 1, 8, 6, 7].
Your task is the following: given n and k, find the k-th (lexicographically) good permutation of length n.
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
Then the test cases follow. Each test case is represented by one line containing two integers n and k (1 β€ n β€ 50, 1 β€ k β€ 10^{18}).
Output
For each test case, print the answer to it as follows: if the number of good permutations of length n is less than k, print one integer -1; otherwise, print the k-th good permutation on n elements (in lexicographical order).
Example
Input
5
3 3
5 15
4 13
6 8
4 2
Output
2 1 3
3 1 2 5 4
-1
1 2 6 3 4 5
1 2 4 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 23;
int nreal;
int N;
long long K;
long long fac[MAXN];
long long dp[MAXN];
int arr[MAXN];
bool used[MAXN];
int par[MAXN];
int cfind(int x) {
if (par[x] == x) return x;
return par[x] = cfind(par[x]);
}
bool uni(int a, int b) {
a = cfind(a);
b = cfind(b);
if (a == b) return false;
par[a] = b;
return true;
}
long long cc(int ind) {
for (int i = 0; i < N; i++) used[i] = false;
for (int i = 0; i < ind; i++) {
if (used[arr[i]]) return 0;
used[arr[i]] = true;
}
int cloc = 0;
while (cloc < ind && arr[cloc] < ind) {
if (arr[cloc] < cloc) return 0;
for (int i = cloc; i <= arr[cloc]; i++)
if (arr[i] < cloc || arr[i] > arr[cloc]) return 0;
cloc = arr[cloc] + 1;
}
if (cloc == ind) return dp[N - ind];
for (int i = 0; i < N; i++) par[i] = i;
for (int i = cloc; i < ind; i++) {
if (arr[i] < cloc || arr[i] > arr[cloc]) return 0;
if (!uni(i, arr[i])) return 0;
}
int nleft = arr[cloc] - ind + 1;
return fac[max(nleft - 1, 0)] * dp[N - arr[cloc] - 1];
}
int main() {
ios_base::sync_with_stdio(0);
int T = 0;
cin >> T;
fac[0] = 1;
for (int i = 1; i < MAXN; i++) fac[i] = fac[i - 1] * i;
dp[0] = 1;
for (int i = 1; i < MAXN; i++) {
dp[i] = 0;
for (int j = 1; j <= i; j++) dp[i] += fac[max(0, j - 2)] * dp[i - j];
}
for (int t = 0; t < T; t++) {
cin >> N >> K;
nreal = N;
if (N > 22) N = 22;
bool bad = false;
for (int i = 0; i < N; i++) {
int cv = 0;
while (cv < N) {
arr[i] = cv;
long long cres = cc(i + 1);
if (K <= cres) break;
K -= cres;
cv++;
}
if (cv >= N) {
bad = true;
break;
}
}
if (bad) {
cout << "-1\n";
} else {
for (int i = 1; i <= nreal - N; i++) cout << i << " ";
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << arr[i] + (nreal - N + 1);
}
cout << "\n";
}
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You finally got a magic pot, an alchemy pot. You can create a new item by putting multiple items in the alchemy pot. Newly created items can also be placed in alchemy pots to make other items. A list of items needed to make an item will be called an alchemy recipe. The following three are examples of alchemy recipes.
1. A racket can be made with a piece of wood and thread.
2. You can make rice balls with rice and water.
3. You can play the guitar with a racket, a microphone, and rice balls.
Items can be obtained with money, but in some cases it is cheaper to make them in an alchemy pot. For example, suppose the purchase price of each item is given as follows.
Item name | Purchase price (yen)
--- | ---
Piece of wood | 3,000
Thread | 800
Rice | 36
Water | 0
Racket | 5,000
Mike | 9,800
Onigiri | 140
Guitar | 98,000
You can buy a racket for 5,000 yen, but if you buy a piece of wood and thread and alchemize it, you can get it for 3,800 yen. In addition, you can get items at a great deal by stacking alchemy. Figure 1 is a combination of the above three alchemy recipe examples. You can buy a guitar for 98,000 yen, but if you buy a piece of wood, thread, rice, water, and a microphone and alchemize it, you can get it for only 13,636 yen.
<image>
Figure 1
You wanted to get the item you wanted as cheaply as possible to make your adventure easier. Create a program that inputs a list of items, a list of alchemy recipes, and a specified item, and outputs the minimum amount required to make the specified item.
There is no limit to the quantity of each item. Items can be used in multiple recipes, but there is at most one recipe for making an item. Also, when you follow a recipe starting from an item, that item will not reappear in the recipe.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
s1 p1
s2 p2
::
sn pn
m
o1 k1 q1 q2 ... qk1
o2 k2 q1 q2 ... qk2
::
om km q1 q2 ... qkm
t
The first line gives the number of item types n (1 β€ n β€ 100) in the list. The next n lines give the name of the i-th item si (a half-width string of alphabets from 1 to 100 characters) and the price pi (0 β€ pi β€ 1000000) for purchasing it.
The next line is given the number of alchemy recipes m (0 β€ m β€ 100). The following m lines give information about the i-th recipe. Each recipe is given the item name oi, the number of items needed to make it ki (1 β€ ki β€ 100), and the ki item names q1, q2 ... qki.
The item name t specified in the last line is given.
The number of datasets does not exceed 30.
Output
Prints the minimum price on one line for each input dataset.
Example
Input
8
wood 3000
string 800
rice 36
water 0
racket 5000
microphone 9800
onigiri 140
guitar 98000
3
racket 2 wood string
onigiri 2 rice water
guitar 3 racket microphone onigiri
guitar
1
computer 300000
0
computer
0
Output
13636
300000
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#define INF (1 << 8)
using namespace std;
map<string, int> table;
map<string, vector<string> > recipe;
int rec(string item)
{
if(recipe[item].size() == 0) {
return table[item];
} else {
int ret = 0;
for(int i = 0; i < recipe[item].size(); i++) ret += rec(recipe[item][i]);
return min(ret, table[item]);
}
}
int main()
{
int N, R;
while(cin >> N && N) {
table.clear();
for(int i = 0; i < N; i++) {
int v; string name;
cin >> name >> v;
table.insert( map<string, int>::value_type(name, v));
}
cin >> R;
recipe.clear();
for(int i = 0; i < R; i++) {
int n; string name, tmp; vector<string> child;
cin >> name >> n;
for(int j = 0; j < n; j++) {
cin >> tmp;
child.push_back(tmp);
}
recipe.insert( map<string, vector<string> >::value_type(name, child));
}
string query;
cin >> query;
cout << rec(query) << endl;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
It is known that even numbers greater than or equal to 4 can be represented by the sum of two prime numbers. This is called the Goldbach's conjecture, and computer calculations have confirmed that it is correct up to a fairly large number. For example, 10 can be represented by the sum of two prime numbers, 7 + 3 and 5 + 5.
Write a program that inputs the integer n and outputs how many combinations of n are the sum of two prime numbers. However, n must be 4 or more and 50,000 or less. Also, the n entered is not always even.
Input
Given multiple datasets. Each dataset is given n on one row. When n is 0, it is the last input. The number of datasets does not exceed 10,000.
Output
For each dataset, output the number of combinations in which n is the sum of two prime numbers on one line.
Example
Input
10
11
0
Output
2
0
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 50005;
bool isP[MAXN];
int main() {
fill(isP, isP+MAXN, true);
isP[0] = isP[1] = false;
for(int i = 0; i < MAXN; ++i) {
if(!isP[i]) continue;
for(int j = i*2; j < MAXN; j += i) isP[j] = false;
}
int n;
while(cin >> n && n) {
int res = 0;
for(int i = 2; i <= n-i; ++i) {
if(isP[i] && isP[n-i]) {
++res;
}
}
cout << res << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Tonight is brain dinner night and all zombies will gather together to scarf down some delicious brains. The artful Heidi plans to crash the party, incognito, disguised as one of them. Her objective is to get away with at least one brain, so she can analyze the zombies' mindset back home and gain a strategic advantage.
They will be N guests tonight: N - 1 real zombies and a fake one, our Heidi. The living-dead love hierarchies as much as they love brains: each one has a unique rank in the range 1 to N - 1, and Heidi, who still appears slightly different from the others, is attributed the highest rank, N. Tonight there will be a chest with brains on display and every attendee sees how many there are. These will then be split among the attendees according to the following procedure:
The zombie of the highest rank makes a suggestion on who gets how many brains (every brain is an indivisible entity). A vote follows. If at least half of the attendees accept the offer, the brains are shared in the suggested way and the feast begins. But if majority is not reached, then the highest-ranked zombie is killed, and the next zombie in hierarchy has to make a suggestion. If he is killed too, then the third highest-ranked makes one, etc. (It's enough to have exactly half of the votes β in case of a tie, the vote of the highest-ranked alive zombie counts twice, and he will of course vote in favor of his own suggestion in order to stay alive.)
You should know that zombies are very greedy and sly, and they know this too β basically all zombie brains are alike. Consequently, a zombie will never accept an offer which is suboptimal for him. That is, if an offer is not strictly better than a potential later offer, he will vote against it. And make no mistake: while zombies may normally seem rather dull, tonight their intellects are perfect. Each zombie's priorities for tonight are, in descending order:
1. survive the event (they experienced death already once and know it is no fun),
2. get as many brains as possible.
Heidi goes first and must make an offer which at least half of the attendees will accept, and which allocates at least one brain for Heidi herself.
What is the smallest number of brains that have to be in the chest for this to be possible?
Input
The only line of input contains one integer: N, the number of attendees (1 β€ N β€ 109).
Output
Output one integer: the smallest number of brains in the chest which allows Heidi to take one brain home.
Examples
Input
1
Output
1
Input
4
Output
2
Note
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cout << (n + 1) / 2 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Karl is developing a key storage service. Each user has a positive integer key.
Karl knows that storing keys in plain text is bad practice. So, instead of storing a key, he decided to store a fingerprint of a key. However, using some existing fingerprint algorithm looked too boring to him, so he invented his own one.
Karl's fingerprint is calculated by the following process: divide the given integer by 2, then divide the result by 3, then divide the result by 4, and so on, until we get a result that equals zero (we are speaking about integer division each time). The fingerprint is defined as the multiset of the remainders of these divisions.
For example, this is how Karl's fingerprint algorithm is applied to the key 11: 11 divided by 2 has remainder 1 and result 5, then 5 divided by 3 has remainder 2 and result 1, and 1 divided by 4 has remainder 1 and result 0. Thus, the key 11 produces the sequence of remainders [1, 2, 1] and has the fingerprint multiset \{1, 1, 2\}.
Ksenia wants to prove that Karl's fingerprint algorithm is not very good. For example, she found that both keys 178800 and 123456 produce the fingerprint of \{0, 0, 0, 0, 2, 3, 3, 4\}. Thus, users are at risk of fingerprint collision with some commonly used and easy to guess keys like 123456.
Ksenia wants to make her words more persuasive. She wants to calculate the number of other keys that have the same fingerprint as the keys in the given list of some commonly used keys. Your task is to help her.
Input
The first line contains an integer t (1 β€ t β€ 50 000) β the number of commonly used keys to examine. Each of the next t lines contains one integer k_i (1 β€ k_i β€ 10^{18}) β the key itself.
Output
For each of the keys print one integer β the number of other keys that have the same fingerprint.
Example
Input
3
1
11
123456
Output
0
1
127
Note
The other key with the same fingerprint as 11 is 15. 15 produces a sequence of remainders [1, 1, 2]. So both numbers have the fingerprint multiset \{1, 1, 2\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long ans = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
}
return ans;
}
long long gcd(long long a, long long b) { return b > 0 ? gcd(b, a % b) : a; }
long long n, m, T;
int cnt[maxn];
long long fac[maxn];
void init() {
fac[0] = 1;
for (int i = 1; i <= 20; i++) {
fac[i] = fac[i - 1] * i;
}
}
long long cal(long long x, long long y) { return fac[x] / fac[y] / fac[x - y]; }
int main() {
init();
cin >> T;
while (T--) {
scanf("%lld", &n);
vector<int> v;
m = 1;
while (n) {
m++;
cnt[n % m]++;
n /= m;
}
long long ans = 1, sub = 1;
long long sum = 0;
for (int j = m; j >= 1; j--) {
if (!cnt[j]) continue;
int temp = min(m - j, m - 1) - sum;
ans = ans * cal(min(m - j, m - 1) - sum, cnt[j]);
if (sum + cnt[j] == min(m - j, m - 1)) sub = 0;
if (sub) {
sub = sub * cal(min(m - j, m - 1) - sum - 1, cnt[j]);
}
sum += cnt[j];
}
long long Ans = ans - sub - 1;
cout << Ans << endl;
fill(cnt, cnt + 1 + m, 0);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There are n stone quarries in Petrograd.
Each quarry owns mi dumpers (1 β€ i β€ n). It is known that the first dumper of the i-th quarry has xi stones in it, the second dumper has xi + 1 stones in it, the third has xi + 2, and the mi-th dumper (the last for the i-th quarry) has xi + mi - 1 stones in it.
Two oligarchs play a well-known game Nim. Players take turns removing stones from dumpers. On each turn, a player can select any dumper and remove any non-zero amount of stones from it. The player who cannot take a stone loses.
Your task is to find out which oligarch will win, provided that both of them play optimally. The oligarchs asked you not to reveal their names. So, let's call the one who takes the first stone Β«tolikΒ» and the other one Β«bolikΒ».
Input
The first line of the input contains one integer number n (1 β€ n β€ 105) β the amount of quarries. Then there follow n lines, each of them contains two space-separated integers xi and mi (1 β€ xi, mi β€ 1016) β the amount of stones in the first dumper of the i-th quarry and the number of dumpers at the i-th quarry.
Output
Output Β«tolikΒ» if the oligarch who takes a stone first wins, and Β«bolikΒ» otherwise.
Examples
Input
2
2 1
3 2
Output
tolik
Input
4
1 1
1 1
1 1
1 1
Output
bolik
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N;
long long solve(long long x) {
long long ans = 0;
for (; x % 4 != 3 && x; x--) {
ans ^= x;
}
return ans;
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N;
long long x, m, ans = 0;
while (N--) {
cin >> x >> m;
ans ^= solve(x - 1) ^ solve(x + m - 1);
}
cout << (ans ? 't' : 'b') << "olik\n";
}
``` |
### Prompt
Please create a solution in cpp 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 <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
while(true) {
int m, n;
vector<pair<int, int> > ms, ns;
scanf("%d", &m);
if(m == 0)
break;
ms.resize(m);
for(int i = 0; i < m; ++i)
scanf("%d%d", &ms[i].first, &ms[i].second);
scanf("%d", &n);
ns.resize(n);
for(int i = 0; i < n; ++i)
scanf("%d%d", &ns[i].first, &ns[i].second);
sort(ms.begin(), ms.end());
sort(ns.begin(), ns.end());
int dx, dy;
for(int i = 0; i < n; ++i) {
dx = ns[i].first - ms[0].first;
dy = ns[i].second - ms[0].second;
bool exist = true;
for(int j = 0; j < m; ++j) {
if(!binary_search(ns.begin(), ns.end(), make_pair(ms[j].first + dx, ms[j].second + dy)))
exist = false;
}
if(exist)
break;
}
printf("%d %d\n", dx, dy);
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 β€ n β€ 50, 1 β€ k β€ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M_LIM = 200;
const int M_MOD = 1000000007;
const double EPS = 1e-9;
int n;
long long k;
long long fib[M_LIM];
int ans[M_LIM];
int main(void) {
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i <= 52; ++i) fib[i] = fib[i - 1] + fib[i - 2];
cin >> n >> k;
--k;
for (int i = 1; i <= n; ++i) ans[i] = i;
for (int i = 1; i <= n - 1; ++i) {
if (fib[n - i + 1] <= k) {
k -= fib[n - i + 1];
swap(ans[i], ans[i + 1]);
++i;
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
The Berland capital is shaken with three bold crimes committed by the Pihsters, a notorious criminal gang.
The Berland capital's map is represented by an n Γ m rectangular table. Each cell of the table on the map represents some districts of the capital.
The capital's main detective Polycarpus took a map and marked there the districts where the first three robberies had been committed as asterisks. Deduction tells Polycarpus that the fourth robbery will be committed in such district, that all four robbed districts will form the vertices of some rectangle, parallel to the sides of the map.
Polycarpus is good at deduction but he's hopeless at math. So he asked you to find the district where the fourth robbery will be committed.
Input
The first line contains two space-separated integers n and m (2 β€ n, m β€ 100) β the number of rows and columns in the table, correspondingly.
Each of the next n lines contains m characters β the description of the capital's map. Each character can either be a "." (dot), or an "*" (asterisk). A character equals "*" if the corresponding district has been robbed. Otherwise, it equals ".".
It is guaranteed that the map has exactly three characters "*" and we can always find the fourth district that meets the problem requirements.
Output
Print two integers β the number of the row and the number of the column of the city district that is the fourth one to be robbed. The rows are numbered starting from one from top to bottom and the columns are numbered starting from one from left to right.
Examples
Input
3 2
.*
..
**
Output
1 1
Input
3 3
*.*
*..
...
Output
2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
pair<int, int> ans;
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] == '*') {
cnt++;
}
}
if (cnt == 1) {
ans.first = i;
}
}
for (int j = 0; j < m; j++) {
cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i][j] == '*') {
cnt++;
}
}
if (cnt == 1) {
ans.second = j;
}
}
cout << ans.first + 1 << " " << ans.second + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The History of Magic is perhaps the most boring subject in the Hogwarts school of Witchcraft and Wizardry. Harry Potter is usually asleep during history lessons, and his magical quill writes the lectures for him. Professor Binns, the history of magic teacher, lectures in such a boring and monotonous voice, that he has a soporific effect even on the quill. That's why the quill often makes mistakes, especially in dates.
So, at the end of the semester Professor Binns decided to collect the students' parchments with notes and check them. Ron Weasley is in a panic: Harry's notes may contain errors, but at least he has some notes, whereas Ron does not have any. Ronald also has been sleeping during the lectures and his quill had been eaten by his rat Scabbers. Hermione Granger refused to give Ron her notes, because, in her opinion, everyone should learn on their own. Therefore, Ron has no choice but to copy Harry's notes.
Due to the quill's errors Harry's dates are absolutely confused: the years of goblin rebellions and other important events for the wizarding world do not follow in order, and sometimes even dates from the future occur. Now Ron wants to change some of the digits while he copies the notes so that the dates were in the chronological (i.e. non-decreasing) order and so that the notes did not have any dates strictly later than 2011, or strictly before than 1000. To make the resulting sequence as close as possible to the one dictated by Professor Binns, Ron will change no more than one digit in each date into other digit. Help him do it.
Input
The first input line contains an integer n (1 β€ n β€ 1000). It represents the number of dates in Harry's notes. Next n lines contain the actual dates y1, y2, ..., yn, each line contains a date. Each date is a four-digit integer (1000 β€ yi β€ 9999).
Output
Print n numbers z1, z2, ..., zn (1000 β€ zi β€ 2011). They are Ron's resulting dates. Print each number on a single line. Numbers zi must form the non-decreasing sequence. Each number zi should differ from the corresponding date yi in no more than one digit. It is not allowed to change the first digit of a number into 0. If there are several possible solutions, print any of them. If there's no solution, print "No solution" (without the quotes).
Examples
Input
3
1875
1936
1721
Output
1835
1836
1921
Input
4
9999
2000
3000
3011
Output
1999
2000
2000
2011
Input
3
1999
5055
2000
Output
No solution
### Response
```cpp
#include <bits/stdc++.h>
int n, a[1005], k[5] = {0, 1, 10, 100, 1000};
bool deal(int s) {
for (int w = 4; w; w--) {
for (int j = (a[s] / k[w]) % 10; j; j--) {
int t = a[s] - k[w] * j;
if (t >= 1000 && t <= 2011 && t >= a[s - 1]) {
a[s] = t;
return 1;
}
}
}
for (int w = 1; w <= 4; w++) {
for (int j = 0; j <= 9 - (a[s] / k[w]) % 10; j++) {
int t = a[s] + k[w] * j;
if (t >= 1000 && t <= 2011 && t >= a[s - 1]) {
a[s] = t;
return 1;
}
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!deal(i)) {
printf("No solution");
return 0;
}
}
for (int i = 1; i <= n; i++) printf("%d\n", a[i]);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long val;
Node *next;
};
Node *Root = NULL;
void _addNodeEnd(long long n) {
if (Root == NULL) {
Root = new Node();
Root->next = NULL;
Root->val = n;
} else {
Node *curNode = Root;
while (curNode != NULL) curNode = curNode->next;
Node *newNode = new Node();
newNode->next = NULL;
newNode->val = n;
curNode->next = newNode;
}
}
struct Point {
long long x;
long long y;
};
bool _Asc_compare(Point lhs, Point rhs) { return lhs.x < rhs.x; }
bool _Desc_compare(Point lhs, Point rhs) { return lhs.x > rhs.x; }
long long _unique(long long x, long long y) { return (x + (y * 100000)); }
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long a, b, c, d, e, f, g, h;
long long pls = 1, mns;
string st;
char ch, dh;
char arr[1000];
int main() {
while (true) {
cin >> dh >> ch;
if (ch == '=') break;
if (ch == '+')
pls++;
else if (ch == '-')
mns++;
arr[b++] = ch;
}
cin >> a;
if (pls - a * mns > a || a * pls - mns < a) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
long long s = 0;
for (long long i = 0; i < b; i++) {
long long sign = 1;
if (i > 0 && arr[i - 1] == '-') sign = -1;
if (sign == 1) pls--;
if (sign == -1) mns--;
for (long long j = 1; j < a + 1; j++) {
if (s + j * sign + pls - a * mns <= a &&
s + j * sign + a * pls - mns >= a) {
cout << j << " " << arr[i] << " ";
s += j * sign;
break;
}
}
}
cout << abs(a - s) << " = " << a << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Pink Floyd are pulling a prank on Roger Waters. They know he doesn't like [walls](https://www.youtube.com/watch?v=YR5ApYxkU-U), he wants to be able to walk freely, so they are blocking him from exiting his room which can be seen as a grid.
Roger Waters has a square grid of size nΓ n and he wants to traverse his grid from the upper left (1,1) corner to the lower right corner (n,n). Waters can move from a square to any other square adjacent by a side, as long as he is still in the grid. Also except for the cells (1,1) and (n,n) every cell has a value 0 or 1 in it.
Before starting his traversal he will pick either a 0 or a 1 and will be able to only go to cells values in which are equal to the digit he chose. The starting and finishing cells (1,1) and (n,n) are exempt from this rule, he may go through them regardless of picked digit. Because of this the cell (1,1) takes value the letter 'S' and the cell (n,n) takes value the letter 'F'.
For example, in the first example test case, he can go from (1, 1) to (n, n) by using the zeroes on this path: (1, 1), (2, 1), (2, 2), (2, 3), (3, 3), (3, 4), (4, 4)
The rest of the band (Pink Floyd) wants Waters to not be able to do his traversal, so while he is not looking they will invert at most two cells in the grid (from 0 to 1 or vice versa). They are afraid they will not be quick enough and asked for your help in choosing the cells. Note that you cannot invert cells (1, 1) and (n, n).
We can show that there always exists a solution for the given constraints.
Also note that Waters will pick his digit of the traversal after the band has changed his grid, so he must not be able to reach (n,n) no matter what digit he picks.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 50). Description of the test cases follows.
The first line of each test case contains one integers n (3 β€ n β€ 200).
The following n lines of each test case contain the binary grid, square (1, 1) being colored in 'S' and square (n, n) being colored in 'F'.
The sum of values of n doesn't exceed 200.
Output
For each test case output on the first line an integer c (0 β€ c β€ 2) β the number of inverted cells.
In i-th of the following c lines, print the coordinates of the i-th cell you inverted. You may not invert the same cell twice. Note that you cannot invert cells (1, 1) and (n, n).
Example
Input
3
4
S010
0001
1000
111F
3
S10
101
01F
5
S0101
00000
01111
11111
0001F
Output
1
3 4
2
1 2
2 1
0
Note
For the first test case, after inverting the cell, we get the following grid:
S010
0001
1001
111F
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void testCase() {
long long n;
cin >> n;
vector<string> grid(n);
vector<pair<long long, long long>> ans;
for (string &s : grid) cin >> s;
if (grid[0][1] == grid[1][0]) {
if (grid[n - 1][n - 2] == grid[0][1]) ans.push_back({n - 1, n - 2});
if (grid[n - 2][n - 1] == grid[0][1]) ans.push_back({n - 2, n - 1});
} else if (grid[n - 1][n - 2] == grid[n - 2][n - 1]) {
if (grid[n - 1][n - 2] == grid[0][1]) ans.push_back({0, 1});
if (grid[n - 1][n - 2] == grid[1][0]) ans.push_back({1, 0});
} else {
if (grid[0][1] == '1') ans.push_back({0, 1});
if (grid[1][0] == '1') ans.push_back({1, 0});
if (grid[n - 1][n - 2] == '0') ans.push_back({n - 1, n - 2});
if (grid[n - 2][n - 1] == '0') ans.push_back({n - 2, n - 1});
}
cout << (long long)(ans.size()) << endl;
for (auto &it : ans) cout << it.first + 1 << " " << it.second + 1 << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cin.tie(nullptr);
long long t_c = 1;
cin >> t_c;
while (t_c--) testCase();
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Ayoub had an array a of integers of size n and this array had two interesting properties:
* All the integers in the array were between l and r (inclusive).
* The sum of all the elements was divisible by 3.
Unfortunately, Ayoub has lost his array, but he remembers the size of the array n and the numbers l and r, so he asked you to find the number of ways to restore the array.
Since the answer could be very large, print it modulo 10^9 + 7 (i.e. the remainder when dividing by 10^9 + 7). In case there are no satisfying arrays (Ayoub has a wrong memory), print 0.
Input
The first and only line contains three integers n, l and r (1 β€ n β€ 2 β
10^5 , 1 β€ l β€ r β€ 10^9) β the size of the lost array and the range of numbers in the array.
Output
Print the remainder when dividing by 10^9 + 7 the number of ways to restore the array.
Examples
Input
2 1 3
Output
3
Input
3 2 2
Output
1
Input
9 9 99
Output
711426616
Note
In the first example, the possible arrays are : [1,2], [2,1], [3, 3].
In the second example, the only possible array is [2, 2, 2].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int TEST = 0, CASE = 1;
long long int mod = 1000000007LL;
const long double pi = 2.0 * acos(0.0);
struct vpair {
int a, b;
vpair(int a, int b) { this->a = a, this->b = b; }
};
bool cmp(int &a, int &b) {
return a < b;
return a > b;
}
long long int n, m, a, b, c, d, k, x, y, l, r, z, ans = 0, total = 0;
long long int dp[200010][4];
long long int f(int pos, int val) {
if (pos > n) {
return val == 0;
}
if (dp[pos][val] != -1) return dp[pos][val] % mod;
long long int ret = 0;
ret += f(pos + 1, (val + 1) % 3) * a;
ret %= mod;
ret += f(pos + 1, (val + 2) % 3) * b;
ret %= mod;
ret += f(pos + 1, (val + 3) % 3) * c;
ret %= mod;
return dp[pos][val] = ret;
}
int main(void) {
cin >> n >> l >> r;
memset(dp, -1, sizeof(dp));
if (r - l < 200001) {
for (long long int i = l; i <= r; i++) {
if (i % 3 == 1)
a++;
else if (i % 3 == 2)
b++;
else
c++;
}
} else {
for (long long int i = l; i <= r; i++) {
if (i % 3 == 1) {
l = i;
break;
} else {
if (i % 3 == 0)
c++;
else if (i % 3 == 1)
a++;
else
b++;
}
}
for (long long int i = r; i >= l; --i) {
if (i % 3 == 0) {
r = i;
break;
} else {
if (i % 3 == 0)
c++;
else if (i % 3 == 1)
a++;
else
b++;
}
}
y = l - 1;
x = (r - y);
a += (x / 3);
b += (x / 3);
c += (x / 3);
}
ans = f(1, 0);
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{β_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0β€ r_i<998244353 and r_iβ
p_iβ‘ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1β€ nβ€ 50, 1β€ mβ€ 50) β the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,β¦,a_n (a_i is either 0 or 1) β if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,β¦,w_n (1β€ w_iβ€50) β the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,β¦,r_n β the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3β
1+\frac 1 3β
2=\frac4 3 .
Because 332748119β
3β‘ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100001;
const int MAXM = 3010;
const int INF = 999999;
const long long Mod = 998244353LL;
inline long long Pow(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, a = a * a % Mod)
if (b & 1) ret = ret * a % Mod;
return ret;
}
int N, M;
long long S[2], a[MAXN + 1], b[MAXN + 1];
long long g[2];
long long Iv[MAXN + 1];
long long f[MAXM + 1][MAXM + 1];
int main() {
N = read(), M = read();
for (int i = 1; i <= N; i++) a[i] = read();
for (int i = 1; i <= N; i++) b[i] = read();
for (int i = 1; i <= N; i++) S[a[i]] += b[i];
for (int i = 0; i <= 2 * MAXM; i++)
Iv[i] = Pow((S[0] + S[1] + i - MAXM + Mod) % Mod, Mod - 2);
f[0][0] = 1;
for (int i = 0; i < M; i++) {
for (int j = 0; j <= i; j++) {
if (!f[i][j]) continue;
int ad = j, dl = i - j, all = ad - dl + S[0] + S[1];
int n0 = S[0] - dl, n1 = S[1] + ad;
n0 = n0 * Iv[ad - dl + MAXM] % Mod;
n1 = n1 * Iv[ad - dl + MAXM] % Mod;
(f[i + 1][j] += f[i][j] * n0 % Mod) %= Mod;
(f[i + 1][j + 1] += f[i][j] * n1 % Mod) %= Mod;
}
}
for (int i = 0; i <= M; i++) {
g[0] = (g[0] - f[M][i] * (M - i) % Mod + Mod) % Mod;
g[1] = (g[1] + f[M][i] * i % Mod) % Mod;
}
S[0] = Pow(S[0], Mod - 2);
S[1] = Pow(S[1], Mod - 2);
for (int i = 1; i <= N; i++) {
long long ret = (b[i] + S[a[i]] * b[i] % Mod * g[a[i]] % Mod) % Mod;
cout << ret << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
A company has n employees numbered from 1 to n. Each employee either has no immediate manager or exactly one immediate manager, who is another employee with a different number. An employee A is said to be the superior of another employee B if at least one of the following is true:
* Employee A is the immediate manager of employee B
* Employee B has an immediate manager employee C such that employee A is the superior of employee C.
The company will not have a managerial cycle. That is, there will not exist an employee who is the superior of his/her own immediate manager.
Today the company is going to arrange a party. This involves dividing all n employees into several groups: every employee must belong to exactly one group. Furthermore, within any single group, there must not be two employees A and B such that A is the superior of B.
What is the minimum number of groups that must be formed?
Input
The first line contains integer n (1 β€ n β€ 2000) β the number of employees.
The next n lines contain the integers pi (1 β€ pi β€ n or pi = -1). Every pi denotes the immediate manager for the i-th employee. If pi is -1, that means that the i-th employee does not have an immediate manager.
It is guaranteed, that no employee will be the immediate manager of him/herself (pi β i). Also, there will be no managerial cycles.
Output
Print a single integer denoting the minimum number of groups that will be formed in the party.
Examples
Input
5
-1
1
2
1
-1
Output
3
Note
For the first example, three groups are sufficient, for example:
* Employee 1
* Employees 2 and 4
* Employees 3 and 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
vector<int> adj[N];
vector<int> depth(N, -1);
int n;
void dfs(int src, int s) {
if (src == s) depth[src] = 1;
for (auto x : adj[src]) {
depth[x] = 1 + depth[src];
dfs(x, s);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != -1) adj[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (depth[i] == -1) dfs(i, i);
}
cout << *max_element(depth.begin(), depth.end()) << '\n';
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Gardener Alex loves to grow trees. We remind that tree is a connected acyclic graph on n vertices.
Today he decided to grow a rooted binary tree. A binary tree is a tree where any vertex has no more than two sons. Luckily, Alex has a permutation of numbers from 1 to n which he was presented at his last birthday, so he decided to grow a tree according to this permutation. To do so he does the following process: he finds a minimum element and makes it a root of the tree. After that permutation is divided into two parts: everything that is to the left of the minimum element, and everything that is to the right. The minimum element on the left part becomes the left son of the root, and the minimum element on the right part becomes the right son of the root. After that, this process is repeated recursively on both parts.
Now Alex wants to grow a forest of trees: one tree for each cyclic shift of the permutation. He is interested in what cyclic shift gives the tree of minimum depth. Unfortunately, growing a forest is a hard and long process, but Alex wants the answer right now. Will you help him?
We remind that cyclic shift of permutation a_1, a_2, β¦, a_k, β¦, a_n for k elements to the left is the permutation a_{k + 1}, a_{k + 2}, β¦, a_n, a_1, a_2, β¦, a_k.
Input
First line contains an integer number n ~ (1 β©½ n β©½ 200 000) β length of the permutation.
Second line contains n integer numbers a_1, a_2, β¦, a_n ~ (1 β©½ a_i β©½ n), and it is guaranteed that all numbers occur exactly one time.
Output
Print two numbers separated with space: minimum possible depth of a tree and how many elements we need to shift left to achieve this depth. The number of elements should be a number from 0 to n - 1. If there are several possible answers, print any of them.
Example
Input
4
1 2 3 4
Output
3 2
Note
The following picture depicts all possible trees for sample test and cyclic shifts on which they are achieved.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int n, lg[N], rid[N], a[N], b[N], st[N << 2], tg[N << 2], f[N][25];
void build(int x, int l, int r) {
if (l == r) {
st[x] = b[l];
return;
}
int mid = l + r >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
st[x] = max(st[(x << 1)], st[(x << 1 | 1)]);
}
void pushdown(int x) {
if (!tg[x]) return;
tg[(x << 1)] += tg[x], tg[(x << 1 | 1)] += tg[x];
st[(x << 1)] += tg[x], st[(x << 1 | 1)] += tg[x];
tg[x] = 0;
}
void update(int x, int l, int r, int sl, int sr, int w) {
if (sl > sr) return;
if (sl <= l && r <= sr) {
st[x] += w, tg[x] += w;
return;
}
pushdown(x);
int mid = l + r >> 1;
if (sl <= mid) update((x << 1), l, mid, sl, sr, w);
if (sr > mid) update((x << 1 | 1), mid + 1, r, sl, sr, w);
st[x] = max(st[(x << 1)], st[(x << 1 | 1)]);
}
int qq(int x, int l, int r, int s) {
if (!s) return 0;
if (l == r) return st[x];
pushdown(x);
int mid = l + r >> 1;
return (s <= mid ? qq((x << 1), l, mid, s) : qq((x << 1 | 1), mid + 1, r, s));
}
int query(int x, int l, int r, int sl, int sr) {
if (sl <= l && r <= sr) return st[x];
pushdown(x);
int mid = l + r >> 1, ans = 0;
if (sl <= mid) ans = query((x << 1), l, mid, sl, sr);
if (sr > mid) ans = max(ans, query((x << 1 | 1), mid + 1, r, sl, sr));
return ans;
}
int qmin(int l, int r) {
int t = lg[r - l + 1];
return min(f[l][t], f[r - (1 << t) + 1][t]);
}
int findl(int l, int r, int w) {
while (l <= r) {
int mid = l + r >> 1;
if (qmin(l, mid) < w)
r = mid - 1;
else
l = mid + 1;
}
return r + 1;
}
int findr(int l, int r, int w) {
while (l <= r) {
int mid = l + r >> 1;
if (qmin(mid, r) < w)
l = mid + 1;
else
r = mid - 1;
}
return l - 1;
}
void init(int l, int r, int d) {
if (l > r) return;
int x = rid[qmin(l, r)];
b[x] = d;
init(l, x - 1, d + 1), init(x + 1, r, d + 1);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), rid[a[i]] = i, a[i + n] = a[i];
for (int i = 1; i <= (n << 1); ++i) f[i][0] = a[i];
for (int j = 1; (1 << j) <= (n << 1); ++j)
for (int i = 1; i + (1 << j - 1) <= (n << 1); ++i)
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
init(1, n, 1);
build(1, 1, (n << 1));
int del = 0, ans = query(1, 1, (n << 1), 1, n);
for (int i = 1; i < n; ++i) {
int lp = findl(i + 1, i + n - 1, a[i]), rp = findr(i + 1, i + n - 1, a[i]);
update(1, 1, (n << 1), i + 1, lp - 1, -1);
update(1, 1, (n << 1), rp + 1, i + n - 1, 1);
if (a[i] == 1)
update(1, 1, (n << 1), i + n, i + n, 1);
else
update(1, 1, (n << 1), i + n, i + n, qq(1, 1, (n << 1), rp) + 1);
int tmp = query(1, 1, (n << 1), i + 1, i + n);
if (tmp < ans) ans = tmp, del = i;
}
printf("%d %d\n", ans, del);
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Problem
Gaccho is enthusiastic about the popular game Hogemon Get. The country of Aizu, where Gaccho lives, consists of N towns, each numbered from 1 to N. In addition, there are M roads in Aizu, and all roads connect two different towns. Gaccho can move in both directions, but he can't go from one town to another through anything other than the road.
Hogemon Get allows you to get di di balls in town i. However, in order to get the ball again in a town, it must be at least 15 minutes after the last time you got the ball in that town. In addition, Gaccho can visit all towns including town 1 and town N as many times as he wants.
Gaccho must be in Town 1 first and move to Town N within R minutes. In other words, you need to be in town N after R minutes. How many balls can you get when you move?
Constraints
* 3 β€ N β€ 30
* N-1 β€ M β€ min (N Γ (N-1) / 2, 300)
* 10 β€ R β€ 1000
* 0 β€ di β€ 10
* d1 = dN = 0
* 1 β€ aj <bj β€ N
* 5 β€ cj β€ 100
* Guaranteed to travel from Town 1 to Town N within R minutes
* There can never be more than one road for a pair of two towns
Input
The input is given in the following format.
N M R
d1 d2 ... dN
a1 b1 c1
a2 b2 c2
...
aM bM cM
All inputs are integers.
The number of towns N, the number of roads M, and the time limit R are given on the first line, separated by blanks.
On the second line, the number of balls di that can be obtained by visiting the town i (i = 1,2, ..., N) is given separated by blanks.
Information aj, bj, cj of the way j (j = 1,2, ..., M) is given from the 3rd line to the M + 2nd line, separated by blanks. The jth road indicates that you can move between towns aj and bj in cj minutes.
Output
Output the maximum number of balls you can get before moving from town 1 to town N within R minutes in one line.
Examples
Input
5 4 40
0 1 1 1 0
1 2 5
2 3 5
3 4 5
4 5 5
Output
6
Input
4 3 100
0 3 1 0
1 2 5
2 3 30
3 4 5
Output
16
Input
5 4 50
0 1 1 10 0
1 2 10
2 3 10
2 4 10
4 5 10
Output
22
### Response
```cpp
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;
class Edge
{
public:
int to, cost;
Edge(int to, int cost){
this->to = to;
this->cost = cost;
}
};
bool check(int pos, int t, const vector<pair<int, int> >& v)
{
for(const auto& p : v){
if(pos == p.first && t - p.second < 15)
return false;
}
return true;
}
vector<pair<int, int> > normalize(int pos, int t, const vector<pair<int, int> >& v)
{
vector<pair<int, int> > ans;
for(const auto& p : v){
if(pos == p.first){
if(t - p.second < 15)
ans.push_back(p);
}
else{
if(t - p.second < 10)
ans.push_back(p);
}
}
sort(ans.begin(), ans.end());
return ans;
}
int main()
{
int n, m, r;
cin >> n >> m >> r;
vector<int> d(n);
for(int i=0; i<n; ++i)
cin >> d[i];
vector<vector<Edge> > edges(n);
for(int i=0; i<m; ++i){
int a, b, c;
cin >> a >> b >> c;
-- a;
-- b;
edges[a].push_back(Edge(b, c));
edges[b].push_back(Edge(a, c));
}
vector<pair<int, int> > empty;
vector<vector<map<vector<pair<int, int> >, int> > > dp(r+1, vector<map<vector<pair<int, int> >, int> >(n));
dp[0][0][empty] = 0;
for(int t=0; t<r; ++t){
for(int curr=0; curr<n; ++curr){
for(const auto& p : dp[t][curr]){
vector<pair<int, int> > v = p.first;
int ball = p.second;
if(check(curr, t, v)){
v.push_back(make_pair(curr, t));
ball += d[curr];
}
for(const Edge& e : edges[curr]){
int next = e.to;
int t2 = t + e.cost;
if(t2 <= r){
auto v2 = normalize(next, t2, v);
dp[t2][next][v2] = max(dp[t2][next][v2], ball);
}
}
int t2;
for(unsigned i=0; i<v.size(); ++i){
if(v[i].first == curr)
t2 = v[i].second + 15;
}
if(t2 <= r){
auto v2 = normalize(curr, t2, v);
dp[t2][curr][v2] = max(dp[t2][curr][v2], ball);
}
}
}
}
int ans = 0;
for(int t=0; t<=r; ++t){
for(const auto& p : dp[t][n-1]){
ans = max(ans, p.second);
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
We have a board with a 2 \times N grid. Snuke covered the board with N dominoes without overlaps. Here, a domino can cover a 1 \times 2 or 2 \times 1 square.
Then, Snuke decided to paint these dominoes using three colors: red, cyan and green. Two dominoes that are adjacent by side should be painted by different colors. Here, it is not always necessary to use all three colors.
Find the number of such ways to paint the dominoes, modulo 1000000007.
The arrangement of the dominoes is given to you as two strings S_1 and S_2 in the following manner:
* Each domino is represented by a different English letter (lowercase or uppercase).
* The j-th character in S_i represents the domino that occupies the square at the i-th row from the top and j-th column from the left.
Constraints
* 1 \leq N \leq 52
* |S_1| = |S_2| = N
* S_1 and S_2 consist of lowercase and uppercase English letters.
* S_1 and S_2 represent a valid arrangement of dominoes.
Input
Input is given from Standard Input in the following format:
N
S_1
S_2
Output
Print the number of such ways to paint the dominoes, modulo 1000000007.
Examples
Input
3
aab
ccb
Output
6
Input
1
Z
Z
Output
3
Input
52
RvvttdWIyyPPQFFZZssffEEkkaSSDKqcibbeYrhAljCCGGJppHHn
RLLwwdWIxxNNQUUXXVVMMooBBaggDKqcimmeYrhAljOOTTJuuzzn
Output
958681902
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
long long m,p=1000000007;
string s,t;
bool q;
cin>>n>>s>>t;
for(int i=0;i<n;i++){
if(s[i]==t[i]){
if(i==0){
m=3;
}else if(q){
m=(m*2)%p;
}
q=true;
}else{
if(i==0){
m=6;
}else if(q){
m=(m*2)%p;
}else{
m=(m*3)%p;
}
q=false;
i++;
}
}
cout<<m<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Polycarp loves ciphers. He has invented his own cipher called repeating.
Repeating cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{m} (1 β€ m β€ 10), Polycarp uses the following algorithm:
* he writes down s_1 ones,
* he writes down s_2 twice,
* he writes down s_3 three times,
* ...
* he writes down s_m m times.
For example, if s="bab" the process is: "b" β "baa" β "baabbb". So the encrypted s="bab" is "baabbb".
Given string t β the result of encryption of some string s. Your task is to decrypt it, i. e. find the string s.
Input
The first line contains integer n (1 β€ n β€ 55) β the length of the encrypted string. The second line of the input contains t β the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is exactly n.
It is guaranteed that the answer to the test exists.
Output
Print such string s that after encryption it equals t.
Examples
Input
6
baabbb
Output
bab
Input
10
ooopppssss
Output
oops
Input
1
z
Output
z
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
while (cin >> n) {
string s;
cin >> s;
vector<string> v;
int ar[11] = {0, 1, 3, 6, 10, 15, 21, 28, 36, 45};
long long int j = 0;
for (long long int i = 0; i < s.size(); i++) {
if (i == ar[j]) {
cout << s[i];
j++;
}
}
cout << endl;
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Omkar has a pie tray with k (2 β€ k β€ 20) spots. Each spot in the tray contains either a chocolate pie or a pumpkin pie. However, Omkar does not like the way that the pies are currently arranged, and has another ideal arrangement that he would prefer instead.
To assist Omkar, n elves have gathered in a line to swap the pies in Omkar's tray. The j-th elf from the left is able to swap the pies at positions a_j and b_j in the tray.
In order to get as close to his ideal arrangement as possible, Omkar may choose a contiguous subsegment of the elves and then pass his pie tray through the subsegment starting from the left. However, since the elves have gone to so much effort to gather in a line, they request that Omkar's chosen segment contain at least m (1 β€ m β€ n) elves.
Formally, Omkar may choose two integers l and r satisfying 1 β€ l β€ r β€ n and r - l + 1 β₯ m so that first the pies in positions a_l and b_l will be swapped, then the pies in positions a_{l + 1} and b_{l + 1} will be swapped, etc. until finally the pies in positions a_r and b_r are swapped.
Help Omkar choose a segment of elves such that the amount of positions in Omkar's final arrangement that contain the same type of pie as in his ideal arrangement is the maximum possible. Note that since Omkar has a big imagination, it might be that the amounts of each type of pie in his original arrangement and in his ideal arrangement do not match.
Input
The first line contains three integers n, m, and k (1 β€ m β€ n β€ 10^6 and 2 β€ k β€ 20) β the number of elves, the minimum subsegment length, and the number of spots in Omkar's tray respectively.
The second and third lines each contain a string of length k consisting of 0s and 1s that represent initial arrangement of pies and ideal arrangement of pies; the j-th character in each string is equal to 0 if the j-th spot in the arrangement contains a chocolate pie and is equal to 1 if the j-th spot in the arrangement contains a pumpkin pie. It is not guaranteed that the two strings have the same amount of 0s or the same amount of 1s.
n lines follow. The j-th of these lines contains two integers a_j and b_j (1 β€ a_j, b_j β€ k, a_j β b_j) which indicate that the j-th elf from the left can swap the pies at positions a_j and b_j in the tray.
Output
Output two lines.
The first line should contain a single integer s (0 β€ s β€ k) equal to the amount of positions that contain the same type of pie in Omkar's final arrangement and in Omkar's ideal arrangement; s should be the maximum possible.
The second line should contain two integers l and r satisfying 1 β€ l β€ r β€ n and r - l + 1 β₯ m, indicating that Omkar should pass his tray through the subsegment l, l + 1, ..., r to achieve a final arrangement with s positions having the same type of pie as his ideal arrangement.
If there are multiple answers you may output any of them.
Examples
Input
4 2 5
11000
00011
1 3
3 5
4 2
3 4
Output
5
1 3
Input
4 3 5
11000
00011
1 3
1 5
2 4
1 5
Output
3
1 4
Note
In the first test case, the swaps will go like this:
* Swap 1 and 3: 11000 becomes 01100
* Swap 3 and 5: 01100 becomes 01001
* Swap 4 and 2: 01001 becomes 00011
The final arrangement is the same as the ideal arrangement 00011, so there are 5 positions with the same type of pie, which is optimal.
In the second test case, the swaps will go like this:
* Swap 1 and 3: 11000 becomes 01100
* Swap 1 and 5: 01100 becomes 01100
* Swap 4 and 2: 01100 becomes 00110
* Swap 1 and 5: 00110 becomes 00110
The final arrangement has 3 positions with the same type of pie as the ideal arrangement 00011, those being positions 1, 2, and 4. In this case the subsegment of elves (l, r) = (2, 3) is more optimal, but that subsegment is only length 2 and therefore does not satisfy the constraint that the subsegment be of length at least m = 3.
### Response
```cpp
#include <bits/stdc++.h>
template <class T>
void read(T &x) {
x = 0;
char f = 0, c = getc(stdin);
while (c < '0' || c > '9') f ^= (c == '-'), c = getc(stdin);
while (c >= '0' && c <= '9') x = x * 10 + (c & 15), c = getc(stdin);
f && (x = -x);
}
int Max(int a, int b) { return a > b ? a : b; }
int Min(int a, int b) { return a < b ? a : b; }
int Abs(int a) { return a < 0 ? -a : a; }
long long sqr(int a) { return (long long)a * a; }
int qpow(int a, int b) {
if (b < 0) return 0;
int ans = 1;
while (b) {
if (b & 1) ans = 1ll * a * ans % 1000000007;
a = 1ll * a * a % 1000000007;
b >>= 1;
}
return ans;
}
int T = 1;
int n, k;
int m, x, y;
int s, t;
int mx[1050010], mn[1050010];
int cnt[1050010], id[50];
int main() {
while (T--) {
read(n), read(m), read(k);
for (int i = 0; i < 1 << k; ++i)
mx[i] = -1, mn[i] = 2147483647, cnt[i] = cnt[i >> 1] + (i & 1);
for (int i = 0; i < k; ++i) scanf("%1d", &x), s |= x << i;
for (int i = 0; i < k; ++i) id[i] = i, scanf("%1d", &x), t |= x << i;
mx[t] = mn[s] = 0;
for (int i = 1; i <= n; ++i) {
read(x), read(y);
id[x - 1] ^= id[y - 1] ^= id[x - 1] ^= id[y - 1];
int ss = 0, tt = 0;
for (int j = 0; j < k; ++j)
ss |= !!(s & (1 << j)) << id[j], tt |= !!(t & (1 << j)) << id[j];
mx[tt] = Max(mx[tt], i);
mn[ss] = Min(mn[ss], i);
}
for (int i = 0; i < k; ++i)
for (int j = 1 << i; j < 1 << k; (++j) |= 1 << i)
mx[j ^ (1 << i)] = Max(mx[j ^ (1 << i)], mx[j]),
mn[j ^ (1 << i)] = Min(mn[j ^ (1 << i)], mn[j]);
int ans = 0;
for (int i = 0; i < 1 << k; ++i)
(mx[i] - mn[i] >= m) && (cnt[i] > cnt[ans]) && (ans = i);
printf("%d\n", k - cnt[s] - cnt[t] + cnt[ans] * 2);
printf("%d %d\n", mn[ans] + 1, mx[ans]);
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
So we got bored and decided to take our own guess at how would "Inception" production go if the budget for the film had been terribly low.
The first scene we remembered was the one that features the whole city bending onto itself:
<image>
It feels like it will require high CGI expenses, doesn't it? Luckily, we came up with a similar-looking scene which was a tiny bit cheaper to make.
Firstly, forget about 3D, that's hard and expensive! The city is now represented as a number line (infinite to make it easier, of course).
Secondly, the city doesn't have to look natural at all. There are n buildings on the line. Each building is a square 1 Γ 1. Buildings are numbered from 1 to n in ascending order of their positions. Lower corners of building i are at integer points a_i and a_i + 1 of the number line. Also the distance between any two neighbouring buildings i and i + 1 doesn't exceed d (really, this condition is here just to make the city look not that sparse). Distance between some neighbouring buildings i and i + 1 is calculated from the lower right corner of building i to the lower left corner of building i + 1.
Finally, curvature of the bend is also really hard to simulate! Let the bend at some integer coordinate x be performed with the following algorithm. Take the ray from x to +β and all the buildings which are on this ray and start turning the ray and the buildings counter-clockwise around point x. At some angle some building will touch either another building or a part of the line. You have to stop bending there (implementing buildings crushing is also not worth its money).
Let's call the angle between two rays in the final state the terminal angle Ξ±_x.
The only thing left is to decide what integer point x is the best to start bending around. Fortunately, we've already chosen m candidates to perform the bending.
So, can you please help us to calculate terminal angle Ξ±_x for each bend x from our list of candidates?
Input
The first line contains two integer numbers n and d (1 β€ n β€ 2 β
10^5, 0 β€ d β€ 7000) β the number of buildings and the maximum distance between any pair of neighbouring buildings, respectively.
The second line contains n integers a_1, a_2, ..., a_n (a_1 = 0, 0 < a_{i + 1} - a_i β€ d + 1) β coordinates of left corners of corresponding buildings in ascending order.
The third line contains single integer m (1 β€ m β€ 2 β
10^5) β the number of candidates.
The fourth line contains m integers x_1, x_2, ..., x_m (0 β€ x_i β€ a_n + 1, x_i < x_{i + 1}) β the coordinates of bends you need to calculate terminal angles for in ascending order.
Output
Print m numbers. For each bend x_i print terminal angle Ξ±_{x_i} (in radians).
Your answer is considered correct if its absolute error does not exceed 10^{-9}.
Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if |a - b| β€ 10^{-9}.
Examples
Input
3 5
0 5 7
9
0 1 2 3 4 5 6 7 8
Output
1.570796326794897
1.570796326794897
0.785398163397448
0.927295218001612
0.785398163397448
1.570796326794897
1.570796326794897
1.570796326794897
1.570796326794897
Input
2 7
0 4
3
1 3 4
Output
1.570796326794897
0.927295218001612
1.570796326794897
Input
5 0
0 1 2 3 4
6
0 1 2 3 4 5
Output
1.570796326794897
3.141592653589793
3.141592653589793
3.141592653589793
3.141592653589793
1.570796326794897
Note
Here you can see the picture of the city for the first example and the bend at position 2 for it. The angle you need to measure is marked blue. You can see that it's equal to \frac Ο 4.
You can see that no pair of neighbouring buildings have distance more than 4 between them. d = 4 would also suffice for that test.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
int num[200010];
int main() {
int n, m, d;
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
scanf("%d", &m);
int u = 0;
while (m--) {
int x;
scanf("%d", &x);
for (; u < n && num[u + 1] < x; u++)
;
if (num[u] == x - 1 && num[u + 1] == x) {
printf("%.11lf\n", pi);
continue;
} else if (num[u] == x - 1 || num[u + 1] == x) {
printf("%.11lf\n", pi / 2);
continue;
}
int l = u;
double res = max(u < n ? atan2(1, num[u + 1] - x) : 0,
u > 0 ? atan2(1, x - num[u] - 1) : 0);
int d = min(num[u + 1] - x, x - num[u] - 1);
int r = u + 1;
while (l >= 1 && r <= n && num[r] - num[l] <= (d + 5) * 4) {
int dis1 = num[r] - x, dis2 = x - num[l] - 1;
if (abs(dis1 - dis2) <= 1) {
res = max(res, atan2(1.0, max(dis1, dis2)) * 2);
break;
}
if (dis1 < dis2)
r++;
else
l--;
}
printf("%.10f\n", res);
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Andrew was very excited to participate in Olympiad of Metropolises. Days flew by quickly, and Andrew is already at the airport, ready to go home. He has n rubles left, and would like to exchange them to euro and dollar bills. Andrew can mix dollar bills and euro bills in whatever way he wants. The price of one dollar is d rubles, and one euro costs e rubles.
Recall that there exist the following dollar bills: 1, 2, 5, 10, 20, 50, 100, and the following euro bills β 5, 10, 20, 50, 100, 200 (note that, in this problem we do not consider the 500 euro bill, it is hard to find such bills in the currency exchange points). Andrew can buy any combination of bills, and his goal is to minimize the total number of rubles he will have after the exchange.
Help him β write a program that given integers n, e and d, finds the minimum number of rubles Andrew can get after buying dollar and euro bills.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^8) β the initial sum in rubles Andrew has.
The second line of the input contains one integer d (30 β€ d β€ 100) β the price of one dollar in rubles.
The third line of the input contains integer e (30 β€ e β€ 100) β the price of one euro in rubles.
Output
Output one integer β the minimum number of rubles Andrew can have after buying dollar and euro bills optimally.
Examples
Input
100
60
70
Output
40
Input
410
55
70
Output
5
Input
600
60
70
Output
0
Note
In the first example, we can buy just 1 dollar because there is no 1 euro bill.
In the second example, optimal exchange is to buy 5 euro and 1 dollar.
In the third example, optimal exchange is to buy 10 dollars in one bill.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
const long long N = 1e6 + 5;
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long C(long long n, long long r) {
if (r > n - r) r = n - r;
long long ans = 1;
for (long long i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
long long mod = 1e9 + 7;
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % mod;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % mod;
res %= mod;
}
return res;
}
long long n, d, e, x, y, ans = 1e18;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> d >> e;
y = (n / e) / 5, y *= 5;
for (long long i = y; i >= 0; i -= 5)
ans = (ans < (n - e * i) % d ? ans : (n - e * i) % d);
cout << ans;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are N integers a_1, a_2, ..., a_N not less than 1. The values of a_1, a_2, ..., a_N are not known, but it is known that a_1 \times a_2 \times ... \times a_N = P.
Find the maximum possible greatest common divisor of a_1, a_2, ..., a_N.
Constraints
* 1 \leq N \leq 10^{12}
* 1 \leq P \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N P
Output
Print the answer.
Examples
Input
3 24
Output
2
Input
5 1
Output
1
Input
1 111
Output
111
Input
4 972439611840
Output
206
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
ll n,p;
cin >> n >> p;
map <ll,ll> m;
for(ll i = 2 ; i*i <= p ; i++)
{
while(p % i == 0)
{
m[i]++;
p /= i;
}
}
if(p > 1)
m[p]++;
ll ans = 1;
for(auto i = m.begin() ; i != m.end() ; i++)
{
ans *= pow(i->first,(i->second/n));
}
cout << ans;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The warehouse in your shop has n shoe pairs. Each pair is characterized by two integers: its price ci and its size si. We know that on this very day all numbers si are different, that is, there is no more than one pair of each size.
The shop has m customers who came at the same time. The customer number i has di money and the size of his feet equals li. The customer number i can buy the pair number j, if cj β€ di, and also if li = sj or li = sj - 1; that is, it is necessary that he has enough money to pay for the shoes. It is also necessary that the size of his feet equals to or is less by 1 than the size of the shoes he chooses.
Your task is to sell some customers pairs of shoes (a pair per person) so as to maximize the sum of the sold pairs cj that is, the profit. It is guaranteed that each customer buys no more than one pair and each pair will be bought by no more than one customer.
Input
The first input line contains the only integer n (1 β€ n β€ 105) β the number of shoe pairs in the warehouse. Then n lines contain the descriptions of pairs of shoes as two integers ci and si (1 β€ ci, si β€ 109), the numbers are separated by a space. It is guaranteed that all numbers si are different.
The next line contains an integer m (1 β€ m β€ 105) β the number of customers in the shop. Next m lines contain the customers' descriptions as two integers di and li (1 β€ di, li β€ 109), the numbers are separated by a space.
Output
In the first line print the only integer β the maximum profit you can get from selling shoes. In the second line print an integer k β the number of shoe pairs you will sell. In the following k lines print the descriptions of the sold pairs β two space-separated integers where the first number is the customer's number and the second number is the number of the shoes the customer will buy.
You can print pairs of numbers "the customer's number and the shoes' number" in any order, the customers and the pairs of shoes are numbered starting from 1 in the order in which they are given in the input. If there are several optimal answers, you are allowed to print any of them.
Please do not use the %lld specificator to read or write 64-bit numbers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specificator instead.
Examples
Input
3
10 1
30 2
20 3
2
20 1
20 2
Output
30
2
2 3
1 1
Input
3
10 4
20 5
30 6
2
70 4
50 5
Output
50
2
2 3
1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct data {
int c, sz, id;
data(){};
data(int _c, int _sz, int _id) {
c = _c;
sz = _sz;
id = _id;
}
} a[N], b[N];
int n, m, id = 0;
int dd[N], X[N];
long long cost[N];
vector<int> G[N];
void opf() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void inp() {
cin >> n;
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) {
cin >> a[i].c >> a[i].sz;
a[i].id = i;
cost[i] = a[i].c;
}
cin >> m;
for (int(i) = (int)(1); (i) <= (int)(m); ++(i)) {
cin >> b[i].c >> b[i].sz;
b[i].id = i;
}
}
inline bool cmpS(const data& a, const data& b) { return a.sz < b.sz; }
inline bool cmpC(const data& a, const data& b) { return a.c > b.c; }
bool dfs(int u) {
if (dd[u] == id) return 0;
dd[u] = id;
for (int v : G[u])
if (X[v] == -1 || dfs(X[v])) {
X[v] = u;
return 1;
}
return 0;
}
void solve() {
sort(a + 1, a + n + 1, cmpS);
for (int(i) = (int)(1); (i) <= (int)(m); ++(i)) {
int cur =
(int)(lower_bound(a + 1, a + n + 1, data(-1, b[i].sz, -1), cmpS) - a);
while (a[cur].sz == b[i].sz || a[cur].sz == b[i].sz + 1) {
if (a[cur].c <= b[i].c) G[a[cur].id].push_back(b[i].id);
++cur;
}
}
sort(a + 1, a + n + 1, cmpC);
memset((X), (-1), sizeof(X));
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) ++id, dfs(a[i].id);
long long res = 0ll;
vector<pair<int, int> > ans;
for (int(i) = (int)(1); (i) <= (int)(m); ++(i)) {
if (X[i] == -1) continue;
res += cost[X[i]];
ans.push_back(make_pair(i, X[i]));
}
cout << res << '\n' << ans.size() << '\n';
for (int(i) = (int)(0); (i) <= (int)(ans.size() - 1); ++(i))
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
int main() {
opf();
inp();
solve();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
<image>
My grandmother uses a balance. The balance will balance if you place the same size on both of the two dishes, otherwise it will tilt to the heavier side. The weights of the 10 weights are 1g, 2g, 4g, 8g, 16g, 32g, 64g, 128g, 256g, 512g in order of lightness.
My grandmother says, "Weigh up to about 1 kg in grams." "Then, try to weigh the juice here," and my grandmother put the juice on the left plate and the 8g, 64g, and 128g weights on the right plate to balance. Then he answered, "The total weight is 200g, so the juice is 200g. How is it correct?"
Since the weight of the item to be placed on the left plate is given, create a program that outputs the weight to be placed on the right plate in order of lightness when balancing with the item of the weight given by the balance. However, the weight of the item to be weighed shall be less than or equal to the total weight of all weights (= 1023g).
Hint
The weight of the weight is 2 to the nth power (n = 0, 1, .... 9) g.
Input
Given multiple datasets. For each dataset, the weight of the item to be placed on the left plate is given in one line. Please process until the end of the input. The number of datasets does not exceed 50.
Output
For each data set, separate the weights (ascending order) to be placed on the right plate with one blank and output them on one line.
Example
Input
5
7
127
Output
1 4
1 2 4
1 2 4 8 16 32 64
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main(){
int n,h,c;
while(cin>>n){
h=1;
c=0;
for(int i=0;i<10;i++){
if(n%(h*2)!=0){
n-=h;
if(c==0)
cout<<h;
else
cout<<" "<<h;
c=1;
}
h*=2;
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
One day Sasha visited the farmer 2D and his famous magnetic farm. On this farm, the crop grows due to the influence of a special magnetic field. Maintaining of the magnetic field is provided by n machines, and the power of the i-th machine is a_i.
This year 2D decided to cultivate a new culture, but what exactly he didn't say. For the successful growth of the new culture, it is necessary to slightly change the powers of the machines. 2D can at most once choose an arbitrary integer x, then choose one machine and reduce the power of its machine by x times, and at the same time increase the power of one another machine by x times (powers of all the machines must stay positive integers). Note that he may not do that if he wants. More formally, 2D can choose two such indices i and j, and one integer x such that x is a divisor of a_i, and change powers as following: a_i = (a_i)/(x), a_j = a_j β
x
Sasha is very curious, that's why he wants to calculate the minimum total power the farmer can reach. There are too many machines, and Sasha can't cope with computations, help him!
Input
The first line contains one integer n (2 β€ n β€ 5 β
10^4) β the number of machines.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 100) β the powers of the machines.
Output
Print one integer β minimum total power.
Examples
Input
5
1 2 3 4 5
Output
14
Input
4
4 2 4 4
Output
14
Input
5
2 4 2 3 7
Output
18
Note
In the first example, the farmer can reduce the power of the 4-th machine by 2 times, and increase the power of the 1-st machine by 2 times, then the powers will be: [2, 2, 3, 2, 5].
In the second example, the farmer can reduce the power of the 3-rd machine by 2 times, and increase the power of the 2-nd machine by 2 times. At the same time, the farmer can leave is be as it is and the total power won't change.
In the third example, it is optimal to leave it be as it is.
### Response
```cpp
#include <bits/stdc++.h>
const int maxn = 1e6 + 1;
const long long mod = 1e9 + 7;
const int base = 1331;
using namespace std;
int n;
int a[maxn];
int ans = 0;
vector<int> divi[200];
void read(void) {
for (int i = 1; i < 101; i++)
for (int j = i; j < 101; j += i) divi[j].push_back(i);
cin >> n;
for (int i = 1; i <= (int)(n); ++i) cin >> a[i], ans += a[i];
int res = ans;
sort(a + 1, a + 1 + n);
for (int i = (int)(2); i <= (int)(n); ++i) {
for (int x : divi[a[i]]) {
res = min(res, ans - a[1] - a[i] + x * a[1] + a[i] / x);
}
}
cout << res;
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Given an integer x. Your task is to find out how many positive integers n (1 β€ n β€ x) satisfy $$$n β
a^n β‘ b (mod\;p), where a, b, p$$$ are all known constants.
Input
The only line contains four integers a,b,p,x (2 β€ p β€ 10^6+3, 1 β€ a,b < p, 1 β€ x β€ 10^{12}). It is guaranteed that p is a prime.
Output
Print a single integer: the number of possible answers n.
Examples
Input
2 3 5 8
Output
2
Input
4 6 7 13
Output
1
Input
233 233 10007 1
Output
1
Note
In the first sample, we can see that n=2 and n=8 are possible answers.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a, b, p, x;
long long qpow(long long t, long long n) {
long long ans = 1;
t %= p;
while (n >= 1) {
if (n & 1) ans = ans * t % p;
t = t * t % p;
n >>= 1;
}
return ans;
}
int main() {
scanf("%lld%lld%lld%lld", &a, &b, &p, &x);
long long cnt = 0;
long long P = (p - 1) * p;
for (long long j = 1; j < p; ++j) {
long long k = b % p * qpow(qpow(a, j), p - 2);
long long i = (j - k % p + p) % p;
long long now = (i * (p - 1) + j) % P;
if (now == 0) now = P;
cnt += x / P + ((x % P) >= now);
}
printf("%lld\n", cnt);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Cosider a sequence, consisting of n integers: a1, a2, ..., an. Jeff can perform the following operation on sequence a:
* take three integers v, t, k (1 β€ v, t β€ n; 0 β€ k; v + tk β€ n), such that av = av + t, av + t = av + 2t, ..., av + t(k - 1) = av + tk;
* remove elements av, av + t, ..., av + tΒ·k from the sequence a, the remaining elements should be reindexed a1, a2, ..., an - k - 1.
* permute in some order the remaining elements of sequence a.
A beauty of a sequence a is the minimum number of operations that is needed to delete all elements from sequence a.
Jeff's written down a sequence of m integers b1, b2, ..., bm. Now he wants to ask q questions. Each question can be described with two integers li, ri. The answer to the question is the beauty of sequence bli, bli + 1, ..., bri. You are given the sequence b and all questions. Help Jeff, answer all his questions.
Input
The first line contains integer m (1 β€ m β€ 105). The next line contains m integers b1, b2, ..., bm (1 β€ bi β€ 105).
The third line contains integer q (1 β€ q β€ 105) β the number of questions. The next q lines contain pairs of integers, i-th of them contains a pair of integers li, ri (1 β€ li β€ ri β€ m) β the description of i-th question.
Output
In q lines print the answers to Jeff's queries. Print the answers according to the order of questions in input.
Examples
Input
5
2 2 1 1 2
5
1 5
1 1
2 2
1 3
2 3
Output
2
1
1
2
2
Input
10
2 1 3 3 3 3 1 3 1 1
10
4 8
2 10
1 10
4 4
1 3
2 4
6 7
1 9
2 5
1 1
Output
2
3
3
1
3
2
2
3
2
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct number {
deque<int> q;
map<int, int> db;
int curr = 0;
};
struct pii {
int x, y, id;
};
const int S = 300;
bool sortFunc(pii a, pii b) {
if (a.x / S == b.x / S) return ((a.x / S) & 1 ? a.y > b.y : a.y < b.y);
return a.x < b.x;
}
vector<number> t(1e5 + 1);
void inc(map<int, int>& db, int num, int& curr) {
if (db.count(num) == 0) db[num] == 0;
if (++db[num] == 1) curr++;
}
void dec(map<int, int>& db, int num, int& curr) {
if (--db[num] == 0) curr--;
}
int curr = 0, nums = 0;
void add(int poz, int num) {
if (t[num].curr <= 1 && t[num].q.size() > 0) curr--;
if (t[num].q.empty())
t[num].q.push_front(poz);
else if (poz < t[num].q.front()) {
inc(t[num].db, t[num].q.front() - poz, t[num].curr);
t[num].q.push_front(poz);
} else {
inc(t[num].db, poz - t[num].q.back(), t[num].curr);
t[num].q.push_back(poz);
}
if (t[num].curr <= 1) curr++;
if (t[num].q.size() == 1) nums++;
}
void remove(int poz, int num) {
if (t[num].curr <= 1) curr--;
if (t[num].q.size() == 1)
t[num].q.pop_front();
else if (poz == t[num].q.front()) {
t[num].q.pop_front();
dec(t[num].db, t[num].q.front() - poz, t[num].curr);
} else {
t[num].q.pop_back();
dec(t[num].db, poz - t[num].q.back(), t[num].curr);
}
if (t[num].curr <= 1 && t[num].q.size() > 0) curr++;
if (t[num].q.size() == 0) nums--;
}
int main() {
int test;
int n;
cin >> n;
vector<int> sor(n);
for (int& a : sor) cin >> a;
int q;
cin >> q;
vector<pii> v(q);
for (int i = 0; i < q; i++)
cin >> v[i].x >> v[i].y, v[i].id = i, v[i].x--, v[i].y--;
sort(v.begin(), v.end(), sortFunc);
int l = 0, r = -1;
vector<int> ans(q);
for (pii& a : v) {
while (a.x < l) add(l - 1, sor[l - 1]), l--;
while (r < a.y) add(r + 1, sor[r + 1]), r++;
while (l < a.x) remove(l, sor[l]), l++;
while (a.y < r) remove(r, sor[r]), r--;
ans[a.id] = (curr > 0 ? nums : nums + 1);
}
for (int& a : ans) cout << a << "\n";
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Do the following for a four-digit number N consisting of numbers 0-9.
1. Let L be the number obtained as a result of arranging the numerical values ββof each of the N digits in descending order.
2. Let S be the number obtained as a result of arranging the numerical values ββof each of the N digits in ascending order.
3. Let the difference L-S be the new N (end of one operation)
4. Repeat from 1. for the new N
At this time, it is known that any four-digit number will eventually become 6174, unless all digits are the same number (0000, 1111, etc.). For example, when N = 2012
First time (N = 2012): L = 2210, S = 0122, L-S = 2088
Second time (N = 2088): L = 8820, S = 0288, L-S = 8532
Third time (N = 8532): L = 8532, S = 2358, L-S = 6174
And reach 6174 in 3 operations.
Write a program that calculates how many operations will reach 6174 given a four-digit number consisting of the numbers 0-9.
input
The input consists of multiple datasets. The end of the input is indicated by 0000 on one line. Each dataset is given in the following format:
N
The dataset is one line and N (1 β€ N β€ 9999) indicates a four-digit number. If N <1000, the upper digit is padded with zeros.
The number of datasets does not exceed 10000.
output
The number of operations to reach 6174 for each data set is output on one line. However, if a number with all the same digits is given as input, NA is output.
Example
Input
6174
2012
3333
0000
Output
0
3
NA
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string n;
cin >>n;
while(n!="0000"){
int a[4];
for(int i=0;i<4;i++){
stringstream ss;
ss <<n[i];
ss >>a[i];
}
if((a[0]==a[1])&&(a[1]==a[2])&&(a[2]==a[3])){
cout <<"NA"<<endl;
cin >>n;
continue;
}
for(int i=0;i<100;i++){
if(n=="6174"){
cout <<i <<endl;
break;
}
sort(a,a+4);
int l=a[0]+a[1]*10+a[2]*100+a[3]*1000;
int s=a[3]+a[2]*10+a[1]*100+a[0]*1000;
int n1=l-s;
stringstream ss;
ss << n1;
ss >> n;
if(n1<10){
n.resize(4);
n[3]=0;
n[2]=0;
n[1]=0;
}else if(n1<100){
n.resize(4);
n[3]=0;
n[2]=0;
}else if(n1<1000){
n.resize(4);
n[3]=0;
}
for(int j=0;j<4;j++){
stringstream ss1;
ss1 <<n[j];
ss1 >>a[j];
}
}
cin >>n;
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given a set of n elements indexed from 1 to n. The weight of i-th element is wi. The weight of some subset of a given set is denoted as <image>. The weight of some partition R of a given set into k subsets is <image> (recall that a partition of a given set is a set of its subsets such that every element of the given set belongs to exactly one subset in partition).
Calculate the sum of weights of all partitions of a given set into exactly k non-empty subsets, and print it modulo 109 + 7. Two partitions are considered different iff there exist two elements x and y such that they belong to the same set in one of the partitions, and to different sets in another partition.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2Β·105) β the number of elements and the number of subsets in each partition, respectively.
The second line contains n integers wi (1 β€ wi β€ 109)β weights of elements of the set.
Output
Print one integer β the sum of weights of all partitions of a given set into k non-empty subsets, taken modulo 109 + 7.
Examples
Input
4 2
2 3 2 3
Output
160
Input
5 2
1 2 3 4 5
Output
645
Note
Possible partitions in the first sample:
1. {{1, 2, 3}, {4}}, W(R) = 3Β·(w1 + w2 + w3) + 1Β·w4 = 24;
2. {{1, 2, 4}, {3}}, W(R) = 26;
3. {{1, 3, 4}, {2}}, W(R) = 24;
4. {{1, 2}, {3, 4}}, W(R) = 2Β·(w1 + w2) + 2Β·(w3 + w4) = 20;
5. {{1, 3}, {2, 4}}, W(R) = 20;
6. {{1, 4}, {2, 3}}, W(R) = 20;
7. {{1}, {2, 3, 4}}, W(R) = 26;
Possible partitions in the second sample:
1. {{1, 2, 3, 4}, {5}}, W(R) = 45;
2. {{1, 2, 3, 5}, {4}}, W(R) = 48;
3. {{1, 2, 4, 5}, {3}}, W(R) = 51;
4. {{1, 3, 4, 5}, {2}}, W(R) = 54;
5. {{2, 3, 4, 5}, {1}}, W(R) = 57;
6. {{1, 2, 3}, {4, 5}}, W(R) = 36;
7. {{1, 2, 4}, {3, 5}}, W(R) = 37;
8. {{1, 2, 5}, {3, 4}}, W(R) = 38;
9. {{1, 3, 4}, {2, 5}}, W(R) = 38;
10. {{1, 3, 5}, {2, 4}}, W(R) = 39;
11. {{1, 4, 5}, {2, 3}}, W(R) = 40;
12. {{2, 3, 4}, {1, 5}}, W(R) = 39;
13. {{2, 3, 5}, {1, 4}}, W(R) = 40;
14. {{2, 4, 5}, {1, 3}}, W(R) = 41;
15. {{3, 4, 5}, {1, 2}}, W(R) = 42.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long n, k;
long long sum;
long long f[200000];
template <typename T>
T inv(T a, T b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long pow(long long a, long long k) {
long long ret = 1LL, s = a;
while (k) {
if (k & 1) ret = (ret * s) % mod;
s = (s * s) % mod;
k >>= 1;
}
return ret;
}
long long fact(long long n) {
if (f[n] == 0LL) f[n] = (n * fact(n - 1)) % mod;
return f[n];
}
long long stirling(long long n, long long k) {
long long ret = 0LL;
for (long long j = 1; j <= k; j++) {
long long cur =
(pow(j, n - 1) * inv((fact(j - 1) * fact(k - j)) % mod, mod)) % mod;
ret += ((k ^ j) & 1) ? -cur : cur;
}
ret %= mod;
return ret < 0 ? ret + mod : ret;
}
int main() {
f[0] = 1LL;
scanf("%lld %lld", &n, &k);
for (int i = 0; i < n; i++) {
long long tmp;
scanf("%lld", &tmp);
sum += tmp;
}
sum %= mod;
if (n == 1LL) {
printf("%lld\n", sum);
return 0;
}
long long ans = (stirling(n, k) + ((n - 1) * stirling(n - 1, k)) % mod) % mod;
ans = (ans * sum) % mod;
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Shrimpy Duc is a fat and greedy boy who is always hungry. After a while of searching for food to satisfy his never-ending hunger, Shrimpy Duc finds M&M candies lying unguarded on a L Γ L grid. There are n M&M candies on the grid, the i-th M&M is currently located at (x_i + 0.5, y_i + 0.5), and has color c_i out of a total of k colors (the size of M&Ms are insignificant).
Shrimpy Duc wants to steal a rectangle of M&Ms, specifically, he wants to select a rectangle with integer coordinates within the grid and steal all candies within the rectangle. Shrimpy Duc doesn't need to steal every single candy, however, he would like to steal at least one candy for each color.
In other words, he wants to select a rectangle whose sides are parallel to the coordinate axes and whose left-bottom vertex (X_1, Y_1) and right-top vertex (X_2, Y_2) are points with integer coordinates satisfying 0 β€ X_1 < X_2 β€ L and 0 β€ Y_1 < Y_2 β€ L, so that for every color 1 β€ c β€ k there is at least one M&M with color c that lies within that rectangle.
How many such rectangles are there? This number may be large, so you only need to find it modulo 10^9 + 7.
Input
The first line contains three positive integers n, k, L (1 β€ k β€ n β€ 2 β
10^3, 1 β€ L β€ 10^9 ) β the number of M&Ms, the number of colors and the length of the grid respectively.
The following n points describe the M&Ms. Each line contains three integers x_i, y_i, c_i (0 β€ x_i, y_i < L, 1 β€ c_i β€ k) β the coordinates and color of the i-th M&M respectively.
Different M&Ms have different coordinates (x_i β x_j or y_i β y_j for every i β j), and for every 1 β€ c β€ k there is at least one M&M with color c.
Output
Output a single integer β the number of rectangles satisfying Shrimpy Duc's conditions, modulo 10^9 + 7.
Examples
Input
4 2 4
3 2 2
3 1 1
1 1 1
1 2 1
Output
20
Input
5 3 10
6 5 3
5 3 1
7 9 1
2 3 2
5 0 2
Output
300
Input
10 4 10
5 4 4
0 0 3
6 0 1
3 9 2
8 7 1
8 1 3
2 1 3
6 3 2
3 5 3
4 3 4
Output
226
Note
Grid for the first sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
const int N = 2005, INF = 0x3f3f3f3f, P = 1000000007;
int n, m, L;
int mx, X[N];
int my, Y[N];
struct Node {
int x, y, c;
bool operator<(const Node &rhs) const {
return x < rhs.x || (x == rhs.x && y < rhs.y);
}
} a[N];
std::vector<int> p[N];
int top, sta[N];
std::vector<int> add[N], del[N];
int l[N];
struct TNode {
int mx, cnt, cmx;
long long sum;
TNode() {}
TNode(int v, int len) { mx = v, cnt = len, cmx = -INF, sum = 1ll * len * v; }
};
TNode operator+(const TNode &A, const TNode &B) {
TNode res;
res.sum = A.sum + B.sum;
res.cmx = std::max(A.cmx, B.cmx);
if (A.mx == B.mx) {
res.mx = A.mx;
res.cnt = A.cnt + B.cnt;
} else if (A.mx > B.mx) {
res.mx = A.mx;
res.cnt = A.cnt;
res.cmx = std::max(res.cmx, B.mx);
} else {
res.mx = B.mx;
res.cnt = B.cnt;
res.cmx = std::max(res.cmx, A.mx);
}
return res;
}
struct SegmentTree {
static const int N = ::N << 2;
TNode val[N];
int tag[N];
void build(int u, int l, int r) {
tag[u] = INF;
if (l == r) {
val[u] = TNode(INF, X[l] - X[l - 1]);
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
val[u] = val[u << 1] + val[u << 1 | 1];
}
void chmin(int u, int v) {
if (val[u].mx <= v) {
return;
}
tag[u] = v;
if (val[u].cmx < v) {
val[u].sum -= 1ll * (val[u].mx - v) * val[u].cnt;
val[u].mx = v;
return;
}
}
void down(int u) {
chmin(u << 1, tag[u]);
chmin(u << 1 | 1, tag[u]);
tag[u] = INF;
}
void modify(int u, int l, int r, int L, int R, int v) {
if (val[u].mx <= v) {
return;
}
if (L <= l && r <= R && val[u].cmx < v) {
chmin(u, v);
return;
}
int mid = (l + r) >> 1;
down(u);
if (L <= mid) {
modify(u << 1, l, mid, L, R, v);
}
if (R > mid) {
modify(u << 1 | 1, mid + 1, r, L, R, v);
}
val[u] = val[u << 1] + val[u << 1 | 1];
}
long long query(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return val[u].sum;
}
int mid = (l + r) >> 1;
down(u);
if (R <= mid) {
return query(u << 1, l, mid, L, R);
} else if (L > mid) {
return query(u << 1 | 1, mid + 1, r, L, R);
} else {
return query(u << 1, l, mid, L, R) + query(u << 1 | 1, mid + 1, r, L, R);
}
}
} T;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m >> L;
for (int i = 1; i <= n; ++i) {
std::cin >> a[i].x >> a[i].y >> a[i].c;
X[++mx] = a[i].x;
Y[++my] = a[i].y;
}
X[0] = -1, X[++mx] = L;
Y[0] = -1, Y[++my] = L;
std::sort(X + 1, X + 1 + mx);
mx = std::unique(X + 1, X + 1 + mx) - X - 1;
std::sort(Y + 1, Y + 1 + my);
my = std::unique(Y + 1, Y + 1 + my) - Y - 1;
for (int i = 1; i <= n; ++i) {
a[i].x = std::lower_bound(X + 1, X + 1 + mx, a[i].x) - X;
a[i].y = std::lower_bound(Y + 1, Y + 1 + my, a[i].y) - Y;
}
int ans = 0;
std::sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
p[a[i].c].push_back(i);
}
for (int up = 1; up <= my; ++up) {
for (int i = 1; i <= mx; ++i) {
add[i].clear();
del[i].clear();
}
T.build(1, 1, mx);
for (int c = 1; c <= m; ++c) {
top = 0;
for (int i = 0; i < (int)p[c].size(); ++i) {
int id = p[c][i];
if (a[id].y >= up) {
continue;
}
if (i + 1 < (int)p[c].size() && a[p[c][i + 1]].y < up &&
a[p[c][i + 1]].x == a[id].x) {
continue;
}
if (top) {
del[a[id].x].push_back(a[sta[top]].x);
} else {
del[a[id].x].push_back(0);
}
while (top && a[sta[top]].y <= a[id].y) {
add[a[id].x].push_back(sta[top]);
--top;
}
if (top) {
l[id] = a[sta[top]].x;
} else {
l[id] = 0;
}
sta[++top] = id;
}
if (top) {
del[mx].push_back(a[sta[top]].x);
} else {
del[mx].push_back(0);
}
while (top) {
add[mx].push_back(sta[top]);
--top;
}
}
for (int i = mx; i; --i) {
for (int v : add[i]) {
if (l[v] < mx) {
T.modify(1, 1, mx, l[v] + 1, mx, Y[a[v].y] + 1);
}
}
for (int v : del[i]) {
if (v < mx) {
T.modify(1, 1, mx, v + 1, mx, 0);
}
}
ans = (ans + T.query(1, 1, mx, 1, i) % P * (X[i] - X[i - 1]) % P *
(Y[up] - Y[up - 1])) %
P;
}
}
std::cout << ans << "\n";
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
A balance scale tips to the left if L>R, where L is the total weight of the masses on the left pan and R is the total weight of the masses on the right pan. Similarly, it balances if L=R, and tips to the right if L<R.
Takahashi placed a mass of weight A and a mass of weight B on the left pan of a balance scale, and placed a mass of weight C and a mass of weight D on the right pan.
Print `Left` if the balance scale tips to the left; print `Balanced` if it balances; print `Right` if it tips to the right.
Constraints
* 1\leq A,B,C,D \leq 10
* All input values are integers.
Input
Input is given from Standard Input in the following format:
A B C D
Output
Print `Left` if the balance scale tips to the left; print `Balanced` if it balances; print `Right` if it tips to the right.
Examples
Input
3 8 7 1
Output
Left
Input
3 4 5 2
Output
Balanced
Input
1 7 6 4
Output
Right
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
long long a,b,c,d;
int main()
{
cin>>a>>b>>c>>d;
if(a+b>c+d)cout<<"Left";else
if(a+b==c+d)cout<<"Balanced";else
cout<<"Right";
cout<<endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You can find anything whatsoever in our Galaxy! A cubical planet goes round an icosahedral star. Let us introduce a system of axes so that the edges of the cubical planet are parallel to the coordinate axes and two opposite vertices lay in the points (0, 0, 0) and (1, 1, 1). Two flies live on the planet. At the moment they are sitting on two different vertices of the cubical planet. Your task is to determine whether they see each other or not. The flies see each other when the vertices they occupy lie on the same face of the cube.
Input
The first line contains three space-separated integers (0 or 1) β the coordinates of the first fly, the second line analogously contains the coordinates of the second fly.
Output
Output "YES" (without quotes) if the flies see each other. Otherwise, output "NO".
Examples
Input
0 0 0
0 1 0
Output
YES
Input
1 1 0
0 1 0
Output
YES
Input
0 0 0
1 1 1
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t x1, x2, x3, y1, y2, y3;
cin >> x1 >> x2 >> x3;
cin >> y1 >> y2 >> y3;
if (x1 != y1 && x2 != y2 && x3 != y3)
cout << "NO";
else
cout << "YES";
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Housing maker Yamada House has launched a new featured product, a land for sale in a green home town with a rich environment such as schools and hospitals. This lot is divided into multiple lots and you can buy as many as you like, but the shape of the land with the lots you buy must be rectangular (including squares).
Yamada House has drawn a boundary for each purchaser in order to manage the lots sold out in all lots, and installed a sign with the purchaser number on one of the lots. The border was just a line drawn on the ground with tree branches, so it disappeared due to heavy rain a few days later, leaving only the sign. Figure 1 shows the number of the purchaser who bought the section on the section with the sign. This doesn't tell you how the land for sale was bought. The salvation is that I found a note (Figure 2) with the purchaser number b and the number of parcels k purchased in the office drawer.
<image>
Fig. 1 (left): Arrangement of signboards, Fig. 2 (right): Memo
As a programmer, you decided to write a program to help Yamada House. Create a program that inputs the size of the lot for sale X Γ Y, the number of purchasers n, the memo information b, k, and the location information s of the signboard, and outputs the purchasers of each section as shown in Fig. 3. Please give me.
<image>
Figure 3: Buyers of each parcel
For the given information, NA is output in the following cases.
* If there is no way to distinguish the parcels
* When there are multiple ways to distinguish between parcels
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by three lines of zeros. Each dataset is given in the following format:
X Y n
b1 k1
b2 k2
::
bn kn
s11 s21 ... sX1
s12 s22 ... sX2
::
s1Y s2Y ... sXY
The first line gives X, Y, n (1 β€ X, Y β€ 10, 1 β€ n β€ 15). The following n lines give the information bi (1 β€ bi β€ n), ki (1 β€ ki β€ 100) written on the i line of the memo.
The following Y line is given the information sij on the i-th line of the partition information. sij represents the sign information of the jth section from the left on the i-th line. Sign information sij is given 0 if there is no sign in the parcel, and the purchaser number of the parcel if there is a sign.
The number of datasets does not exceed 50.
Output
Prints buyer information or NA for each input dataset.
Example
Input
5 4 6
1 6
2 4
3 3
4 4
5 1
6 2
0 0 1 0 0
0 0 0 2 0
0 0 0 3 0
0 4 5 0 6
3 3 1
1 9
0 0 1
0 0 0
0 0 0
4 4 4
1 6
2 2
3 4
4 4
0 1 0 0
0 0 0 2
0 0 3 0
0 4 0 0
0 0 0
Output
1 1 1 2 2
1 1 1 2 2
4 4 3 3 3
4 4 5 6 6
1 1 1
1 1 1
1 1 1
NA
### Response
```cpp
#include<cstdio>
#include<vector>
#define mp make_pair
#define pb push_back
using namespace std;
typedef pair<int,int> pii;
typedef vector<pii> vpii;
vector<vpii> rect;
int w,h,n,land[10][10],test[10][10],ans[10][10];
bool search(int i0,int j0){
for(int i=i0;i<h;i++){
for(int j=(i==i0?j0:0);j<w;j++){
int id=land[i][j];
if(id==0) continue;
int cnt=0;
for(int k=0;k<rect[id].size();k++){
int rh=rect[id][k].first,rw=rect[id][k].second;
for(int y=i-rh+1;y<=i;y++)for(int x=j-rw+1;x<=j;x++){
if(!(0<=y && y+rh<=h && 0<=x && x+rw<=w)) continue;
bool canput=true;
for(int yy=y;yy<y+rh;yy++)for(int xx=x;xx<x+rw;xx++){
if(test[yy][xx]!=0
||(land[yy][xx]!=0 && land[yy][xx]!=id)) canput=false;
}
if(!canput) continue;
for(int yy=y;yy<y+rh;yy++)for(int xx=x;xx<x+rw;xx++) test[yy][xx]=id;
cnt+=search(i,j+1);
for(int yy=y;yy<y+rh;yy++)for(int xx=x;xx<x+rw;xx++) test[yy][xx]=0;
if(cnt>=2) return false;
}
}
return cnt==1;
}
}
bool suc=true;
for(int i=0;i<h;i++)for(int j=0;j<w;j++){
if(test[i][j]==0) suc=false;
}
if(suc){
for(int i=0;i<h;i++)for(int j=0;j<w;j++) ans[i][j]=test[i][j];
return true;
}
return false;
}
int main(){
for(;scanf("%d%d%d",&w,&h,&n),w;){
rect=vector<vpii>(n+1);
for(int i=0;i<n;i++){
int id,area; scanf("%d%d",&id,&area);
for(int j=1;j<=area;j++){
if(area%j==0) rect[id].pb(mp(j,area/j));
}
}
for(int i=0;i<h;i++)for(int j=0;j<w;j++) scanf("%d",&land[i][j]);
if(search(0,0)){
for(int i=0;i<h;i++){
for(int j=0;j<w;j++) printf("%s%d",(j?" ":""),ans[i][j]);
putchar('\n');
}
}
else puts("NA");
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Ilya is an experienced player in tic-tac-toe on the 4 Γ 4 field. He always starts and plays with Xs. He played a lot of games today with his friend Arseny. The friends became tired and didn't finish the last game. It was Ilya's turn in the game when they left it. Determine whether Ilya could have won the game by making single turn or not.
The rules of tic-tac-toe on the 4 Γ 4 field are as follows. Before the first turn all the field cells are empty. The two players take turns placing their signs into empty cells (the first player places Xs, the second player places Os). The player who places Xs goes first, the another one goes second. The winner is the player who first gets three of his signs in a row next to each other (horizontal, vertical or diagonal).
Input
The tic-tac-toe position is given in four lines.
Each of these lines contains four characters. Each character is '.' (empty cell), 'x' (lowercase English letter x), or 'o' (lowercase English letter o). It is guaranteed that the position is reachable playing tic-tac-toe, and it is Ilya's turn now (in particular, it means that the game is not finished). It is possible that all the cells are empty, it means that the friends left without making single turn.
Output
Print single line: "YES" in case Ilya could have won by making single turn, and "NO" otherwise.
Examples
Input
xx..
.oo.
x...
oox.
Output
YES
Input
x.ox
ox..
x.o.
oo.x
Output
NO
Input
x..x
..oo
o...
x.xo
Output
YES
Input
o.x.
o...
.x..
ooxx
Output
NO
Note
In the first example Ilya had two winning moves: to the empty cell in the left column and to the leftmost empty cell in the first row.
In the second example it wasn't possible to win by making single turn.
In the third example Ilya could have won by placing X in the last row between two existing Xs.
In the fourth example it wasn't possible to win by making single turn.
### Response
```cpp
#include <bits/stdc++.h>
using std::cin;
using std::string;
int main() {
char board[4][4];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) cin >> board[i][j];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) {
if (board[i][j] == 'x' && board[i][j + 1] == 'x' && j <= 2)
if (((j > 0) && (board[i][j - 1] == '.')) ||
((j <= 1) && (board[i][j + 2] == '.'))) {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i][j + 2] == 'x' && j <= 1)
if (board[i][j + 1] == '.') {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 1][j] == 'x' && i <= 2 && j <= 3)
if (((i > 0) && (board[i - 1][j] == '.')) ||
((i <= 1) && (board[i + 2][j] == '.'))) {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 2][j] == 'x' && i <= 1 && j <= 3)
if (board[i + 1][j] == '.') {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 1][j + 1] == 'x' && i <= 2 && j <= 2)
if (((i > 0 && j > 0) && (board[i - 1][j - 1] == '.')) ||
((i <= 1 && j <= 1) && (board[i + 2][j + 2] == '.'))) {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 2][j + 2] == 'x' && i <= 1 && j <= 1)
if (board[i + 1][j + 1] == '.') {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 1][j - 1] == 'x' && i <= 2 && j > 0)
if (((i > 0 && j <= 2) && (board[i - 1][j + 1] == '.')) ||
((j > 1) && (board[i + 2][j - 2] == '.'))) {
printf("YES\n");
return 0;
}
if (board[i][j] == 'x' && board[i + 2][j - 2] == 'x' && i <= 1 && j > 1)
if (board[i + 1][j - 1] == '.' && j > 0) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
``` |