text
stringlengths 424
69.5k
|
|---|
### Prompt
Develop a solution in Cpp to the problem described below:
Soon there will be held the world's largest programming contest, but the testing system still has m bugs. The contest organizer, a well-known university, has no choice but to attract university students to fix all the bugs. The university has n students able to perform such work. The students realize that they are the only hope of the organizers, so they don't want to work for free: the i-th student wants to get ci 'passes' in his subjects (regardless of the volume of his work).
Bugs, like students, are not the same: every bug is characterized by complexity aj, and every student has the level of his abilities bi. Student i can fix a bug j only if the level of his abilities is not less than the complexity of the bug: bi β₯ aj, and he does it in one day. Otherwise, the bug will have to be fixed by another student. Of course, no student can work on a few bugs in one day. All bugs are not dependent on each other, so they can be corrected in any order, and different students can work simultaneously.
The university wants to fix all the bugs as quickly as possible, but giving the students the total of not more than s passes. Determine which students to use for that and come up with the schedule of work saying which student should fix which bug.
Input
The first line contains three space-separated integers: n, m and s (1 β€ n, m β€ 105, 0 β€ s β€ 109) β the number of students, the number of bugs in the system and the maximum number of passes the university is ready to give the students.
The next line contains m space-separated integers a1, a2, ..., am (1 β€ ai β€ 109) β the bugs' complexities.
The next line contains n space-separated integers b1, b2, ..., bn (1 β€ bi β€ 109) β the levels of the students' abilities.
The next line contains n space-separated integers c1, c2, ..., cn (0 β€ ci β€ 109) β the numbers of the passes the students want to get for their help.
Output
If the university can't correct all bugs print "NO".
Otherwise, on the first line print "YES", and on the next line print m space-separated integers: the i-th of these numbers should equal the number of the student who corrects the i-th bug in the optimal answer. The bugs should be corrected as quickly as possible (you must spend the minimum number of days), and the total given passes mustn't exceed s. If there are multiple optimal answers, you can output any of them.
Examples
Input
3 4 9
1 3 1 2
2 1 3
4 3 6
Output
YES
2 3 2 3
Input
3 4 10
2 3 1 2
2 1 3
4 3 6
Output
YES
1 3 1 3
Input
3 4 9
2 3 1 2
2 1 3
4 3 6
Output
YES
3 3 2 3
Input
3 4 5
1 3 1 2
2 1 3
5 3 6
Output
NO
Note
Consider the first sample.
The third student (with level 3) must fix the 2nd and 4th bugs (complexities 3 and 2 correspondingly) and the second student (with level 1) must fix the 1st and 3rd bugs (their complexity also equals 1). Fixing each bug takes one day for each student, so it takes 2 days to fix all bugs (the students can work in parallel).
The second student wants 3 passes for his assistance, the third student wants 6 passes. It meets the university's capabilities as it is ready to give at most 9 passes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = 2e6 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353;
int n, m, S;
pair<long long, long long> a[N];
int ans[N];
struct node {
long long a, b, id;
bool operator<(const node &t) const { return b > t.b; }
} g[N];
bool cmp(node a, node b) { return a.a < b.a; }
bool check(int x) {
long long sum = 0;
priority_queue<node> q;
int i;
int cnt = n;
for (i = m; i >= 1; i--) {
while (cnt && g[cnt].a >= a[i].first) {
q.push(g[cnt--]);
}
if (q.empty()) return false;
int j;
for (j = i; j > max(i - x, 0); j--) {
ans[a[j].second] = q.top().id;
}
i -= x;
i++;
sum += q.top().b;
q.pop();
}
return sum <= S;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> S;
int i;
for (i = 1; i <= m; i++) {
cin >> a[i].first;
a[i].second = i;
}
for (i = 1; i <= n; i++) {
cin >> g[i].a;
g[i].id = i;
}
for (i = 1; i <= n; i++) cin >> g[i].b;
sort(a + 1, a + 1 + m);
sort(g + 1, g + 1 + n, cmp);
int l = 0, r = m + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == m + 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
check(l);
for (i = 1; i <= m; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Queue is a container of elements that are inserted and deleted according to FIFO (First In First Out).
For $n$ queues $Q_i$ ($i = 0, 1, ..., n-1$), perform a sequence of the following operations.
* enqueue($t$, $x$): Insert an integer $x$ to $Q_t$.
* front($t$): Report the value which should be deleted next from $Q_t$. If $Q_t$ is empty, do nothing.
* dequeue($t$): Delete an element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent enqueue, front and dequeue operations respectively.
Output
For each front operation, print an integer in a line.
Example
Input
3 9
0 0 1
0 0 2
0 0 3
0 2 4
0 2 5
1 0
1 2
2 0
1 0
Output
1
4
2
### Response
```cpp
#include <iostream>
#include <queue>
int main()
{
int n, q; std::cin >> n >> q;
std::queue<int>* que = new std::queue<int>[n];
;
for (int i=0; i<q; i++) {
int op, x, t;
std::cin >> op;
switch (op) {
case 0:
std::cin >> t >> x;
que[t].push(x);
break;
case 1:
std::cin >> t;
if (!que[t].empty()) std::cout << que[t].front() << std::endl;
break;
case 2:
std::cin >> t;
if (!que[t].empty()) que[t].pop();
break;
}
}
delete[] que;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The Squareland national forest is divided into equal 1 Γ 1 square plots aligned with north-south and east-west directions. Each plot can be uniquely described by integer Cartesian coordinates (x, y) of its south-west corner.
Three friends, Alice, Bob, and Charlie are going to buy three distinct plots of land A, B, C in the forest. Initially, all plots in the forest (including the plots A, B, C) are covered by trees. The friends want to visit each other, so they want to clean some of the plots from trees. After cleaning, one should be able to reach any of the plots A, B, C from any other one of those by moving through adjacent cleared plots. Two plots are adjacent if they share a side.
<image> For example, A=(0,0), B=(1,1), C=(2,2). The minimal number of plots to be cleared is 5. One of the ways to do it is shown with the gray color.
Of course, the friends don't want to strain too much. Help them find out the smallest number of plots they need to clean from trees.
Input
The first line contains two integers x_A and y_A β coordinates of the plot A (0 β€ x_A, y_A β€ 1000). The following two lines describe coordinates (x_B, y_B) and (x_C, y_C) of plots B and C respectively in the same format (0 β€ x_B, y_B, x_C, y_C β€ 1000). It is guaranteed that all three plots are distinct.
Output
On the first line print a single integer k β the smallest number of plots needed to be cleaned from trees. The following k lines should contain coordinates of all plots needed to be cleaned. All k plots should be distinct. You can output the plots in any order.
If there are multiple solutions, print any of them.
Examples
Input
0 0
1 1
2 2
Output
5
0 0
1 0
1 1
1 2
2 2
Input
0 0
2 0
1 1
Output
4
0 0
1 0
1 1
2 0
Note
The first example is shown on the picture in the legend.
The second example is illustrated with the following image:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int x[3], y[3];
for (int i = 0; i < 3; i++) cin >> x[i] >> y[i];
int s = 1e9;
int xx, yy;
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= 1000; j++) {
int t = 0;
for (int k = 0; k < 3; k++) t += (abs(i - x[k]) + abs(j - y[k]));
if (t < s) {
s = t;
xx = i;
yy = j;
}
}
set<pair<int, int>> ans;
for (int i = 0; i < 3; i++) {
while (x[i] > xx) ans.insert({x[i]--, y[i]});
while (x[i] < xx) ans.insert({x[i]++, y[i]});
while (y[i] > yy) ans.insert({x[i], y[i]--});
while (y[i] < yy) ans.insert({x[i], y[i]++});
}
ans.insert({xx, yy});
cout << ans.size() << '\n';
for (auto a : ans) cout << a.first << ' ' << a.second << '\n';
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
### Response
```cpp
#include <iostream>
using namespace std;
void solve()
{
int n;
while(cin >> n, n)
{
n = 1000 - n;
int count = 0;
count += n / 500;
n %= 500;
count += n / 100;
n %= 100;
count += n / 50;
n %= 50;
count += n / 10;
n %= 10;
count += n / 5;
n %= 5;
count += n;
cout << count << endl;
}
}
int main()
{
solve();
return(0);
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Vasya has got a magic matrix a of size n Γ m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to β{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q notβ‘ 0~(mod ~ 998244353). Print the value P β
Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 1 000) β the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 β€ a_{ij} β€ 10^9).
The following line contains two integers r and c (1 β€ r β€ n, 1 β€ c β€ m) β the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 1e6 + 10;
const int xm = 1e2 + 10;
const int sq = 320;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int mod = 998244353;
const int base = 257;
long long n, m, R2, L2, R, L, dp, part, cnt, ans[xn], ansL, ansR, ANS;
pair<int, pair<int, int> > num[xn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int x;
cin >> x;
num[cnt].first = x, num[cnt].second.first = i, num[cnt].second.second = j;
++cnt;
}
}
cin >> ansL >> ansR;
sort(num, num + cnt);
num[cnt].first = -1;
int k = 0;
for (int i = 0; i < cnt;) {
long long adad = num[i].first, ind = i;
long long tmpL = 0, tmpR = 0, tmpL2 = 0, tmpR2 = 0, tmpdp = 0, tmpcnt = 0;
while (i < cnt && num[i].first == adad) {
int x = num[i].second.first, y = num[i].second.second;
if (!k)
ans[i] = 0;
else
ans[i] = (x * x % mod) + (y * y % mod) +
(part * power(k, mod - 2, mod) % mod) +
(L2 * power(k, mod - 2, mod) % mod) +
(R2 * power(k, mod - 2, mod)) -
((2 * x * L % mod) * power(k, mod - 2, mod) % mod) -
((2 * y * R % mod) * power(k, mod - 2, mod) % mod),
ans[i] %= mod;
tmpdp += ans[i];
if (num[i].second.first == ansL && num[i].second.second == ansR)
ANS = ans[i];
++i;
tmpL += x, tmpR += y, tmpL2 += x * x, tmpR2 += y * y, tmpcnt++;
tmpL %= mod, tmpR %= mod, tmpL2 %= mod, tmpR2 %= mod;
}
L += tmpL, L %= mod;
L2 += tmpL2, L2 %= mod;
R += tmpR, R %= mod;
R2 += tmpR2, R2 %= mod;
part += tmpdp, part %= mod;
k += tmpcnt;
}
cout << ANS;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Write a program which reads a $ n \times m$ matrix $A$ and a $m \times 1$ vector $b$, and prints their product $Ab$.
A column vector with m elements is represented by the following equation.
\\[ b = \left( \begin{array}{c} b_1 \\\ b_2 \\\ : \\\ b_m \\\ \end{array} \right) \\]
A $n \times m$ matrix with $m$ column vectors, each of which consists of $n$ elements, is represented by the following equation.
\\[ A = \left( \begin{array}{cccc} a_{11} & a_{12} & ... & a_{1m} \\\ a_{21} & a_{22} & ... & a_{2m} \\\ : & : & : & : \\\ a_{n1} & a_{n2} & ... & a_{nm} \\\ \end{array} \right) \\]
$i$-th element of a $m \times 1$ column vector $b$ is represented by $b_i$ ($i = 1, 2, ..., m$), and the element in $i$-th row and $j$-th column of a matrix $A$ is represented by $a_{ij}$ ($i = 1, 2, ..., n,$ $j = 1, 2, ..., m$).
The product of a $n \times m$ matrix $A$ and a $m \times 1$ column vector $b$ is a $n \times 1$ column vector $c$, and $c_i$ is obtained by the following formula:
\\[ c_i = \sum_{j=1}^m a_{ij}b_j = a_{i1}b_1 + a_{i2}b_2 + ... + a_{im}b_m \\]
Constraints
* $1 \leq n, m \leq 100$
* $0 \leq b_i, a_{ij} \leq 1000$
Input
In the first line, two integers $n$ and $m$ are given. In the following $n$ lines, $a_{ij}$ are given separated by a single space character. In the next $m$ lines, $b_i$ is given in a line.
Output
The output consists of $n$ lines. Print $c_i$ in a line.
Example
Input
3 4
1 2 0 1
0 3 0 1
4 1 1 0
1
2
3
0
Output
5
6
9
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int x[101][101]={};
int y[101]={};
int main(){
int a,b;
cin>>a>>b;
for (int i=0;i<a;i++)for (int j=0;j<b;j++)cin>>x[i][j];
for (int i=0;i<b;i++)cin>>y[i];
for (int i=0;i<a;i++){
int ans=0;
for (int j=0;j<b;j++){
ans+=x[i][j]*y[j];
}
cout<<ans<<endl;
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You've come to your favorite store Infinitesco to buy some ice tea.
The store sells ice tea in bottles of different volumes at different costs. Specifically, a 0.25-liter bottle costs Q yen, a 0.5-liter bottle costs H yen, a 1-liter bottle costs S yen, and a 2-liter bottle costs D yen. The store has an infinite supply of bottles of each type.
You want to buy exactly N liters of ice tea. How many yen do you have to spend?
Constraints
* 1 \leq Q, H, S, D \leq 10^8
* 1 \leq N \leq 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
Q H S D
N
Output
Print the smallest number of yen you have to spend to buy exactly N liters of ice tea.
Examples
Input
20 30 70 90
3
Output
150
Input
10000 1000 100 10
1
Output
100
Input
10 100 1000 10000
1
Output
40
Input
12345678 87654321 12345678 87654321
123456789
Output
1524157763907942
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
long long n,x,y,z,d,ma;
int main()
{
scanf("%d%d%d%d%d",&x,&y,&z,&d,&n);
cout<<min(min(min(4*x,2*y),z)*n,(n/2*d+n%2* min(min(4*x,2*y),z)))<<endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Guy-Manuel and Thomas are planning 144 trips around the world.
You are given a simple weighted undirected connected graph with n vertexes and m edges with the following restriction: there isn't any simple cycle (i. e. a cycle which doesn't pass through any vertex more than once) of length greater than 3 which passes through the vertex 1. The cost of a path (not necessarily simple) in this graph is defined as the [XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges in that path with each edge being counted as many times as the path passes through it.
But the trips with cost 0 aren't exciting.
You may choose any subset of edges incident to the vertex 1 and remove them. How many are there such subsets, that, when removed, there is not any nontrivial cycle with the cost equal to 0 which passes through the vertex 1 in the resulting graph? A cycle is called nontrivial if it passes through some edge odd number of times. As the answer can be very big, output it modulo 10^9+7.
Input
The first line contains two integers n and m (1 β€ n,m β€ 10^5) β the number of vertexes and edges in the graph. The i-th of the next m lines contains three integers a_i, b_i and w_i (1 β€ a_i, b_i β€ n, a_i β b_i, 0 β€ w_i < 32) β the endpoints of the i-th edge and its weight. It's guaranteed there aren't any multiple edges, the graph is connected and there isn't any simple cycle of length greater than 3 which passes through the vertex 1.
Output
Output the answer modulo 10^9+7.
Examples
Input
6 8
1 2 0
2 3 1
2 4 3
2 6 2
3 4 8
3 5 4
5 4 5
5 6 6
Output
2
Input
7 9
1 2 0
1 3 1
2 3 9
2 4 3
2 5 4
4 5 7
3 6 6
3 7 7
6 7 8
Output
1
Input
4 4
1 2 27
1 3 1
1 4 1
3 4 0
Output
6
Note
The pictures below represent the graphs from examples. <image> In the first example, there aren't any nontrivial cycles with cost 0, so we can either remove or keep the only edge incident to the vertex 1. <image> In the second example, if we don't remove the edge 1-2, then there is a cycle 1-2-4-5-2-1 with cost 0; also if we don't remove the edge 1-3, then there is a cycle 1-3-2-4-5-2-3-1 of cost 0. The only valid subset consists of both edges. <image> In the third example, all subsets are valid except for those two in which both edges 1-3 and 1-4 are kept.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 405, Maxn = 100005, p = 1e9 + 7;
struct Basis {
int val[5];
bool insert(int x) {
for (int i = 4; i >= 0; i--)
if (x & (1 << i)) {
if (val[i])
x ^= val[i];
else {
val[i] = x;
for (int j = 0; j < i; j++)
if (val[j] && val[i] & (1 << j)) val[i] ^= val[j];
for (int j = i + 1; j <= 4; j++)
if (val[j] & (1 << i)) val[j] ^= val[i];
return true;
}
}
return false;
}
int Hash(void) {
return val[0] | val[1] << 1 | val[2] << 3 | val[3] << 6 | val[4] << 10;
}
void init(int x) {
val[0] = x & 1;
val[1] = x >> 1 & 3;
val[2] = x >> 3 & 7;
val[3] = x >> 6 & 15;
val[4] = x >> 10 & 31;
}
} B[Maxn];
int n, m, cnt, block_ct, edge_cnt, dfn_cnt, dfn[Maxn], root[Maxn], dis[Maxn],
cyc[Maxn], bel[Maxn], head[Maxn], trans[Maxk][Maxk], id[Maxn], rk[Maxk];
bool vis_cyc[Maxn], done[Maxn];
struct edg {
int nxt, to, w;
} edge[2 * Maxn];
void add(int x, int y, int w) {
edge[++edge_cnt] = (edg){head[x], y, w};
head[x] = edge_cnt;
}
void init(void) {
cnt = 374;
id[1] = 1, rk[1] = 1;
id[5] = 2, rk[2] = 5;
id[37] = 3, rk[3] = 37;
id[549] = 4, rk[4] = 549;
id[16933] = 5, rk[5] = 16933;
id[16421] = 6, rk[6] = 16421;
id[24613] = 7, rk[7] = 24613;
id[517] = 8, rk[8] = 517;
id[16901] = 9, rk[9] = 16901;
id[20997] = 10, rk[10] = 20997;
id[773] = 11, rk[11] = 773;
id[17157] = 12, rk[12] = 17157;
id[21253] = 13, rk[13] = 21253;
id[16389] = 14, rk[14] = 16389;
id[20485] = 15, rk[15] = 20485;
id[24581] = 16, rk[16] = 24581;
id[28677] = 17, rk[17] = 28677;
id[33] = 18, rk[18] = 33;
id[545] = 19, rk[19] = 545;
id[16929] = 20, rk[20] = 16929;
id[18977] = 21, rk[21] = 18977;
id[673] = 22, rk[22] = 673;
id[17057] = 23, rk[23] = 17057;
id[19105] = 24, rk[24] = 19105;
id[16417] = 25, rk[25] = 16417;
id[18465] = 26, rk[26] = 18465;
id[24609] = 27, rk[27] = 24609;
id[26657] = 28, rk[28] = 26657;
id[49] = 29, rk[29] = 49;
id[561] = 30, rk[30] = 561;
id[16945] = 31, rk[31] = 16945;
id[18993] = 32, rk[32] = 18993;
id[689] = 33, rk[33] = 689;
id[17073] = 34, rk[34] = 17073;
id[19121] = 35, rk[35] = 19121;
id[16433] = 36, rk[36] = 16433;
id[18481] = 37, rk[37] = 18481;
id[24625] = 38, rk[38] = 24625;
id[26673] = 39, rk[39] = 26673;
id[513] = 40, rk[40] = 513;
id[16897] = 41, rk[41] = 16897;
id[18945] = 42, rk[42] = 18945;
id[20993] = 43, rk[43] = 20993;
id[23041] = 44, rk[44] = 23041;
id[641] = 45, rk[45] = 641;
id[17025] = 46, rk[46] = 17025;
id[19073] = 47, rk[47] = 19073;
id[21121] = 48, rk[48] = 21121;
id[23169] = 49, rk[49] = 23169;
id[769] = 50, rk[50] = 769;
id[17153] = 51, rk[51] = 17153;
id[19201] = 52, rk[52] = 19201;
id[21249] = 53, rk[53] = 21249;
id[23297] = 54, rk[54] = 23297;
id[897] = 55, rk[55] = 897;
id[17281] = 56, rk[56] = 17281;
id[19329] = 57, rk[57] = 19329;
id[21377] = 58, rk[58] = 21377;
id[23425] = 59, rk[59] = 23425;
id[16385] = 60, rk[60] = 16385;
id[18433] = 61, rk[61] = 18433;
id[20481] = 62, rk[62] = 20481;
id[22529] = 63, rk[63] = 22529;
id[24577] = 64, rk[64] = 24577;
id[26625] = 65, rk[65] = 26625;
id[28673] = 66, rk[66] = 28673;
id[30721] = 67, rk[67] = 30721;
id[4] = 68, rk[68] = 4;
id[36] = 69, rk[69] = 36;
id[548] = 70, rk[70] = 548;
id[16932] = 71, rk[71] = 16932;
id[17956] = 72, rk[72] = 17956;
id[612] = 73, rk[73] = 612;
id[16996] = 74, rk[74] = 16996;
id[18020] = 75, rk[75] = 18020;
id[16420] = 76, rk[76] = 16420;
id[17444] = 77, rk[77] = 17444;
id[24612] = 78, rk[78] = 24612;
id[25636] = 79, rk[79] = 25636;
id[44] = 80, rk[80] = 44;
id[556] = 81, rk[81] = 556;
id[16940] = 82, rk[82] = 16940;
id[17964] = 83, rk[83] = 17964;
id[620] = 84, rk[84] = 620;
id[17004] = 85, rk[85] = 17004;
id[18028] = 86, rk[86] = 18028;
id[16428] = 87, rk[87] = 16428;
id[17452] = 88, rk[88] = 17452;
id[24620] = 89, rk[89] = 24620;
id[25644] = 90, rk[90] = 25644;
id[516] = 91, rk[91] = 516;
id[16900] = 92, rk[92] = 16900;
id[17924] = 93, rk[93] = 17924;
id[20996] = 94, rk[94] = 20996;
id[22020] = 95, rk[95] = 22020;
id[580] = 96, rk[96] = 580;
id[16964] = 97, rk[97] = 16964;
id[17988] = 98, rk[98] = 17988;
id[21060] = 99, rk[99] = 21060;
id[22084] = 100, rk[100] = 22084;
id[772] = 101, rk[101] = 772;
id[17156] = 102, rk[102] = 17156;
id[18180] = 103, rk[103] = 18180;
id[21252] = 104, rk[104] = 21252;
id[22276] = 105, rk[105] = 22276;
id[836] = 106, rk[106] = 836;
id[17220] = 107, rk[107] = 17220;
id[18244] = 108, rk[108] = 18244;
id[21316] = 109, rk[109] = 21316;
id[22340] = 110, rk[110] = 22340;
id[16388] = 111, rk[111] = 16388;
id[17412] = 112, rk[112] = 17412;
id[20484] = 113, rk[113] = 20484;
id[21508] = 114, rk[114] = 21508;
id[24580] = 115, rk[115] = 24580;
id[25604] = 116, rk[116] = 25604;
id[28676] = 117, rk[117] = 28676;
id[29700] = 118, rk[118] = 29700;
id[6] = 119, rk[119] = 6;
id[38] = 120, rk[120] = 38;
id[550] = 121, rk[121] = 550;
id[16934] = 122, rk[122] = 16934;
id[17958] = 123, rk[123] = 17958;
id[614] = 124, rk[124] = 614;
id[16998] = 125, rk[125] = 16998;
id[18022] = 126, rk[126] = 18022;
id[16422] = 127, rk[127] = 16422;
id[17446] = 128, rk[128] = 17446;
id[24614] = 129, rk[129] = 24614;
id[25638] = 130, rk[130] = 25638;
id[46] = 131, rk[131] = 46;
id[558] = 132, rk[132] = 558;
id[16942] = 133, rk[133] = 16942;
id[17966] = 134, rk[134] = 17966;
id[622] = 135, rk[135] = 622;
id[17006] = 136, rk[136] = 17006;
id[18030] = 137, rk[137] = 18030;
id[16430] = 138, rk[138] = 16430;
id[17454] = 139, rk[139] = 17454;
id[24622] = 140, rk[140] = 24622;
id[25646] = 141, rk[141] = 25646;
id[518] = 142, rk[142] = 518;
id[16902] = 143, rk[143] = 16902;
id[17926] = 144, rk[144] = 17926;
id[20998] = 145, rk[145] = 20998;
id[22022] = 146, rk[146] = 22022;
id[582] = 147, rk[147] = 582;
id[16966] = 148, rk[148] = 16966;
id[17990] = 149, rk[149] = 17990;
id[21062] = 150, rk[150] = 21062;
id[22086] = 151, rk[151] = 22086;
id[774] = 152, rk[152] = 774;
id[17158] = 153, rk[153] = 17158;
id[18182] = 154, rk[154] = 18182;
id[21254] = 155, rk[155] = 21254;
id[22278] = 156, rk[156] = 22278;
id[838] = 157, rk[157] = 838;
id[17222] = 158, rk[158] = 17222;
id[18246] = 159, rk[159] = 18246;
id[21318] = 160, rk[160] = 21318;
id[22342] = 161, rk[161] = 22342;
id[16390] = 162, rk[162] = 16390;
id[17414] = 163, rk[163] = 17414;
id[20486] = 164, rk[164] = 20486;
id[21510] = 165, rk[165] = 21510;
id[24582] = 166, rk[166] = 24582;
id[25606] = 167, rk[167] = 25606;
id[28678] = 168, rk[168] = 28678;
id[29702] = 169, rk[169] = 29702;
id[32] = 170, rk[170] = 32;
id[544] = 171, rk[171] = 544;
id[16928] = 172, rk[172] = 16928;
id[17952] = 173, rk[173] = 17952;
id[18976] = 174, rk[174] = 18976;
id[20000] = 175, rk[175] = 20000;
id[608] = 176, rk[176] = 608;
id[16992] = 177, rk[177] = 16992;
id[18016] = 178, rk[178] = 18016;
id[19040] = 179, rk[179] = 19040;
id[20064] = 180, rk[180] = 20064;
id[672] = 181, rk[181] = 672;
id[17056] = 182, rk[182] = 17056;
id[18080] = 183, rk[183] = 18080;
id[19104] = 184, rk[184] = 19104;
id[20128] = 185, rk[185] = 20128;
id[736] = 186, rk[186] = 736;
id[17120] = 187, rk[187] = 17120;
id[18144] = 188, rk[188] = 18144;
id[19168] = 189, rk[189] = 19168;
id[20192] = 190, rk[190] = 20192;
id[16416] = 191, rk[191] = 16416;
id[17440] = 192, rk[192] = 17440;
id[18464] = 193, rk[193] = 18464;
id[19488] = 194, rk[194] = 19488;
id[24608] = 195, rk[195] = 24608;
id[25632] = 196, rk[196] = 25632;
id[26656] = 197, rk[197] = 26656;
id[27680] = 198, rk[198] = 27680;
id[40] = 199, rk[199] = 40;
id[552] = 200, rk[200] = 552;
id[16936] = 201, rk[201] = 16936;
id[17960] = 202, rk[202] = 17960;
id[18984] = 203, rk[203] = 18984;
id[20008] = 204, rk[204] = 20008;
id[616] = 205, rk[205] = 616;
id[17000] = 206, rk[206] = 17000;
id[18024] = 207, rk[207] = 18024;
id[19048] = 208, rk[208] = 19048;
id[20072] = 209, rk[209] = 20072;
id[680] = 210, rk[210] = 680;
id[17064] = 211, rk[211] = 17064;
id[18088] = 212, rk[212] = 18088;
id[19112] = 213, rk[213] = 19112;
id[20136] = 214, rk[214] = 20136;
id[744] = 215, rk[215] = 744;
id[17128] = 216, rk[216] = 17128;
id[18152] = 217, rk[217] = 18152;
id[19176] = 218, rk[218] = 19176;
id[20200] = 219, rk[219] = 20200;
id[16424] = 220, rk[220] = 16424;
id[17448] = 221, rk[221] = 17448;
id[18472] = 222, rk[222] = 18472;
id[19496] = 223, rk[223] = 19496;
id[24616] = 224, rk[224] = 24616;
id[25640] = 225, rk[225] = 25640;
id[26664] = 226, rk[226] = 26664;
id[27688] = 227, rk[227] = 27688;
id[48] = 228, rk[228] = 48;
id[560] = 229, rk[229] = 560;
id[16944] = 230, rk[230] = 16944;
id[17968] = 231, rk[231] = 17968;
id[18992] = 232, rk[232] = 18992;
id[20016] = 233, rk[233] = 20016;
id[624] = 234, rk[234] = 624;
id[17008] = 235, rk[235] = 17008;
id[18032] = 236, rk[236] = 18032;
id[19056] = 237, rk[237] = 19056;
id[20080] = 238, rk[238] = 20080;
id[688] = 239, rk[239] = 688;
id[17072] = 240, rk[240] = 17072;
id[18096] = 241, rk[241] = 18096;
id[19120] = 242, rk[242] = 19120;
id[20144] = 243, rk[243] = 20144;
id[752] = 244, rk[244] = 752;
id[17136] = 245, rk[245] = 17136;
id[18160] = 246, rk[246] = 18160;
id[19184] = 247, rk[247] = 19184;
id[20208] = 248, rk[248] = 20208;
id[16432] = 249, rk[249] = 16432;
id[17456] = 250, rk[250] = 17456;
id[18480] = 251, rk[251] = 18480;
id[19504] = 252, rk[252] = 19504;
id[24624] = 253, rk[253] = 24624;
id[25648] = 254, rk[254] = 25648;
id[26672] = 255, rk[255] = 26672;
id[27696] = 256, rk[256] = 27696;
id[56] = 257, rk[257] = 56;
id[568] = 258, rk[258] = 568;
id[16952] = 259, rk[259] = 16952;
id[17976] = 260, rk[260] = 17976;
id[19000] = 261, rk[261] = 19000;
id[20024] = 262, rk[262] = 20024;
id[632] = 263, rk[263] = 632;
id[17016] = 264, rk[264] = 17016;
id[18040] = 265, rk[265] = 18040;
id[19064] = 266, rk[266] = 19064;
id[20088] = 267, rk[267] = 20088;
id[696] = 268, rk[268] = 696;
id[17080] = 269, rk[269] = 17080;
id[18104] = 270, rk[270] = 18104;
id[19128] = 271, rk[271] = 19128;
id[20152] = 272, rk[272] = 20152;
id[760] = 273, rk[273] = 760;
id[17144] = 274, rk[274] = 17144;
id[18168] = 275, rk[275] = 18168;
id[19192] = 276, rk[276] = 19192;
id[20216] = 277, rk[277] = 20216;
id[16440] = 278, rk[278] = 16440;
id[17464] = 279, rk[279] = 17464;
id[18488] = 280, rk[280] = 18488;
id[19512] = 281, rk[281] = 19512;
id[24632] = 282, rk[282] = 24632;
id[25656] = 283, rk[283] = 25656;
id[26680] = 284, rk[284] = 26680;
id[27704] = 285, rk[285] = 27704;
id[512] = 286, rk[286] = 512;
id[16896] = 287, rk[287] = 16896;
id[17920] = 288, rk[288] = 17920;
id[18944] = 289, rk[289] = 18944;
id[19968] = 290, rk[290] = 19968;
id[20992] = 291, rk[291] = 20992;
id[22016] = 292, rk[292] = 22016;
id[23040] = 293, rk[293] = 23040;
id[24064] = 294, rk[294] = 24064;
id[576] = 295, rk[295] = 576;
id[16960] = 296, rk[296] = 16960;
id[17984] = 297, rk[297] = 17984;
id[19008] = 298, rk[298] = 19008;
id[20032] = 299, rk[299] = 20032;
id[21056] = 300, rk[300] = 21056;
id[22080] = 301, rk[301] = 22080;
id[23104] = 302, rk[302] = 23104;
id[24128] = 303, rk[303] = 24128;
id[640] = 304, rk[304] = 640;
id[17024] = 305, rk[305] = 17024;
id[18048] = 306, rk[306] = 18048;
id[19072] = 307, rk[307] = 19072;
id[20096] = 308, rk[308] = 20096;
id[21120] = 309, rk[309] = 21120;
id[22144] = 310, rk[310] = 22144;
id[23168] = 311, rk[311] = 23168;
id[24192] = 312, rk[312] = 24192;
id[704] = 313, rk[313] = 704;
id[17088] = 314, rk[314] = 17088;
id[18112] = 315, rk[315] = 18112;
id[19136] = 316, rk[316] = 19136;
id[20160] = 317, rk[317] = 20160;
id[21184] = 318, rk[318] = 21184;
id[22208] = 319, rk[319] = 22208;
id[23232] = 320, rk[320] = 23232;
id[24256] = 321, rk[321] = 24256;
id[768] = 322, rk[322] = 768;
id[17152] = 323, rk[323] = 17152;
id[18176] = 324, rk[324] = 18176;
id[19200] = 325, rk[325] = 19200;
id[20224] = 326, rk[326] = 20224;
id[21248] = 327, rk[327] = 21248;
id[22272] = 328, rk[328] = 22272;
id[23296] = 329, rk[329] = 23296;
id[24320] = 330, rk[330] = 24320;
id[832] = 331, rk[331] = 832;
id[17216] = 332, rk[332] = 17216;
id[18240] = 333, rk[333] = 18240;
id[19264] = 334, rk[334] = 19264;
id[20288] = 335, rk[335] = 20288;
id[21312] = 336, rk[336] = 21312;
id[22336] = 337, rk[337] = 22336;
id[23360] = 338, rk[338] = 23360;
id[24384] = 339, rk[339] = 24384;
id[896] = 340, rk[340] = 896;
id[17280] = 341, rk[341] = 17280;
id[18304] = 342, rk[342] = 18304;
id[19328] = 343, rk[343] = 19328;
id[20352] = 344, rk[344] = 20352;
id[21376] = 345, rk[345] = 21376;
id[22400] = 346, rk[346] = 22400;
id[23424] = 347, rk[347] = 23424;
id[24448] = 348, rk[348] = 24448;
id[960] = 349, rk[349] = 960;
id[17344] = 350, rk[350] = 17344;
id[18368] = 351, rk[351] = 18368;
id[19392] = 352, rk[352] = 19392;
id[20416] = 353, rk[353] = 20416;
id[21440] = 354, rk[354] = 21440;
id[22464] = 355, rk[355] = 22464;
id[23488] = 356, rk[356] = 23488;
id[24512] = 357, rk[357] = 24512;
id[16384] = 358, rk[358] = 16384;
id[17408] = 359, rk[359] = 17408;
id[18432] = 360, rk[360] = 18432;
id[19456] = 361, rk[361] = 19456;
id[20480] = 362, rk[362] = 20480;
id[21504] = 363, rk[363] = 21504;
id[22528] = 364, rk[364] = 22528;
id[23552] = 365, rk[365] = 23552;
id[24576] = 366, rk[366] = 24576;
id[25600] = 367, rk[367] = 25600;
id[26624] = 368, rk[368] = 26624;
id[27648] = 369, rk[369] = 27648;
id[28672] = 370, rk[370] = 28672;
id[29696] = 371, rk[371] = 29696;
id[30720] = 372, rk[372] = 30720;
id[31744] = 373, rk[373] = 31744;
id[0] = 374, rk[374] = 0;
}
void get_trans(void) {
init();
for (int i = 1; i <= 374; i++) {
Basis tmp_i;
tmp_i.init(rk[i]);
for (int j = 1; j <= 374; j++) {
Basis tmp_j;
tmp_j.init(rk[j]);
bool Done = false;
for (int k = 0; k <= 4; k++)
if (tmp_i.val[k]) Done |= !tmp_j.insert(tmp_i.val[k]);
if (!Done) trans[i][j] = id[tmp_j.Hash()];
}
}
}
void dfs(int u, int fa, int now) {
bel[u] = now;
dfn[u] = ++dfn_cnt;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (!bel[to])
dis[to] = dis[u] ^ edge[i].w, dfs(to, u, now);
else if (to != 1 && to != fa && dfn[to] < dfn[u])
done[now] |= !B[now].insert(dis[to] ^ dis[u] ^ edge[i].w);
}
}
long long f[Maxk], g[Maxk], ans;
int main() {
scanf("%d%d", &n, &m);
init();
get_trans();
for (int i = 1; i <= m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
add(x, y, w);
add(y, x, w);
}
bel[1] = -1;
for (int i = head[1]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (!bel[to])
root[++block_ct] = to, cyc[block_ct] = edge[i].w, dfs(to, 1, block_ct);
else {
int rt = root[bel[to]];
for (int j = head[to]; j; j = edge[j].nxt)
if (edge[j].to == rt) {
cyc[bel[to]] = cyc[bel[to]] ^ edge[i].w ^ edge[j].w;
vis_cyc[bel[to]] = true;
}
}
}
f[374] = 1;
for (int i = 1; i <= block_ct; i++) {
if (done[i]) continue;
memcpy(g, f, sizeof(long long[cnt + 1]));
if (!vis_cyc[i]) {
int now = id[B[i].Hash()];
for (int j = 1; j <= cnt; j++)
if (trans[j][now]) (f[trans[j][now]] += g[j]) %= p;
} else {
int now1 = id[B[i].Hash()];
Basis tmp = B[i];
bool Done = tmp.insert(cyc[i]);
int now2 = id[tmp.Hash()];
for (int j = 1; j <= cnt; j++) {
if (trans[j][now1]) (f[trans[j][now1]] += 2 * g[j]) %= p;
if (Done && trans[j][now2]) (f[trans[j][now2]] += g[j]) %= p;
}
}
}
for (int i = 1; i <= cnt; i++) (ans += f[i]) %= p;
printf("%lld", ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
problem
Taro bought 10 books. Later, I tried to find out the price based on the receipt, but the receipt was dirty and I could not read the price of a book. We decided to calculate the price of the book from the total price of 10 books and the prices of the other 9 books.
Write a program that outputs the price of the book whose price could not be read. The prices of books are all positive integers. Also, there is no need to consider the consumption tax.
Example
Input
9850
1050
800
420
380
600
820
2400
1800
980
0
Output
600
### Response
```cpp
#include<stdio.h>
int main(void)
{
int n,m,i,z=0;
while(1){
z=0;
scanf("%d",&n);
if(n==0) break;
for(i=0;i<9;i++){
m=0;
scanf("%d",&m);
z+=m;
}
n=n-z;
printf("%d\n",n);
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
In ABBYY a wonderful Smart Beaver lives. This time, he began to study history. When he read about the Roman Empire, he became interested in the life of merchants.
The Roman Empire consisted of n cities numbered from 1 to n. It also had m bidirectional roads numbered from 1 to m. Each road connected two different cities. Any two cities were connected by no more than one road.
We say that there is a path between cities c1 and c2 if there exists a finite sequence of cities t1, t2, ..., tp (p β₯ 1) such that:
* t1 = c1
* tp = c2
* for any i (1 β€ i < p), cities ti and ti + 1 are connected by a road
We know that there existed a path between any two cities in the Roman Empire.
In the Empire k merchants lived numbered from 1 to k. For each merchant we know a pair of numbers si and li, where si is the number of the city where this merchant's warehouse is, and li is the number of the city where his shop is. The shop and the warehouse could be located in different cities, so the merchants had to deliver goods from the warehouse to the shop.
Let's call a road important for the merchant if its destruction threatens to ruin the merchant, that is, without this road there is no path from the merchant's warehouse to his shop. Merchants in the Roman Empire are very greedy, so each merchant pays a tax (1 dinar) only for those roads which are important for him. In other words, each merchant pays di dinars of tax, where di (di β₯ 0) is the number of roads important for the i-th merchant.
The tax collection day came in the Empire. The Smart Beaver from ABBYY is very curious by nature, so he decided to count how many dinars each merchant had paid that day. And now he needs your help.
Input
The first input line contains two integers n and m, separated by a space, n is the number of cities, and m is the number of roads in the empire.
The following m lines contain pairs of integers ai, bi (1 β€ ai, bi β€ n, ai β bi), separated by a space β the numbers of cities connected by the i-th road. It is guaranteed that any two cities are connected by no more than one road and that there exists a path between any two cities in the Roman Empire.
The next line contains a single integer k β the number of merchants in the empire.
The following k lines contain pairs of integers si, li (1 β€ si, li β€ n), separated by a space, β si is the number of the city in which the warehouse of the i-th merchant is located, and li is the number of the city in which the shop of the i-th merchant is located.
The input limitations for getting 20 points are:
* 1 β€ n β€ 200
* 1 β€ m β€ 200
* 1 β€ k β€ 200
The input limitations for getting 50 points are:
* 1 β€ n β€ 2000
* 1 β€ m β€ 2000
* 1 β€ k β€ 2000
The input limitations for getting 100 points are:
* 1 β€ n β€ 105
* 1 β€ m β€ 105
* 1 β€ k β€ 105
Output
Print exactly k lines, the i-th line should contain a single integer di β the number of dinars that the i-th merchant paid.
Examples
Input
7 8
1 2
2 3
3 4
4 5
5 6
5 7
3 5
4 7
4
1 5
2 4
2 6
4 7
Output
2
1
2
0
Note
The given sample is illustrated in the figure below.
<image>
Let's describe the result for the first merchant. The merchant's warehouse is located in city 1 and his shop is in city 5. Let us note that if either road, (1, 2) or (2, 3) is destroyed, there won't be any path between cities 1 and 5 anymore. If any other road is destroyed, the path will be preserved. That's why for the given merchant the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, LG = 17 + 3;
int n, m, q, a[N], h[N], mn[N], par[N][LG];
vector<int> adj[N];
void dfs1(int u) {
mn[u] = h[u] = h[par[u][0]] + 1;
for (auto v : adj[u])
if (!h[v]) {
par[v][0] = u;
dfs1(v);
a[v] = (mn[v] > h[u]);
mn[u] = min(mn[u], mn[v]);
} else if (v ^ par[u][0])
mn[u] = min(mn[u], h[v]);
}
void dfs2(int u) {
for (int i = 0; i < LG - 1; i++) par[u][i + 1] = par[par[u][i]][i];
for (auto v : adj[u])
if (h[v] == h[u] + 1) {
a[v] += a[u];
dfs2(v);
}
}
inline int get_par(int u, int k) {
for (int i = 0; i < LG; i++)
if (k >> i & 1) u = par[u][i];
return u;
}
inline int lca(int u, int v) {
if (h[u] > h[v]) swap(u, v);
v = get_par(v, h[v] - h[u]);
for (int i = LG - 1; ~i; i--)
if (par[u][i] ^ par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return u ^ v ? par[u][0] : u;
}
inline int dist(int u, int v) { return a[u] + a[v] - 2 * a[lca(u, v)]; }
inline void readInput() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
inline void solve() {
dfs1(0);
dfs2(0);
}
inline void writeOutput() {
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
cout << dist(u - 1, v - 1) << endl;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
readInput(), solve(), writeOutput();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given an n Γ m rectangular table consisting of lower case English letters. In one operation you can completely remove one column from the table. The remaining parts are combined forming a new table. For example, after removing the second column from the table
abcd
edfg
hijk
we obtain the table:
acd
efg
hjk
A table is called good if its rows are ordered from top to bottom lexicographically, i.e. each row is lexicographically no larger than the following one. Determine the minimum number of operations of removing a column needed to make a given table good.
Input
The first line contains two integers β n and m (1 β€ n, m β€ 100).
Next n lines contain m small English letters each β the characters of the table.
Output
Print a single number β the minimum number of columns that you need to remove in order to make the table good.
Examples
Input
1 10
codeforces
Output
0
Input
4 4
case
care
test
code
Output
2
Input
5 4
code
forc
esco
defo
rces
Output
4
Note
In the first sample the table is already good.
In the second sample you may remove the first and third column.
In the third sample you have to remove all the columns (note that the table where all rows are empty is considered good by definition).
Let strings s and t have equal length. Then, s is lexicographically larger than t if they are not equal and the character following the largest common prefix of s and t (the prefix may be empty) in s is alphabetically larger than the corresponding character of t.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int done[1005];
char str[105][105];
int main() {
int r, c, cnt, sol, i, j;
ios::sync_with_stdio(false);
cin >> r >> c;
for (i = 0; i < r; i++) {
cin >> str[i];
}
cnt = 0;
for (i = 0; i < c; i++) {
sol = 0;
for (j = 1; j < r; j++) {
if (!done[j] && (str[j][i] < str[j - 1][i])) {
sol = 1;
}
}
if (!sol) {
for (j = 1; j < r; j++) {
if (!done[j] && (str[j][i] > str[j - 1][i])) done[j] = 1;
}
} else {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
In this problem, we will deal with binary strings. Each character of a binary string is either a 0 or a 1. We will also deal with substrings; recall that a substring is a contiguous subsequence of a string. We denote the substring of string s starting from the l-th character and ending with the r-th character as s[l ... r]. The characters of each string are numbered from 1.
We can perform several operations on the strings we consider. Each operation is to choose a substring of our string and replace it with another string. There are two possible types of operations: replace 011 with 110, or replace 110 with 011. For example, if we apply exactly one operation to the string 110011110, it can be transformed into 011011110, 110110110, or 110011011.
Binary string a is considered reachable from binary string b if there exists a sequence s_1, s_2, ..., s_k such that s_1 = a, s_k = b, and for every i β [1, k - 1], s_i can be transformed into s_{i + 1} using exactly one operation. Note that k can be equal to 1, i. e., every string is reachable from itself.
You are given a string t and q queries to it. Each query consists of three integers l_1, l_2 and len. To answer each query, you have to determine whether t[l_1 ... l_1 + len - 1] is reachable from t[l_2 ... l_2 + len - 1].
Input
The first line contains one integer n (1 β€ n β€ 2 β
10^5) β the length of string t.
The second line contains one string t (|t| = n). Each character of t is either 0 or 1.
The third line contains one integer q (1 β€ q β€ 2 β
10^5) β the number of queries.
Then q lines follow, each line represents a query. The i-th line contains three integers l_1, l_2 and len (1 β€ l_1, l_2 β€ |t|, 1 β€ len β€ |t| - max(l_1, l_2) + 1) for the i-th query.
Output
For each query, print either YES if t[l_1 ... l_1 + len - 1] is reachable from t[l_2 ... l_2 + len - 1], or NO otherwise. You may print each letter in any register.
Example
Input
5
11011
3
1 3 3
1 4 2
1 2 3
Output
Yes
Yes
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
template <class t>
bool inc(t first, t second, t c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
using uint = unsigned;
using ull = unsigned long long;
struct modinfo {
uint mod, root;
};
template <modinfo const& ref>
struct modular {
static constexpr uint const& mod = ref.mod;
static modular root() { return modular(ref.root); }
uint v;
modular(ll vv = 0) { s(vv % mod + mod); }
modular& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
modular operator-() const { return modular() - *this; }
modular& operator+=(const modular& rhs) { return s(v + rhs.v); }
modular& operator-=(const modular& rhs) { return s(v + mod - rhs.v); }
modular& operator*=(const modular& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
modular& operator/=(const modular& rhs) { return *this *= rhs.inv(); }
modular operator+(const modular& rhs) const { return modular(*this) += rhs; }
modular operator-(const modular& rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular& rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular& rhs) const { return modular(*this) /= rhs; }
modular pow(ll n) const {
modular res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
modular inv() const { return pow(mod - 2); }
friend modular operator+(ll x, const modular& y) { return modular(x) + y; }
friend modular operator-(ll x, const modular& y) { return modular(x) - y; }
friend modular operator*(ll x, const modular& y) { return modular(x) * y; }
friend modular operator/(ll x, const modular& y) { return modular(x) / y; }
friend ostream& operator<<(ostream& os, const modular& m) {
return os << m.v;
}
friend istream& operator>>(istream& is, modular& m) {
ll x;
is >> x;
m = modular(x);
return is;
}
bool operator<(const modular& r) const { return v < r.v; }
bool operator==(const modular& r) const { return v == r.v; }
bool operator!=(const modular& r) const { return v != r.v; }
explicit operator bool() const { return v; }
};
extern constexpr modinfo base{1000000007, 0};
using mint = modular<base>;
const ll vmax = (1 << 21) + 10;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[vmax - 1] = fact[vmax - 1].inv();
for (ll i = vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = vmax - 1; i >= 1; i--) {
invs[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
namespace rhash {
const ll k = 4;
vc<array<mint, k>> first, second;
void init(ll n) {
first.resize(n + 1);
second.resize(n + 1);
for (ll i = ll(0); i < ll(k); i++) {
first[0][i] = 1;
first[1][i] = rand_int(1, mint::mod - 1);
second[0][i] = 1;
second[1][i] = first[1][i].inv();
}
for (ll i = ll(1); i < ll(n); i++)
for (ll j = ll(0); j < ll(k); j++) {
first[i + 1][j] = first[i][j] * first[1][j];
second[i + 1][j] = second[i][j] * second[1][j];
}
}
using P = pair<array<mint, k>, ll>;
P mrg(P x, P y) {
for (ll i = ll(0); i < ll(k); i++)
x.first[i] += y.first[i] * first[x.second][i];
x.second += y.second;
return x;
}
struct gen {
gen() {}
vc<array<mint, k>> c;
template <class S>
gen(S s) : c(s.size() + 1) {
for (ll i = ll(0); i < ll(s.size()); i++)
for (ll j = ll(0); j < ll(k); j++)
c[i + 1][j] = c[i][j] + first[i][j] * s[i];
}
P get(ll l, ll r) {
P res;
for (ll i = ll(0); i < ll(k); i++)
res.first[i] = (c[r][i] - c[l][i]) * second[l][i];
res.second = r - l;
return res;
}
};
} // namespace rhash
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n;
cin >> n;
vi ps{-1};
{
string s;
cin >> s;
for (ll i = ll(0); i < ll(n); i++)
if (s[i] == '0') ps.push_back(i);
}
ps.push_back(n);
rhash::init(ll(ps.size()));
vi x[2];
for (ll k = ll(0); k < ll(2); k++) {
for (auto v : ps) x[k].push_back((v ^ k) & 1);
}
rhash::gen y[2];
for (ll k = ll(0); k < ll(2); k++) y[k] = rhash::gen(x[k]);
auto get = [&](ll l, ll r) -> rhash::P {
ll i = lwb(ps, l);
if (ps[i] < r) {
return y[l & 1].get(i, lwb(ps, r));
} else {
return {};
}
};
ll q;
cin >> q;
for (ll _ = ll(0); _ < ll(q); _++) {
ll first, second, c;
cin >> first >> second >> c;
first--;
second--;
if (get(first, first + c) == get(second, second + c))
yes(0);
else
no(0);
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
double p, q;
complex<double> ps[100010];
inline double cross(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
bool cmp(complex<double> a, complex<double> b) {
double c = cross(a, b);
if (c == 0) return a.real() + a.imag() < b.real() + b.imag();
return c > 0;
}
inline bool isl(complex<double> a, complex<double> b, complex<double> c) {
return cross(b - a, c - a) > 0;
}
vector<complex<double> > convex;
bool calc(double time) {
for (int i = 0; i < convex.size() - 1; i++) {
complex<double> a = convex[i] * time, b = complex<double>(p, q),
c = convex[i + 1] * time;
if (cmp(a, b) && cmp(b, c) && !isl(a, b, c)) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> p >> q;
int mxa = 0, mxb = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
ps[i] = complex<double>(a, b);
mxa = max(mxa, a);
mxb = max(mxb, b);
}
ps[n] = complex<double>(mxa, 0);
ps[n + 1] = complex<double>(0, mxb);
n += 2;
sort(ps, ps + n, cmp);
for (int i = 0; i < n; i++) {
while (convex.size() >= 2 &&
!isl(convex[convex.size() - 2], convex.back(), ps[i]))
convex.pop_back();
convex.push_back(ps[i]);
}
double l = 0, r = max(p, q);
while (r - l > 1e-7) {
double mid = (l + r) / 2;
if (calc(mid))
r = mid;
else
l = mid;
}
cout << fixed << setprecision(10) << (l + r) / 2 << endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
I have an undirected graph consisting of n nodes, numbered 1 through n. Each node has at most two incident edges. For each pair of nodes, there is at most an edge connecting them. No edge connects a node to itself.
I would like to create a new graph in such a way that:
* The new graph consists of the same number of nodes and edges as the old graph.
* The properties in the first paragraph still hold.
* For each two nodes u and v, if there is an edge connecting them in the old graph, there is no edge connecting them in the new graph.
Help me construct the new graph, or tell me if it is impossible.
Input
The first line consists of two space-separated integers: n and m (1 β€ m β€ n β€ 105), denoting the number of nodes and edges, respectively. Then m lines follow. Each of the m lines consists of two space-separated integers u and v (1 β€ u, v β€ n; u β v), denoting an edge between nodes u and v.
Output
If it is not possible to construct a new graph with the mentioned properties, output a single line consisting of -1. Otherwise, output exactly m lines. Each line should contain a description of edge in the same way as used in the input format.
Examples
Input
8 7
1 2
2 3
4 5
5 6
6 8
8 7
7 4
Output
1 4
4 6
1 6
2 7
7 5
8 5
2 8
Input
3 2
1 2
2 3
Output
-1
Input
5 4
1 2
2 3
3 4
4 1
Output
1 3
3 5
5 2
2 4
Note
The old graph of the first example:
<image>
A possible new graph for the first example:
<image>
In the second example, we cannot create any new graph.
The old graph of the third example:
<image>
A possible new graph for the third example:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, M, cnt;
map<pair<int, int>, bool> mp;
int nd[200005];
void solve() {
cnt++;
vector<pair<int, int> > ari;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
for (int i = 1; i <= N; i++) nd[i] = i;
shuffle(nd + 1, nd + N + 1, rng);
int l = 1;
while (l <= N) {
int r = l;
while (ari.size() < M && r + 1 <= N && !mp[{nd[r], nd[r + 1]}]) {
ari.push_back({nd[r], nd[r + 1]});
r++;
}
if (l + 2 <= r && ari.size() < M && !mp[{nd[l], nd[r]}])
ari.push_back({nd[l], nd[r]});
l = r + 1;
}
if (ari.size() == M) {
for (auto v : ari) cout << v.first << " " << v.second << "\n";
exit(0);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int u, v;
cin >> u >> v;
mp[{u, v}] = 1;
mp[{v, u}] = 1;
}
int T = 150;
while (T--) solve();
cout << "-1\n";
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Nathan O. Davis has been running an electronic bulletin board system named JAG-channel. He is now having hard time to add a new feature there --- threaded view.
Like many other bulletin board systems, JAG-channel is thread-based. Here a thread (also called a topic) refers to a single conversation with a collection of posts. Each post can be an opening post, which initiates a new thread, or a reply to a previous post in an existing thread.
Threaded view is a tree-like view that reflects the logical reply structure among the posts: each post forms a node of the tree and contains its replies as its subnodes in the chronological order (i.e. older replies precede newer ones). Note that a post along with its direct and indirect replies forms a subtree as a whole.
Let us take an example. Suppose: a user made an opening post with a message `hoge`; another user replied to it with `fuga`; yet another user also replied to the opening post with `piyo`; someone else replied to the second post (i.e. `fuga`β) with `foobar`; and the fifth user replied to the same post with `jagjag`. The tree of this thread would look like:
hoge
ββfuga
βγββfoobar
βγββjagjag
ββpiyo
For easier implementation, Nathan is thinking of a simpler format: the depth of each post from the opening post is represented by dots. Each reply gets one more dot than its parent post. The tree of the above thread would then look like:
hoge
.fuga
..foobar
..jagjag
.piyo
Your task in this problem is to help Nathan by writing a program that prints a tree in the Nathan's format for the given posts in a single thread.
Input
Input contains a single dataset in the following format:
n
k_1
M_1
k_2
M_2
:
:
k_n
M_n
The first line contains an integer n (1 β€ n β€ 1,000), which is the number of posts in the thread. Then 2n lines follow. Each post is represented by two lines: the first line contains an integer k_i (k_1 = 0, 1 β€ k_i < i for 2 β€ i β€ n) and indicates the i-th post is a reply to the k_i-th post; the second line contains a string M_i and represents the message of the i-th post. k_1 is always 0, which means the first post is not replying to any other post, i.e. it is an opening post.
Each message contains 1 to 50 characters, consisting of uppercase, lowercase, and numeric letters.
Output
Print the given n messages as specified in the problem statement.
Sample Input 1
1
0
icpc
Output for the Sample Input 1
icpc
Sample Input 2
5
0
hoge
1
fuga
1
piyo
2
foobar
2
jagjag
Output for the Sample Input 2
hoge
.fuga
..foobar
..jagjag
.piyo
Sample Input 3
8
0
jagjag
1
hogehoge
1
buhihi
2
fugafuga
4
ponyoponyo
5
evaeva
4
nowawa
5
pokemon
Output for the Sample Input 3
jagjag
.hogehoge
..fugafuga
...ponyoponyo
....evaeva
....pokemon
...nowawa
.buhihi
Sample Input 4
6
0
nakachan
1
fan
2
yamemasu
3
nennryou2
4
dannyaku4
5
kouzai11
Output for the Sample Input 4
nakachan
.fan
..yamemasu
...nennryou2
....dannyaku4
.....kouzai11
Sample Input 5
34
0
LoveLive
1
honoka
2
borarara
2
sunohare
2
mogyu
1
eri
6
kasikoi
7
kawaii
8
eriichika
1
kotori
10
WR
10
haetekurukotori
10
ichigo
1
umi
14
love
15
arrow
16
shoot
1
rin
18
nyanyanya
1
maki
20
6th
20
star
22
nishikino
1
nozomi
24
spiritual
25
power
1
hanayo
27
darekatasukete
28
chottomattete
1
niko
30
natsuiro
30
nikkonikkoni
30
sekaino
33
YAZAWA
Output for the Sample Input 5
LoveLive
.honoka
..borarara
..sunohare
..mogyu
.eri
..kasikoi
...kawaii
....eriichika
.kotori
..WR
..haetekurukotori
..ichigo
.umi
..love
...arrow
....shoot
.rin
..nyanyanya
.maki
..6th
..star
...nishikino
.nozomi
..spiritual
...power
.hanayo
..darekatasukete
...chottomattete
.niko
..natsuiro
..nikkonikkoni
..sekaino
...YAZAWA
Sample Input 6
6
0
2ch
1
1ostu
1
2get
1
1otsu
1
1ostu
3
pgr
Output for the Sample Input 6
2ch
.1ostu
.2get
..pgr
.1otsu
.1ostu
Example
Input
1
0
icpc
Output
icpc
### Response
```cpp
#include <iostream>
#include <vector>
#include <string>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
class State {
public:
int id;
string str;
int deep;
vector<State> rep;
void draw()
{
rep(i, deep) {
cout << '.';
}
cout << str << endl;
for (auto& r : rep) {
r.draw();
}
}
void add(State s, int i)
{
if (i == id) {
s.deep = deep + 1;
rep.push_back(s);
}
else {
for (auto& r : rep) {
r.add(s, i);
}
}
}
};
int main()
{
int n;
cin >> n;
State s;
s.id = 1;
s.deep = 0;
cin >> s.str >> s.str;
rep(i, n - 1) {
int r;
State temp;
temp.id = i + 2;
cin >> r >> temp.str;
s.add(temp, r);
}
s.draw();
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s β the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int n1 = 0, n2 = 0, n3 = 0, n4;
for (int i = 0; i < n; i++) {
if (s[i] == '1') n1 += 1;
if (s[i] == '2') n2 += 1;
if (s[i] == '3') n3 += 1;
if (s[i] == '+') n4 += 1;
}
for (int j = 1; j <= n1; j++) {
cout << 1;
if (n4 > 0) {
cout << '+';
--n4;
}
}
for (int j = 1; j <= n2; j++) {
cout << 2;
if (n4 > 0) {
cout << '+';
--n4;
}
}
for (int j = 1; j <= n3; j++) {
cout << 3;
if (n4 > 0) {
cout << '+';
--n4;
}
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Initially Ildar has an empty array. He performs n steps. On each step he takes a subset of integers already added to the array and appends the mex of this subset to the array.
The mex of an multiset of integers is the smallest non-negative integer not presented in the multiset. For example, the mex of the multiset [0, 2, 3] is 1, while the mex of the multiset [1, 2, 1] is 0.
More formally, on the step m, when Ildar already has an array a_1, a_2, β¦, a_{m-1}, he chooses some subset of indices 1 β€ i_1 < i_2 < β¦ < i_k < m (possibly, empty), where 0 β€ k < m, and appends the mex(a_{i_1}, a_{i_2}, β¦ a_{i_k}) to the end of the array.
After performing all the steps Ildar thinks that he might have made a mistake somewhere. He asks you to determine for a given array a_1, a_2, β¦, a_n the minimum step t such that he has definitely made a mistake on at least one of the steps 1, 2, β¦, t, or determine that he could have obtained this array without mistakes.
Input
The first line contains a single integer n (1 β€ n β€ 100 000) β the number of steps Ildar made.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 10^9) β the array Ildar obtained.
Output
If Ildar could have chosen the subsets on each step in such a way that the resulting array is a_1, a_2, β¦, a_n, print -1.
Otherwise print a single integer t β the smallest index of a step such that a mistake was made on at least one step among steps 1, 2, β¦, t.
Examples
Input
4
0 1 2 1
Output
-1
Input
3
1 0 1
Output
1
Input
4
0 1 2 239
Output
4
Note
In the first example it is possible that Ildar made no mistakes. Here is the process he could have followed.
* 1-st step. The initial array is empty. He can choose an empty subset and obtain 0, because the mex of an empty set is 0. Appending this value to the end he gets the array [0].
* 2-nd step. The current array is [0]. He can choose a subset [0] and obtain an integer 1, because mex(0) = 1. Appending this value to the end he gets the array [0,1].
* 3-rd step. The current array is [0,1]. He can choose a subset [0,1] and obtain an integer 2, because mex(0,1) = 2. Appending this value to the end he gets the array [0,1,2].
* 4-th step. The current array is [0,1,2]. He can choose a subset [0] and obtain an integer 1, because mex(0) = 1. Appending this value to the end he gets the array [0,1,2,1].
Thus, he can get the array without mistakes, so the answer is -1.
In the second example he has definitely made a mistake on the very first step, because he could not have obtained anything different from 0.
In the third example he could have obtained [0, 1, 2] without mistakes, but 239 is definitely wrong.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int maxi = 0;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (a > maxi) {
cout << i << endl;
return 0;
}
if (a == maxi) {
maxi++;
}
}
cout << -1 << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Fox Ciel just designed a puzzle game called "Polygon"! It is played using triangulations of a regular n-edge polygon. The goal is to transform one triangulation to another by some tricky rules.
<image>
Triangulation of an n-edge poylgon is a set of n - 3 diagonals satisfying the condition that no two diagonals share a common internal point.
For example, the initial state of the game may look like (a) in above figure. And your goal may look like (c). In each step you can choose a diagonal inside the polygon (but not the one of edges of the polygon) and flip this diagonal.
Suppose you are going to flip a diagonal a β b. There always exist two triangles sharing a β b as a side, let's denote them as a β b β c and a β b β d. As a result of this operation, the diagonal a β b is replaced by a diagonal c β d. It can be easily proven that after flip operation resulting set of diagonals is still a triangulation of the polygon.
So in order to solve above case, you may first flip diagonal 6 β 3, it will be replaced by diagonal 2 β 4. Then you flip diagonal 6 β 4 and get figure (c) as result.
Ciel just proved that for any starting and destination triangulations this game has a solution. She wants you to solve it in no more than 20 000 steps for any puzzle satisfying n β€ 1000.
Input
The first line contain an integer n (4 β€ n β€ 1000), number of edges of the regular polygon.
Then follows two groups of (n - 3) lines describing the original triangulation and goal triangulation.
Description of each triangulation consists of (n - 3) lines. Each line contains 2 integers ai and bi (1 β€ ai, bi β€ n), describing a diagonal ai β bi.
It is guaranteed that both original and goal triangulations are correct (i. e. no two diagonals share a common internal point in both of these triangulations).
Output
First, output an integer k (0 β€ k β€ 20, 000): number of steps.
Then output k lines, each containing 2 integers ai and bi: the endpoints of a diagonal you are going to flip at step i. You may output ai and bi in any order.
If there are several possible solutions, output any of them.
Examples
Input
4
1 3
2 4
Output
1
1 3
Input
6
2 6
3 6
4 6
6 2
5 2
4 2
Output
2
6 3
6 4
Input
8
7 1
2 7
7 3
6 3
4 6
6 1
6 2
6 3
6 4
6 8
Output
3
7 3
7 2
7 1
Note
Sample test 2 is discussed above and shown on the picture.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> v[1010];
int t[1010], ts;
bool bs[1010][1010];
void go(vector<pair<int, int> > &ans, bool esp = 0) {
for (int k = 0; k < n - 3; k++) {
ts = 0;
for (auto i : v[0]) {
t[ts++] = i;
}
for (int i = 0; i < ts - 1; i++)
if (t[i] + 1 != t[i + 1]) {
int aff = 0;
for (int j = 1; j < n; j++)
if (bs[t[i]][j] && bs[t[i + 1]][j]) {
if ((j + 1) % n != t[i] && (t[i] + 1) % n != j) {
bs[t[i]][j] = bs[j][t[i]] = 0;
}
if ((j + 1) % n != t[i + 1] && (t[i + 1] + 1) % n != j) {
bs[t[i + 1]][j] = bs[j][t[i + 1]] = 0;
}
bs[t[i]][t[i + 1]] = bs[t[i + 1]][t[i]] = 0;
bs[0][j] = bs[j][0] = 1;
v[0].insert(j);
aff = j;
break;
}
if (esp)
ans.push_back(make_pair(0, aff));
else
ans.push_back(make_pair(t[i], t[i + 1]));
break;
}
}
}
int main() {
scanf("%d", &n);
memset(bs, 0, sizeof bs);
for (int i = 0; i < n; i++) v[i].clear();
for (int i = 0; i < n; i++) {
v[i].insert((i + 1) % n);
v[(i + 1) % n].insert(i);
bs[i][(i + 1) % n] = 1;
bs[(i + 1) % n][i] = 1;
}
for (int i = 0; i < n - 3; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
v[a].insert(b);
v[b].insert(a);
bs[a][b] = bs[b][a] = 1;
}
vector<pair<int, int> > ans1 = vector<pair<int, int> >();
go(ans1);
memset(bs, 0, sizeof bs);
for (int i = 0; i < n; i++) v[i].clear();
for (int i = 0; i < n; i++) {
v[i].insert((i + 1) % n);
v[(i + 1) % n].insert(i);
bs[i][(i + 1) % n] = 1;
bs[(i + 1) % n][i] = 1;
}
for (int i = 0; i < n - 3; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
v[a].insert(b);
v[b].insert(a);
bs[a][b] = bs[b][a] = 1;
}
vector<pair<int, int> > ans2 = vector<pair<int, int> >();
go(ans2, 1);
reverse(ans2.begin(), ans2.end());
printf("%d\n", ans1.size() + ans2.size());
for (int i = 0; i < ans1.size(); i++)
printf("%d %d\n", ans1[i].first + 1, ans1[i].second + 1);
for (int i = 0; i < ans2.size(); i++)
printf("%d %d\n", ans2[i].first + 1, ans2[i].second + 1);
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
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 int N = 2e5, yzh = 1e9 + 7;
int x, n, k, inv[N + 5];
int quick_pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1ll * ans * a % yzh;
a = 1ll * a * a % yzh, b >>= 1;
}
return ans;
}
int S(int n, int m) {
int ans = 0;
for (int i = 0; i <= m; i++) {
int t = 1ll * inv[i] * inv[m - i] % yzh * quick_pow(m - i, n) % yzh;
if (i & 1)
(ans -= t) %= yzh;
else
(ans += t) %= yzh;
}
return ans;
}
void work() {
scanf("%d%d", &n, &k);
inv[0] = inv[1] = 1;
for (int i = 2; i <= k; i++) inv[i] = -1ll * yzh / i * inv[yzh % i] % yzh;
for (int i = 1; i <= k; i++) inv[i] = 1ll * inv[i - 1] * inv[i] % yzh;
int sum = 0;
for (int i = 1; i <= n; i++) scanf("%d", &x), (sum += x) %= yzh;
int ans = (S(n - 1, k - 1) + 1ll * (n + k - 1) * S(n - 1, k) % yzh) % yzh;
ans = 1ll * ans * sum % yzh;
printf("%d\n", (ans + yzh) % yzh);
}
int main() {
work();
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given n switches and m lamps. The i-th switch turns on some subset of the lamps. This information is given as the matrix a consisting of n rows and m columns where ai, j = 1 if the i-th switch turns on the j-th lamp and ai, j = 0 if the i-th switch is not connected to the j-th lamp.
Initially all m lamps are turned off.
Switches change state only from "off" to "on". It means that if you press two or more switches connected to the same lamp then the lamp will be turned on after any of this switches is pressed and will remain its state even if any switch connected to this lamp is pressed afterwards.
It is guaranteed that if you push all n switches then all m lamps will be turned on.
Your think that you have too many switches and you would like to ignore one of them.
Your task is to say if there exists such a switch that if you will ignore (not use) it but press all the other n - 1 switches then all the m lamps will be turned on.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 2000) β the number of the switches and the number of the lamps.
The following n lines contain m characters each. The character ai, j is equal to '1' if the i-th switch turns on the j-th lamp and '0' otherwise.
It is guaranteed that if you press all n switches all m lamps will be turned on.
Output
Print "YES" if there is a switch that if you will ignore it and press all the other n - 1 switches then all m lamps will be turned on. Print "NO" if there is no such switch.
Examples
Input
4 5
10101
01000
00111
10000
Output
YES
Input
4 5
10100
01000
00110
00101
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 * 1000 + 100;
const long long mod = 1e9 + 7;
const long long inf = 2 * 1e18;
const int delta = 10691;
long long pw(long long a, long long b, long long c = mod) {
if (b == 0) return 1;
long long ans = pw(a, b / 2, c);
ans = (ans * ans) % c;
if (b & 1) ans = (ans * a) % c;
return ans;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
return (b == 0 ? a : gcd(a % b, b));
}
long long n, m;
char a[2001][2001];
int c[2001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) c[j] += a[i][j] - '0';
}
for (int i = 1; i <= n; i++) {
bool t = true;
for (int j = 1; j <= m; j++) {
if (a[i][j] == '1') {
t &= (c[j] > 1);
}
}
if (t) cout << "YES", exit(0);
}
cout << "NO";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You have array a1, a2, ..., an. Segment [l, r] (1 β€ l β€ r β€ n) is good if ai = ai - 1 + ai - 2, for all i (l + 2 β€ i β€ r).
Let's define len([l, r]) = r - l + 1, len([l, r]) is the length of the segment [l, r]. Segment [l1, r1], is longer than segment [l2, r2], if len([l1, r1]) > len([l2, r2]).
Your task is to find a good segment of the maximum length in array a. Note that a segment of length 1 or 2 is always good.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains integers: a1, a2, ..., an (0 β€ ai β€ 109).
Output
Print the length of the longest good segment in array a.
Examples
Input
10
1 2 3 5 8 13 21 34 55 89
Output
10
Input
5
1 1 1 1 1
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100005], i, j, m, n, ans = 0, pos = 1;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 3; i <= n;) {
if (a[i] == a[i - 1] + a[i - 2]) {
while (a[i] == a[i - 1] + a[i - 2] && i <= n) {
i++;
}
ans = max(i - pos, ans);
pos = i - 2;
} else
i++, pos = i - 2;
}
cout << max(ans, min(n, 2));
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given an array a_1, a_2, ..., a_n of integer numbers.
Your task is to divide the array into the maximum number of segments in such a way that:
* each element is contained in exactly one segment;
* each segment contains at least one element;
* there doesn't exist a non-empty subset of segments such that bitwise XOR of the numbers from them is equal to 0.
Print the maximum number of segments the array can be divided into. Print -1 if no suitable division exists.
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 10^9).
Output
Print the maximum number of segments the array can be divided into while following the given constraints. Print -1 if no suitable division exists.
Examples
Input
4
5 5 7 2
Output
2
Input
3
1 2 3
Output
-1
Input
3
3 1 10
Output
3
Note
In the first example 2 is the maximum number. If you divide the array into \{[5], [5, 7, 2]\}, the XOR value of the subset of only the second segment is 5 β 7 β 2 = 0. \{[5, 5], [7, 2]\} has the value of the subset of only the first segment being 5 β 5 = 0. However, \{[5, 5, 7], [2]\} will lead to subsets \{[5, 5, 7]\} of XOR 7, \{[2]\} of XOR 2 and \{[5, 5, 7], [2]\} of XOR 5 β 5 β 7 β 2 = 5.
Let's take a look at some division on 3 segments β \{[5], [5, 7], [2]\}. It will produce subsets:
* \{[5]\}, XOR 5;
* \{[5, 7]\}, XOR 2;
* \{[5], [5, 7]\}, XOR 7;
* \{[2]\}, XOR 2;
* \{[5], [2]\}, XOR 7;
* \{[5, 7], [2]\}, XOR 0;
* \{[5], [5, 7], [2]\}, XOR 5;
As you can see, subset \{[5, 7], [2]\} has its XOR equal to 0, which is unacceptable. You can check that for other divisions of size 3 or 4, non-empty subset with 0 XOR always exists.
The second example has no suitable divisions.
The third example array can be divided into \{[3], [1], [10]\}. No subset of these segments has its XOR equal to 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> basis;
void add(int x) {
for (int& a : basis)
if (a & -a & x) x ^= a;
if (x == 0) return;
for (int& a : basis)
if (x & -x & a) a ^= x;
basis.emplace_back(x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x = 0;
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
add(x ^= a);
}
if (x)
cout << basis.size();
else
cout << "-1";
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
There are n cities in Westeros. The i-th city is inhabited by ai people. Daenerys and Stannis play the following game: in one single move, a player chooses a certain town and burns it to the ground. Thus all its residents, sadly, die. Stannis starts the game. The game ends when Westeros has exactly k cities left.
The prophecy says that if the total number of surviving residents is even, then Daenerys wins: Stannis gets beheaded, and Daenerys rises on the Iron Throne. If the total number of surviving residents is odd, Stannis wins and everything goes in the completely opposite way.
Lord Petyr Baelish wants to know which candidates to the throne he should support, and therefore he wonders, which one of them has a winning strategy. Answer to this question of Lord Baelish and maybe you will become the next Lord of Harrenholl.
Input
The first line contains two positive space-separated integers, n and k (1 β€ k β€ n β€ 2Β·105) β the initial number of cities in Westeros and the number of cities at which the game ends.
The second line contains n space-separated positive integers ai (1 β€ ai β€ 106), which represent the population of each city in Westeros.
Output
Print string "Daenerys" (without the quotes), if Daenerys wins and "Stannis" (without the quotes), if Stannis wins.
Examples
Input
3 1
1 2 1
Output
Stannis
Input
3 1
2 2 1
Output
Daenerys
Input
6 3
5 20 12 7 14 101
Output
Stannis
Note
In the first sample Stannis will use his move to burn a city with two people and Daenerys will be forced to burn a city with one resident. The only survivor city will have one resident left, that is, the total sum is odd, and thus Stannis wins.
In the second sample, if Stannis burns a city with two people, Daenerys burns the city with one resident, or vice versa. In any case, the last remaining city will be inhabited by two people, that is, the total sum is even, and hence Daenerys wins.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-8;
const int N = 2e5 + 7;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
int main() {
int n, k, odd = 0, even = 0, x, m;
scanf("%d%d", &n, &k);
m = k;
k = n - k;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
odd += (x % 2 != 0);
even += (x % 2 == 0);
}
int first = k - k / 2, second = k / 2;
if (k & 1) {
if (second >= odd)
cout << "Daenerys" << endl;
else if (second >= even && m % 2 == 0)
cout << "Daenerys" << endl;
else
cout << "Stannis" << endl;
} else {
if (k == 0 && odd % 2 == 1)
cout << "Stannis" << endl;
else if (first >= even && m % 2 != 0)
cout << "Stannis" << endl;
else
cout << "Daenerys" << endl;
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
In this problem you will need to deal with an n Γ m grid graph. The graph's vertices are the nodes of the n Γ m grid. The graph's edges are all the sides and diagonals of the grid's unit squares.
The figure below shows a 3 Γ 5 graph. The black lines are the graph's edges, the colored circles are the graph's vertices. The vertices of the graph are painted on the picture for a reason: the coloring is a correct vertex coloring of the 3 Γ 5 graph into four colors. A graph coloring is correct if and only if each vertex is painted and no two vertices connected by an edge are painted the same color.
<image>
You are given the size of the grid graph n Γ m and the colors of some of its vertices. Find any way how to paint the unpainted vertices of the graph in 4 colors to make the final coloring a correct vertex graph coloring. If there is no such correct vertex coloring, say that the answer doesn't exist.
Input
The first line contains two integers n and m (2 β€ n, m β€ 1000). Each of the next n lines consists of m characters β the given graph. Each character is either Β«0Β», Β«1Β», Β«2Β», Β«3Β», Β«4Β». Character Β«0Β» means that the corresponding vertex is unpainted, otherwise the character means the color of the vertex.
Assume that all the available colors are numbered from 1 to 4.
Output
If there is no way to get correct vertex coloring of the graph, print 0 in a single line. Otherwise print the colored n Γ m graph. Print the graph in the same format as in the input.
If multiple answers exist, print any of them.
Examples
Input
3 5
10101
00020
01000
Output
13131
42424
31313
Input
2 2
00
00
Output
12
34
Input
2 2
11
00
Output
0
Note
The answer to the first sample is shown on the picture (1 β green color, 2 β blue, 3 β dark blue, 4 β pink).
In the second sample there exists 4! answers, each of them is considered correct.
In the third sample two vertices with equal colors are connected. So the correct vertex coloring couldn't be obtained.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[1111][1111], r[1111][1111];
char b[11];
void result() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", r[i][j]);
puts("");
}
}
bool process1() {
int cd1 = 0, cd2 = 1;
for (int i = 1; i <= n; ++i) {
cd2 = 1;
for (int j = 1; j <= m; ++j) r[i][j] = b[cd1 + cd2], cd2 = 3 - cd2;
bool check = 0;
for (int j = 1; j <= m; ++j)
if (s[i][j] != '0' && s[i][j] != r[i][j]) {
check = 1;
break;
}
if (!check) {
cd1 = 2 - cd1;
continue;
}
cd2 = 2;
for (int j = 1; j <= m; ++j) r[i][j] = b[cd1 + cd2], cd2 = 3 - cd2;
check = 0;
for (int j = 1; j <= m; ++j)
if (s[i][j] != '0' && s[i][j] != r[i][j]) {
check = 1;
break;
}
if (check) return 0;
cd1 = 2 - cd1;
}
return 1;
}
bool process2() {
int cd1 = 0, cd2 = 1;
for (int j = 1; j <= m; ++j) {
cd2 = 1;
for (int i = 1; i <= n; ++i) r[i][j] = b[cd1 + cd2], cd2 = 3 - cd2;
bool check = 0;
for (int i = 1; i <= n; ++i)
if (s[i][j] != '0' && s[i][j] != r[i][j]) {
check = 1;
break;
}
if (!check) {
cd1 = 2 - cd1;
continue;
}
cd2 = 2;
for (int i = 1; i <= n; ++i) r[i][j] = b[cd1 + cd2], cd2 = 3 - cd2;
check = 0;
for (int i = 1; i <= n; ++i)
if (s[i][j] != '0' && s[i][j] != r[i][j]) {
check = 1;
break;
}
if (check) return 0;
cd1 = 2 - cd1;
}
return 1;
}
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s\n", s[i] + 1);
}
for (int i = 1; i < 5; ++i) b[i] = '0' + i;
do {
if (process1()) {
result();
return 0;
}
if (process2()) {
result();
return 0;
}
} while (next_permutation(b + 1, b + 5));
cout << '0' << '\n';
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Berland has n cities, the capital is located in city s, and the historic home town of the President is in city t (s β t). The cities are connected by one-way roads, the travel time for each of the road is a positive integer.
Once a year the President visited his historic home town t, for which his motorcade passes along some path from s to t (he always returns on a personal plane). Since the president is a very busy man, he always chooses the path from s to t, along which he will travel the fastest.
The ministry of Roads and Railways wants to learn for each of the road: whether the President will definitely pass through it during his travels, and if not, whether it is possible to repair it so that it would definitely be included in the shortest path from the capital to the historic home town of the President. Obviously, the road can not be repaired so that the travel time on it was less than one. The ministry of Berland, like any other, is interested in maintaining the budget, so it wants to know the minimum cost of repairing the road. Also, it is very fond of accuracy, so it repairs the roads so that the travel time on them is always a positive integer.
Input
The first lines contain four integers n, m, s and t (2 β€ n β€ 105; 1 β€ m β€ 105; 1 β€ s, t β€ n) β the number of cities and roads in Berland, the numbers of the capital and of the Presidents' home town (s β t).
Next m lines contain the roads. Each road is given as a group of three integers ai, bi, li (1 β€ ai, bi β€ n; ai β bi; 1 β€ li β€ 106) β the cities that are connected by the i-th road and the time needed to ride along it. The road is directed from city ai to city bi.
The cities are numbered from 1 to n. Each pair of cities can have multiple roads between them. It is guaranteed that there is a path from s to t along the roads.
Output
Print m lines. The i-th line should contain information about the i-th road (the roads are numbered in the order of appearance in the input).
If the president will definitely ride along it during his travels, the line must contain a single word "YES" (without the quotes).
Otherwise, if the i-th road can be repaired so that the travel time on it remains positive and then president will definitely ride along it, print space-separated word "CAN" (without the quotes), and the minimum cost of repairing.
If we can't make the road be such that president will definitely ride along it, print "NO" (without the quotes).
Examples
Input
6 7 1 6
1 2 2
1 3 10
2 3 7
2 4 8
3 5 3
4 5 2
5 6 1
Output
YES
CAN 2
CAN 1
CAN 1
CAN 1
CAN 1
YES
Input
3 3 1 3
1 2 10
2 3 10
1 3 100
Output
YES
YES
CAN 81
Input
2 2 1 2
1 2 1
1 2 2
Output
YES
NO
Note
The cost of repairing the road is the difference between the time needed to ride along it before and after the repairing.
In the first sample president initially may choose one of the two following ways for a ride: 1 β 2 β 4 β 5 β 6 or 1 β 2 β 3 β 5 β 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 2e18;
vector<pair<pair<int, int>, long long int> > e;
vector<pair<int, long long int> > g[200005], ng[200005], rg[200005];
long long int s[200005], d[200005];
int vs[200005];
int ans[100005];
int in[200005], p[200005], t = 0, m[100005];
int dfs(int u) {
vs[u] = 1;
in[u] = t++;
int dbe = in[u];
for (int i = 0; i < (int)(ng[u].size()); i++) {
int w = ng[u][i].first, index = ng[u][i].second;
if (!vs[w]) {
ans[index] = 1;
m[index] = 1;
p[w] = u;
int be = dfs(w);
if (be == in[w]) {
;
ans[index] = 2;
} else
dbe = min(dbe, be);
} else if (!m[index]) {
ans[index] = 1;
dbe = min(dbe, in[w]);
}
}
return dbe;
}
int main() {
int n, m, start, finish, a, b;
long long int c;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &start);
scanf("%d", &finish);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
scanf("%lld", &c);
g[a].push_back(make_pair(b, c));
rg[b].push_back(make_pair(a, c));
e.push_back(make_pair(make_pair(a, b), c));
}
set<pair<long long int, int> > q;
for (int i = 1; i <= n; i++) {
s[i] = inf;
vs[i] = 0;
}
s[start] = 0;
q.insert(make_pair(s[start], start));
while (!q.empty()) {
int u = (*q.begin()).second;
q.erase(q.begin());
vs[u] = 1;
for (int i = 0; i < (int)(g[u].size()); i++) {
int w = g[u][i].first;
long long int edge = g[u][i].second;
if (s[u] + edge < s[w]) {
s[w] = s[u] + edge;
q.insert(make_pair(s[w], w));
}
}
}
for (int i = 1; i <= n; i++) {
d[i] = inf;
vs[i] = 0;
}
d[finish] = 0;
q.insert(make_pair(d[finish], finish));
while (!q.empty()) {
int u = (*q.begin()).second;
q.erase(q.begin());
vs[u] = 1;
for (int i = 0; i < (int)(rg[u].size()); i++) {
int w = rg[u][i].first;
long long int edge = rg[u][i].second;
if (d[u] + edge < d[w]) {
d[w] = d[u] + edge;
q.insert(make_pair(d[w], w));
}
}
}
for (int i = 0; i < (int)(e.size()); i++) {
a = e[i].first.first, b = e[i].first.second, c = e[i].second;
if (s[a] + c + d[b] == s[finish]) {
ng[a].push_back(make_pair(b, i));
ng[b].push_back(make_pair(a, i));
;
}
}
memset(vs, 0, sizeof(vs));
dfs(start);
for (int i = 0; i < (int)(e.size()); i++) {
if (ans[i] == 2)
cout << "YES" << endl;
else {
a = e[i].first.first, b = e[i].first.second, c = e[i].second;
if (s[a] == inf || d[b] == inf) {
cout << "NO" << endl;
continue;
}
int nw = s[finish] - s[a] - d[b] - 1;
;
if (nw > 0)
cout << "CAN " << c - nw << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Kevin has just recevied his disappointing results on the USA Identification of Cows Olympiad (USAICO) in the form of a binary string of length n. Each character of Kevin's string represents Kevin's score on one of the n questions of the olympiadβ'1' for a correctly identified cow and '0' otherwise.
However, all is not lost. Kevin is a big proponent of alternative thinking and believes that his score, instead of being the sum of his points, should be the length of the longest alternating subsequence of his string. Here, we define an alternating subsequence of a string as a not-necessarily contiguous subsequence where no two consecutive elements are equal. For example, {0, 1, 0, 1}, {1, 0, 1}, and {1, 0, 1, 0} are alternating sequences, while {1, 0, 0} and {0, 1, 0, 1, 1} are not.
Kevin, being the sneaky little puffball that he is, is willing to hack into the USAICO databases to improve his score. In order to be subtle, he decides that he will flip exactly one substringβthat is, take a contiguous non-empty substring of his score and change all '0's in that substring to '1's and vice versa. After such an operation, Kevin wants to know the length of the longest possible alternating subsequence that his string could have.
Input
The first line contains the number of questions on the olympiad n (1 β€ n β€ 100 000).
The following line contains a binary string of length n representing Kevin's results on the USAICO.
Output
Output a single integer, the length of the longest possible alternating subsequence that Kevin can create in his string after flipping a single substring.
Examples
Input
8
10000011
Output
5
Input
2
01
Output
2
Note
In the first sample, Kevin can flip the bolded substring '10000011' and turn his string into '10011011', which has an alternating subsequence of length 5: '10011011'.
In the second sample, Kevin can flip the entire string and still have the same score.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
int n;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
string s;
cin >> s;
int ans = 0;
stack<int> st;
int id = 0;
for (int i = 0; i < n; i++) {
if (st.size() == 0 || st.top() != s[i]) {
st.push(s[i]);
} else {
if (id < 2) {
id++;
st.push(s[i]);
}
}
}
ans += st.size();
cout << ans;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 β€ t β€ 150) β the number of test cases.
Each test case consists of one line containing two integers n and k (1 β€ n β€ 150, 0 β€ k β€ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ds(int x) {
int res = 0;
while (x) {
res += x % 10;
x /= 10;
}
return res;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(15);
if (argc == 2 && atoi(argv[1]) == 123456789)
freopen("d:\\code\\cpp\\contests\\stdin", "r", stdin);
int T;
cin >> T;
for (int(t) = 0; (t) < (T); (t)++) {
int n, k;
cin >> n >> k;
string ans = string(n + 1, '9');
for (int(a) = 0; (a) < (100); (a)++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) s += ds(a + x);
string str = to_string(a);
if (s == n)
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
for (int(a) = 0; (a) < (10); (a)++) {
for (int(tt) = 0; (tt) < ((n + 8) / 9); (tt)++) {
for (int(c) = 0; (c) < (10); (c)++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) {
if (x + c < 10)
s += a + tt * 9 + c + x;
else
s += ds(a + 1) + c + x - 10;
}
if (s == n) {
string str =
string(1, a + '0') + string(tt, '9') + string(1, c + '0');
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
}
for (int c = 10; c < 100; c++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) {
if (x + c < 100)
s += a + tt * 9 + ds(c + x);
else
s += ds(a + 1) + ds(c + x - 100);
}
if (s == n) {
string str = string(1, a + '0') + string(tt, '9') + to_string(c);
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
}
}
}
if (ans[0] == '0' && ans.length() > 1) ans = ans.substr(1);
if (ans.length() == n + 1)
cout << -1 << endl;
else
cout << ans << endl;
}
if (argc == 2 && atoi(argv[1]) == 123456789)
cout << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Polycarp found n segments on the street. A segment with the index i is described by two integers l_i and r_i β coordinates of the beginning and end of the segment, respectively. Polycarp realized that he didn't need all the segments, so he wanted to delete some of them.
Polycarp believes that a set of k segments is good if there is a segment [l_i, r_i] (1 β€ i β€ k) from the set, such that it intersects every segment from the set (the intersection must be a point or segment). For example, a set of 3 segments [[1, 4], [2, 3], [3, 6]] is good, since the segment [2, 3] intersects each segment from the set. Set of 4 segments [[1, 2], [2, 3], [3, 5], [4, 5]] is not good.
Polycarp wonders, what is the minimum number of segments he has to delete so that the remaining segments form a good set?
Input
The first line contains a single integer t (1 β€ t β€ 2 β
10^5) β number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of segments. This is followed by n lines describing the segments.
Each segment is described by two integers l and r (1 β€ l β€ r β€ 10^9) β coordinates of the beginning and end of the segment, respectively.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case, output a single integer β the minimum number of segments that need to be deleted in order for the set of remaining segments to become good.
Example
Input
4
3
1 4
2 3
3 6
4
1 2
2 3
3 5
4 5
5
1 2
3 8
4 5
6 7
9 10
5
1 5
2 4
3 5
3 8
4 8
Output
0
1
2
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define fastio() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#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")
#define ll long long
#define int long long
#define ld long double
#define endl "\n"
#define pb push_back
#define fill(a,val) memset(a,val,sizeof(a))
#define ff first
#define ss second
#define test ll t; cin>>t; while(t--)
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define loopr(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<ll,ll>
#define all(v) v.begin(),v.end()
const ll mod = 1000*1000*1000+7;
const ll inf = 1ll*1000*1000*1000*1000*1000*1000 + 7;
const ll mod2 = 998244353;
const ll N = 1000 + 10;
const ld pi = 3.141592653589793;
ll power(ll x,ll y,ll p = LLONG_MAX ){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
void solve(){
ll n;
cin>>n;
pii p[n];
ll l[n],r[n];
loop(i,0,n){
cin>>p[i].ff>>p[i].ss;
l[i]=p[i].ff;
r[i]=p[i].ss;
}
sort(l,l+n);
sort(r,r+n);
ll ans=LLONG_MAX;
for(ll i=0;i<n;i++){
ll cnt=0;
// for(ll j=0;j<n;j++){
// if(p[j].ff>r || p[j].ss<l){
// continue;
// }
// cnt++;
// }
auto it=upper_bound(l,l+n,p[i].ss)-l;
cnt+=n-it;
auto it2=lower_bound(r,r+n,p[i].ff)-r;
cnt+=it2;
ans=min(ans,cnt);
}
cout<<ans<<endl;
return;
}
signed main(){
fastio();
test{
solve();
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Vasya plays the Need For Brake. He plays because he was presented with a new computer wheel for birthday! Now he is sure that he will win the first place in the championship in his favourite racing computer game!
n racers take part in the championship, which consists of a number of races. After each race racers are arranged from place first to n-th (no two racers share the same place) and first m places are awarded. Racer gains bi points for i-th awarded place, which are added to total points, obtained by him for previous races. It is known that current summary score of racer i is ai points. In the final standings of championship all the racers will be sorted in descending order of points. Racers with an equal amount of points are sorted by increasing of the name in lexicographical order.
Unfortunately, the championship has come to an end, and there is only one race left. Vasya decided to find out what the highest and lowest place he can take up as a result of the championship.
Input
The first line contains number n (1 β€ n β€ 105) β number of racers. Each of the next n lines contains si and ai β nick of the racer (nonempty string, which consist of no more than 20 lowercase Latin letters) and the racer's points (0 β€ ai β€ 106). Racers are given in the arbitrary order.
The next line contains the number m (0 β€ m β€ n). Then m nonnegative integer numbers bi follow. i-th number is equal to amount of points for the i-th awarded place (0 β€ bi β€ 106).
The last line contains Vasya's racer nick.
Output
Output two numbers β the highest and the lowest place Vasya can take up as a result of the championship.
Examples
Input
3
teama 10
teamb 20
teamc 40
2
10 20
teama
Output
2 3
Input
2
teama 10
teamb 10
2
10 10
teamb
Output
2 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
string nick[MAX];
int ara[MAX], ord[MAX], b[MAX];
int save[MAX];
bool cmp(int a, int b) {
if (ara[a] == ara[b]) return nick[a] < nick[b];
return ara[a] > ara[b];
}
deque<int> D;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
if (n == 0) {
cout << 0 << " " << 0 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> nick[i] >> ara[i];
save[i] = ara[i];
}
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i], D.push_back(b[i]);
sort(D.begin(), D.end());
string s;
cin >> s;
int id = -1;
for (int i = 1; i <= n; i++) {
if (s == nick[i]) {
if (id == -1)
id = i;
else
assert(false);
}
}
for (int i = 1; i <= n; i++) ord[i] = i;
sort(ord + 1, ord + n + 1, cmp);
int ans1, ans2;
if (m == 0) {
for (int i = 1; i <= n; i++)
if (ord[i] == id) {
ans2 = ans1 = i;
break;
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
int cur;
for (int i = 1; i <= n; i++)
if (ord[i] == id) cur = i;
if (n == m) {
ara[id] += D.front();
D.pop_front();
}
int parbo = n - cur;
int bad = D.size() - parbo;
for (int i = cur - 1; i >= 1 and bad > 0; i--, bad--) {
ara[ord[i]] += D.front();
D.pop_front();
}
int need;
for (int i = cur + 1; i <= n; i++) {
need = (ara[id] + 1) - ara[ord[i]];
int paic = 0;
while (D.size() > 0) {
if (D.front() >= need) {
paic = D.front();
D.pop_front();
break;
} else
D.pop_front();
}
ara[ord[i]] += paic;
}
sort(ord + 1, ord + n + 1, cmp);
for (int i = 1; i <= n; i++)
if (ord[i] == id) ans2 = i;
for (int i = 1; i <= n; i++) ara[i] = save[i];
D.clear();
for (int i = 1; i <= m; i++) D.push_back(b[i]);
sort(D.begin(), D.end());
ara[id] += D.back();
D.pop_back();
sort(ord + 1, ord + n + 1, cmp);
for (int i = n; i >= 1 and D.size() > 0; i--) {
if (ord[i] == id) continue;
ara[ord[i]] += D.back();
D.pop_back();
}
sort(ord + 1, ord + n + 1, cmp);
for (int i = 1; i <= n; i++)
if (ord[i] == id) ans1 = i;
cout << ans1 << " " << ans2 << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You have a positive integer m and a non-negative integer s. Your task is to find the smallest and the largest of the numbers that have length m and sum of digits s. The required numbers should be non-negative integers written in the decimal base without leading zeroes.
Input
The single line of the input contains a pair of integers m, s (1 β€ m β€ 100, 0 β€ s β€ 900) β the length and the sum of the digits of the required numbers.
Output
In the output print the pair of the required non-negative integer numbers β first the minimum possible number, then β the maximum possible number. If no numbers satisfying conditions required exist, print the pair of numbers "-1 -1" (without the quotes).
Examples
Input
2 15
Output
69 96
Input
3 0
Output
-1 -1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
if ((n > 1 && s == 0) || (s > 9 * n))
cout << "-1"
<< " "
<< "-1" << endl;
else if (n == 1 && s == 0)
cout << '0' << " " << '0';
else {
string str = "", r = "", t = "";
int x = s / 9;
int y = s % 9;
for (int i = 0; i < x; i++) {
str += '9';
}
if (x < n) {
str += char(y + 48);
for (int i = x + 1; i < n; i++) str += '0';
}
for (int i = 0; i < x; i++) {
r += '9';
}
if (x < n) {
r += char(y + 48);
for (int i = x + 1; i < n; i++) {
r += '0';
}
}
if (r[n - 1] == '0') {
if (r[x] == '0') {
r[x - 1] = '8';
r[n - 1] = '1';
} else {
r[x] = char((y - 1) + 48);
r[n - 1] = '1';
}
}
reverse(r.begin(), r.end());
cout << r << " " << str;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their teamβs strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each personβs teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 β€ n β€ 400) β the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 β€ aij β€ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, pair<int, int>>> v;
int fri[1000];
bool taken[1000];
int main() {
cin >> n;
for (int i = 2; i <= 2 * n; i++) {
for (int j = 1; j <= i - 1; j++) {
int x;
cin >> x;
v.push_back({x, {i, j}});
}
}
sort(v.rbegin(), v.rend());
for (int i = 0; i < (int)v.size(); i++) {
int p1 = v[i].second.first, p2 = v[i].second.second;
if (!taken[p1] and !taken[p2]) {
fri[p1] = p2;
fri[p2] = p1;
taken[p1] = taken[p2] = 1;
}
}
for (int i = 1; i <= 2 * n; i++) cout << fri[i] << ' ';
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi has a deposit of 100 yen (the currency of Japan) in AtCoder Bank.
The bank pays an annual interest rate of 1 % compounded annually. (A fraction of less than one yen is discarded.)
Assuming that nothing other than the interest affects Takahashi's balance, in how many years does the balance reach X yen or above for the first time?
Constraints
* 101 \le X \le 10^{18}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X
Output
Print the number of years it takes for Takahashi's balance to reach X yen or above for the first time.
Examples
Input
103
Output
3
Input
1000000000000000000
Output
3760
Input
1333333333
Output
1706
### Response
```cpp
#include<iostream>
using namespace std;
int main() {
long X;
cin >> X;
int ans = 0;
for (long x = 100; x < X; x += x / 100, ans++);
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given two integers a and b. Moreover, you are given a sequence s_0, s_1, ..., s_{n}. All values in s are integers 1 or -1. It's known that sequence is k-periodic and k divides n+1. In other words, for each k β€ i β€ n it's satisfied that s_{i} = s_{i - k}.
Find out the non-negative remainder of division of β _{i=0}^{n} s_{i} a^{n - i} b^{i} by 10^{9} + 9.
Note that the modulo is unusual!
Input
The first line contains four integers n, a, b and k (1 β€ n β€ 10^{9}, 1 β€ a, b β€ 10^{9}, 1 β€ k β€ 10^{5}).
The second line contains a sequence of length k consisting of characters '+' and '-'.
If the i-th character (0-indexed) is '+', then s_{i} = 1, otherwise s_{i} = -1.
Note that only the first k members of the sequence are given, the rest can be obtained using the periodicity property.
Output
Output a single integer β value of given expression modulo 10^{9} + 9.
Examples
Input
2 2 3 3
+-+
Output
7
Input
4 1 5 1
-
Output
999999228
Note
In the first example:
(β _{i=0}^{n} s_{i} a^{n - i} b^{i}) = 2^{2} 3^{0} - 2^{1} 3^{1} + 2^{0} 3^{2} = 7
In the second example:
(β _{i=0}^{n} s_{i} a^{n - i} b^{i}) = -1^{4} 5^{0} - 1^{3} 5^{1} - 1^{2} 5^{2} - 1^{1} 5^{3} - 1^{0} 5^{4} = -781 β‘ 999999228 \pmod{10^{9} + 9}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int vv[65];
inline int ksm(int p, int k) {
vv[0] = p;
for (int i = 1; i <= 29; ++i)
vv[i] = (long long)vv[i - 1] * vv[i - 1] % 1000000009;
int s = 1;
for (int i = 29; i >= 0; --i) {
if (1 << i <= k) {
k -= 1 << i;
s = (long long)s * vv[i] % 1000000009;
}
}
return s;
}
long long ll, a_, b_, s, l, ans, q, n, a, b, k;
char ss[1000050];
long long aa[1000050];
inline void upt(long long &a, long long b) { a = (a + b) % 1000000009; }
int main() {
scanf("%lld%lld%lld%lld", &n, &a, &b, &k);
scanf("%s", ss + 1);
for (int i = 1; i <= k; ++i)
if (ss[i] == '+')
aa[i - 1] = 1;
else
aa[i - 1] = 1000000009 - 1;
for (int i = 0; i < k; ++i)
upt(s, aa[i] * ksm(a, n - i) % 1000000009 * ksm(b, i) % 1000000009);
a_ = ksm(a, k);
b_ = ksm(b, k);
q = b_ * ksm(a_, 1000000009 - 2) % 1000000009;
if (q == 1) {
l = (n + 1) / k;
s = s * l % 1000000009;
cout << s;
return 0;
}
l = (n + 1) / k;
ans = (ksm(q, l) + 1000000009 - 1) % 1000000009;
ans = ans * ksm(q + 1000000009 - 1, 1000000009 - 2) % 1000000009;
ans = ans * s % 1000000009;
cout << ans;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Fox Ciel has a board with n rows and n columns, there is one integer in each cell.
It's known that n is an odd number, so let's introduce <image>. Fox Ciel can do the following operation many times: she choose a sub-board with size x rows and x columns, then all numbers in it will be multiplied by -1.
Return the maximal sum of numbers in the board that she can get by these operations.
Input
The first line contains an integer n, (1 β€ n β€ 33, and n is an odd integer) β the size of the board.
Each of the next n lines contains n integers β the numbers in the board. Each number doesn't exceed 1000 by its absolute value.
Output
Output a single integer: the maximal sum of numbers in the board that can be accomplished.
Examples
Input
3
-1 -1 1
-1 1 -1
1 -1 -1
Output
9
Input
5
-2 0 0 0 -2
0 -2 0 -2 0
0 0 -2 0 0
0 -2 0 -2 0
-2 0 0 0 -2
Output
18
Note
In the first test, we can apply this operation twice: first on the top left 2 Γ 2 sub-board, then on the bottom right 2 Γ 2 sub-board. Then all numbers will become positive.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 35;
int a[N][N];
int m, n, x, X;
int best;
int up(int x, int y) {
x = x ^ y;
return x == 0 ? 1 : -1;
}
int bit(int p, int v) { return (p >> v) & 1; }
void check(int p) {
int ans = 0;
int tmp0, tmp1;
int tmp00, tmp01, tmp10, tmp11;
int c00, c01, c10, c11;
int r0, r1;
for (int i = 0; i < x; ++i)
if (bit(p, i))
ans += -a[i][m];
else
ans += a[i][m];
for (int i = x; i < n; ++i) ans += a[i][m] * up(bit(p, i - x), bit(p, m));
c00 = up(0, 0);
c01 = up(0, 1);
c10 = up(1, 0);
c11 = up(1, 1);
for (int c = 0; c < m; ++c) {
tmp0 = a[m][c] + up(0, bit(p, m)) * a[m][c + x];
tmp1 = -a[m][c] + up(1, bit(p, m)) * a[m][c + x];
for (int r = 0; r < m; ++r) {
r0 = up(0, bit(p, r));
r1 = up(1, bit(p, r));
tmp00 = a[r][c] + r0 * a[r][c + x] + c00 * a[r + x][c] +
a[r + x][c + x] * up(0 ^ bit(p, m), 0 ^ bit(p, r));
tmp10 = -a[r][c] + r1 * a[r][c + x] + c10 * a[r + x][c] +
a[r + x][c + x] * up(0 ^ bit(p, m), 1 ^ bit(p, r));
tmp01 = a[r][c] + r0 * a[r][c + x] + c01 * a[r + x][c] +
a[r + x][c + x] * up(1 ^ bit(p, m), 0 ^ bit(p, r));
tmp11 = -a[r][c] + r1 * a[r][c + x] + c11 * a[r + x][c] +
a[r + x][c + x] * up(1 ^ bit(p, m), 1 ^ bit(p, r));
tmp0 += max(tmp00, tmp10);
tmp1 += max(tmp01, tmp11);
}
ans += max(tmp0, tmp1);
}
best = max(best, ans);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j];
x = (n + 1) / 2;
m = x - 1;
best = -(int)1e9;
X = 1 << x;
for (int mask = 0; mask < X; ++mask) check(mask);
cout << best << endl;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Bob has a rectangular chocolate bar of the size W Γ H. He introduced a cartesian coordinate system so that the point (0, 0) corresponds to the lower-left corner of the bar, and the point (W, H) corresponds to the upper-right corner. Bob decided to split the bar into pieces by breaking it. Each break is a segment parallel to one of the coordinate axes, which connects the edges of the bar. More formally, each break goes along the line x = xc or y = yc, where xc and yc are integers. It should divide one part of the bar into two non-empty parts. After Bob breaks some part into two parts, he breaks the resulting parts separately and independently from each other. Also he doesn't move the parts of the bar. Bob made n breaks and wrote them down in his notebook in arbitrary order. At the end he got n + 1 parts. Now he wants to calculate their areas. Bob is lazy, so he asks you to do this task.
Input
The first line contains 3 integers W, H and n (1 β€ W, H, n β€ 100) β width of the bar, height of the bar and amount of breaks. Each of the following n lines contains four integers xi, 1, yi, 1, xi, 2, yi, 2 β coordinates of the endpoints of the i-th break (0 β€ xi, 1 β€ xi, 2 β€ W, 0 β€ yi, 1 β€ yi, 2 β€ H, or xi, 1 = xi, 2, or yi, 1 = yi, 2). Breaks are given in arbitrary order.
It is guaranteed that the set of breaks is correct, i.e. there is some order of the given breaks that each next break divides exactly one part of the bar into two non-empty parts.
Output
Output n + 1 numbers β areas of the resulting parts in the increasing order.
Examples
Input
2 2 2
1 0 1 2
0 1 1 1
Output
1 1 2
Input
2 2 3
1 0 1 2
0 1 1 1
1 1 2 1
Output
1 1 1 1
Input
2 4 2
0 1 2 1
0 3 2 3
Output
2 2 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int w, h, num;
int x[4] = {-1, 0, 1, 0};
int y[4] = {0, 1, 0, -1};
bool visit[105][105] = {0}, g[105][105][4];
vector<int> ans;
void dfs(int n, int m) {
if (n < 0 || n >= w || m < 0 || m >= h || visit[n][m]) return;
visit[n][m] = 1;
num++;
for (int i = 0; i < 4; i++)
if (g[n][m][i]) dfs(n + x[i], m + y[i]);
}
int main(void) {
memset(g, true, sizeof(g));
int n;
cin >> w >> h >> n;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a == c)
for (int i = b; i < d; i++) g[a][i][0] = g[a - 1][i][2] = 0;
else
for (int i = a; i < c; i++) g[i][b][3] = g[i][b - 1][1] = 0;
}
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++)
if (!visit[i][j]) {
num = 0;
dfs(i, j);
ans.push_back(num);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Let's call a positive integer n ordinary if in the decimal notation all its digits are the same. For example, 1, 2 and 99 are ordinary numbers, but 719 and 2021 are not ordinary numbers.
For a given number n, find the number of ordinary numbers among the numbers from 1 to n.
Input
The first line contains one integer t (1 β€ t β€ 10^4). Then t test cases follow.
Each test case is characterized by one integer n (1 β€ n β€ 10^9).
Output
For each test case output the number of ordinary numbers among numbers from 1 to n.
Example
Input
6
1
2
3
4
5
100
Output
1
2
3
4
5
18
### Response
```cpp
#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
#define fastio ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
//#define printclock cerr<<"Time : "<<1000*(ld)clock()/(ld)CLOCKS_PER_SEC<<"ms\n"
#define ll long long int
#define ld long double
#define ull unsigned long long
#define li long int
#define str string
#define fr(i,n) for(ll i = 0; i<n; i++)
int main() {
fastio;
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
if(n<10){
cout<<n<<endl;
}
else{
ll p=n;
int count=0,a=0;
while(p!=0){
int rem=p%10;
count++;
if(p<10){
a=rem;
}
p=p/10;
}
ll temp = 0;
for(int i=0;i<count;i++){
temp+=a*pow(10,i);
}
//cout<<temp<<endl;
if(n>=temp){
cout<<(9*(count-1) + a)<<endl;
}
else
cout<<(9*(count-1) +a -1)<<endl;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
We have sticks numbered 1, \cdots, N. The length of Stick i (1 \leq i \leq N) is L_i.
In how many ways can we choose three of the sticks with different lengths that can form a triangle?
That is, find the number of triples of integers (i, j, k) (1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* L_i, L_j, and L_k are all different.
* There exists a triangle whose sides have lengths L_i, L_j, and L_k.
Constraints
* 1 \leq N \leq 100
* 1 \leq L_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
L_1 L_2 \cdots L_N
Output
Print the number of ways to choose three of the sticks with different lengths that can form a triangle.
Examples
Input
5
4 4 9 7 5
Output
5
Input
6
4 5 4 3 3 5
Output
8
Input
10
9 4 6 1 9 6 10 6 6 8
Output
39
Input
2
1 1
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<long> v(n);
for(int i=0;i<n;i++) cin>>v[i];
long cnt=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
for(int k=j+1;k<n;k++){
if(v[i]!=v[j]&&v[j]!=v[k]&&v[k]!=v[i]){
long M=max(v[i],max(v[j],v[k]));
if(v[i]+v[j]+v[k]>2*M) cnt++;
}
}
}
}
cout<<cnt;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Little Petya likes points a lot. Recently his mom has presented him n points lying on the line OX. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two farthest of them doesn't exceed d.
Note that the order of the points inside the group of three chosen points doesn't matter.
Input
The first line contains two integers: n and d (1 β€ n β€ 105; 1 β€ d β€ 109). The next line contains n integers x1, x2, ..., xn, their absolute value doesn't exceed 109 β the x-coordinates of the points that Petya has got.
It is guaranteed that the coordinates of the points in the input strictly increase.
Output
Print a single integer β the number of groups of three points, where the distance between two farthest points doesn't exceed d.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 3
1 2 3 4
Output
4
Input
4 2
-3 -2 -1 0
Output
2
Input
5 19
1 10 20 30 50
Output
1
Note
In the first sample any group of three points meets our conditions.
In the seconds sample only 2 groups of three points meet our conditions: {-3, -2, -1} and {-2, -1, 0}.
In the third sample only one group does: {1, 10, 20}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e9 + 7;
const double pie = 3.14159265358979323846;
const char nl = '\n';
const char spc = ' ';
template <typename Type>
istream &operator>>(istream &in, vector<Type> &v) {
long long int n = v.size();
for (int i = 0; i < n; i++) in >> v[i];
return in;
}
template <typename Type>
ostream &operator<<(ostream &out, vector<Type> &v) {
for (auto value : v) out << value << ' ';
out << nl;
return out;
}
bool isPrime(long long int n) {
if (n < 4) return true;
if (n % 2 == 0) return false;
long long int i = 3;
while (i * i <= n) {
if (n % i == 0) return false;
i += 2;
}
return true;
}
void solve() {
long long int n, d;
cin >> n >> d;
vector<long long int> a(n);
cin >> a;
long long int c = 0, l = 0;
for (long long int r = 0; r < n; ++r) {
while (a[r] - a[l] > d) ++l;
long long int len = r - l;
c += len * (len - 1) / 2;
}
cout << c << nl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
To your surprise, Jamie is the final boss! Ehehehe.
Jamie has given you a tree with n vertices, numbered from 1 to n. Initially, the root of the tree is the vertex with number 1. Also, each vertex has a value on it.
Jamie also gives you three types of queries on the tree:
1 v β Change the tree's root to vertex with number v.
2 u v x β For each vertex in the subtree of smallest size that contains u and v, add x to its value.
3 v β Find sum of values of vertices in the subtree of vertex with number v.
A subtree of vertex v is a set of vertices such that v lies on shortest path from this vertex to root of the tree. Pay attention that subtree of a vertex can change after changing the tree's root.
Show your strength in programming to Jamie by performing the queries accurately!
Input
The first line of input contains two space-separated integers n and q (1 β€ n β€ 105, 1 β€ q β€ 105) β the number of vertices in the tree and the number of queries to process respectively.
The second line contains n space-separated integers a1, a2, ..., an ( - 108 β€ ai β€ 108) β initial values of the vertices.
Next n - 1 lines contains two space-separated integers ui, vi (1 β€ ui, vi β€ n) describing edge between vertices ui and vi in the tree.
The following q lines describe the queries.
Each query has one of following formats depending on its type:
1 v (1 β€ v β€ n) for queries of the first type.
2 u v x (1 β€ u, v β€ n, - 108 β€ x β€ 108) for queries of the second type.
3 v (1 β€ v β€ n) for queries of the third type.
All numbers in queries' descriptions are integers.
The queries must be carried out in the given order. It is guaranteed that the tree is valid.
Output
For each query of the third type, output the required answer. It is guaranteed that at least one query of the third type is given by Jamie.
Examples
Input
6 7
1 4 2 8 5 7
1 2
3 1
4 3
4 5
3 6
3 1
2 4 6 3
3 4
1 6
2 2 4 -5
1 4
3 3
Output
27
19
5
Input
4 6
4 3 5 6
1 2
2 3
3 4
3 1
1 3
2 2 4 3
1 1
2 2 4 -3
3 1
Output
18
21
Note
The following picture shows how the tree varies after the queries in the first sample.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, q, opt, x, y, z, aa, bb, cc,
cap = 1, cnt, tot, out, fh, a[100010], at[100010], h[100010], dep[100010],
size[100010], dad[100010], son[100010], id[100010], top[100010],
fa[100010][18];
char c;
struct Edge {
int next, to;
} e[200010];
struct SegT {
long long s, l;
} t[400010];
int read() {
out = 0, fh = 1, c = getchar();
while (c < 48 || c > 57) {
if (c == 45) {
fh = -1;
}
c = getchar();
}
while (c >= 48 && c <= 57) {
out = (out << 3) + (out << 1) + (c & 15), c = getchar();
}
return out * fh;
}
void Add(int x, int y) { e[++cnt].next = h[x], e[cnt].to = y, h[x] = cnt; }
void DFS1(int x) {
dep[x] = dep[dad[x]] + 1, size[x] = 1;
for (int i = h[x]; i; i = e[i].next) {
int y = e[i].to;
if (y ^ dad[x]) {
dad[y] = x, fa[y][0] = x;
DFS1(y);
size[x] += size[y];
if (size[son[x]] < size[y]) {
son[x] = y;
}
}
}
}
void DFS2(int x) {
id[x] = ++tot, at[tot] = a[x], top[x] = x == son[dad[x]] ? top[dad[x]] : x;
for (int i = 1; i <= 17; ++i) {
fa[x][i] = fa[fa[x][i - 1]][i - 1];
}
if (!son[x]) {
return;
}
DFS2(son[x]);
for (int i = h[x]; i; i = e[i].next) {
int y = e[i].to;
if (y ^ dad[x] && y ^ son[x]) {
DFS2(y);
}
}
}
void DFS(int x) {
DFS1(x);
DFS2(x);
}
void Pushup(int k) { t[k].s = t[k << 1].s + t[k << 1 | 1].s; }
void Pushdown(int k, int l, int r) {
if (!t[k].l) {
return;
}
int mid = l + r >> 1;
t[k << 1].l += t[k].l, t[k << 1 | 1].l += t[k].l,
t[k << 1].s += t[k].l * (mid - l + 1),
t[k << 1 | 1].s += t[k].l * (r - mid), t[k].l = 0;
}
void Build(int k, int l, int r) {
if (l == r) {
t[k].s = at[l];
return;
}
int mid = l + r >> 1;
Build(k << 1, l, mid);
Build(k << 1 | 1, mid + 1, r);
Pushup(k);
}
void Change(int k, int l, int r, int ll, int rr, long long x) {
if (r < ll || rr < l) {
return;
}
if (ll <= l && r <= rr) {
t[k].s += x * (r - l + 1), t[k].l += x;
return;
}
Pushdown(k, l, r);
int mid = l + r >> 1;
Change(k << 1, l, mid, ll, rr, x);
Change(k << 1 | 1, mid + 1, r, ll, rr, x);
Pushup(k);
}
long long Query(int k, int l, int r, int ll, int rr) {
if (r < ll || rr < l) {
return 0;
}
if (ll <= l && r <= rr) {
return t[k].s;
}
Pushdown(k, l, r);
int mid = l + r >> 1;
return Query(k << 1, l, mid, ll, rr) + Query(k << 1 | 1, mid + 1, r, ll, rr);
}
int LCA(int x, int y) {
while (top[x] ^ top[y]) {
if (dep[top[x]] < dep[top[y]]) {
x ^= y ^= x ^= y;
}
x = dad[top[x]];
}
return dep[x] > dep[y] ? y : x;
}
int Son(int x, int p) {
for (int i = 0; i <= 17; ++i) {
if (p & 1) {
x = fa[x][i];
}
p >>= 1;
}
return x;
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
}
for (int i = 1; i < n; ++i) {
x = read(), y = read();
Add(x, y);
Add(y, x);
}
DFS(1);
Build(1, 1, n);
while (q--) {
opt = read();
if (opt == 1) {
cap = read();
}
if (opt == 2) {
x = read(), y = read(), z = read(), aa = LCA(x, y), bb = LCA(x, cap),
cc = LCA(y, cap),
x = dep[aa] > dep[bb] ? dep[aa] > dep[cc] ? aa : cc
: dep[bb] > dep[cc] ? bb
: cc;
if (x == cap) {
Change(1, 1, n, 1, n, z);
} else {
if (id[x] < id[cap] && id[x] + size[x] > id[cap]) {
x = Son(cap, dep[cap] - dep[x] - 1);
Change(1, 1, n, 1, id[x] - 1, z);
Change(1, 1, n, id[x] + size[x], n, z);
} else {
Change(1, 1, n, id[x], id[x] + size[x] - 1, z);
}
}
}
if (opt == 3) {
x = read();
if (x == cap) {
printf("%lld\n", t[1].s);
} else {
if (id[x] < id[cap] && id[x] + size[x] > id[cap]) {
x = Son(cap, dep[cap] - dep[x] - 1);
printf("%lld\n", t[1].s - Query(1, 1, n, id[x], id[x] + size[x] - 1));
} else {
printf("%lld\n", Query(1, 1, n, id[x], id[x] + size[x] - 1));
}
}
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Xenia the vigorous detective faced n (n β₯ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 β€ li β€ ri β€ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 β€ n, m β€ 105; 1 β€ s, f β€ n; s β f; n β₯ 2). Each of the following m lines contains three integers ti, li, ri (1 β€ ti β€ 109, 1 β€ li β€ ri β€ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 110000;
int t[M], l[M], r[M];
char ans[2 * M];
int main() {
int i;
int n, m, s, f;
scanf("%d %d %d %d", &n, &m, &s, &f);
for (i = 0; i < m; i++) scanf("%d %d %d", &t[i], &l[i], &r[i]);
int k = 0, cr = 0, ds;
while (s != f) {
if (s < f)
ds = 1;
else
ds = -1;
int fl = 1;
if (t[cr] - 1 == k) {
if ((l[cr] <= s + ds && r[cr] >= s + ds) || (l[cr] <= s && r[cr] >= s)) {
fl = 0;
ans[k] = 'X';
}
cr++;
}
if (fl) {
if (ds < 0)
ans[k] = 'L';
else
ans[k] = 'R';
s += ds;
}
k++;
}
ans[k] = '\0';
printf("%s\n", ans);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There are 2N points evenly spaced on the circumference of a circle. These points are numbered 1 to 2N in clockwise order, starting from some of them.
Snuke will divide these points into N pairs, then for each pair, he will draw a line segment connecting the two points. After the line segments are drawn, two points are connected when one can reach from one of those points to the other by traveling only on the line segments. The number of the connected parts here is the number of the connected components in the graph with 2N vertices, corresponding to the 2N points, where every pair of vertices corresponding to two connected points is connected with an edge.
Snuke has already decided K of the pairs, and the i-th of them is a pair of Point A_i and Point B_i.
He is thinking of trying all possible ways to make the remaining N-K pairs and counting the number of the connected parts for each of those ways. Find the sum of those numbers of the connected parts. As the answer can be extremely large, compute the sum modulo 10^9+7.
Constraints
* 1 \leq N \leq 300
* 0 \leq K \leq N
* 1 \leq A_i,B_i \leq 2N
* A_1,\ A_2,\ ...\ A_K,\ B_1,\ B_2,\ ...\ B_K are all distinct.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 B_1
A_2 B_2
:
A_K B_K
Output
Print the sum of the numbers of the connected parts for all possible ways to make the remaining N-K pairs.
Examples
Input
2 0
Output
5
Input
4 2
5 2
6 1
Output
6
Input
20 10
10 18
11 17
14 7
4 6
30 28
19 24
29 22
25 32
38 34
36 39
Output
27087418
### Response
```cpp
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=602,M=1000000007;
typedef long long ll;
int n,k,i,j,l,r,x,y,L[N],R[N],cnt[N],num[N][N];
ll g[N],f[N][N],Ans;
bool ok;
void init(){
scanf("%d%d",&n,&k);
n*=2;
for(i=1;i<=k;i++){
scanf("%d%d",L+i,R+i);
if(L[i]>R[i])
swap(L[i],R[i]);
cnt[L[i]]++;
cnt[R[i]]++;
}
for(i=1;i<=n;i++)
cnt[i]=1-cnt[i]+cnt[i-1];
for(l=1;l<=n;l++)
for(r=l;r<=n;r++)
num[l][r]=cnt[r]-cnt[l-1];
}
void work(){
g[0]=1;
for(i=2;i<=n;i++)
g[i]=(i-1)*g[i-2]%M;
for(j=1;j<=n;j+=2)
for(x=1;x+j<=n;x++){
y=x+j;
ok=1;
for(i=1;i<=k&&ok;i++){
if(L[i]<x&&x<=R[i]&&R[i]<=y)
ok=0;
if(x<=L[i]&&L[i]<=y&&y<R[i])
ok=0;
}
if(ok){
f[x][y]=g[num[x][y]];
for(i=x+1;i<y;i+=2)
f[x][y]=(f[x][y]-f[x][i]*g[num[i+1][y]])%M;
}
Ans=(Ans+f[x][y]*g[num[1][x-1]+num[y+1][n]])%M;
}
printf("%lld",(Ans+M)%M);
}
int main(){
init();
work();
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA β AABBA β AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 β€ t β€ 20000) β the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 β
10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA β BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB β AABBBABB β AABBBB β ABBB β AB β (empty string). So, the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int MOD = 1e9 + 7;
void solve() {
string s;
cin >> s;
int n = int(s.size());
int b = 0, ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'B')
++b;
else {
if (b > 0) {
--b;
} else {
ans++;
ans += b % 2;
b = 0;
}
}
}
if (b > 0) ans += b % 2;
cout << ans << endl;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tt = 1;
cin >> tt;
for (int tc = 1; tc <= tt; tc++) {
solve();
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Vus the Cossack has two binary strings, that is, strings that consist only of "0" and "1". We call these strings a and b. It is known that |b| β€ |a|, that is, the length of b is at most the length of a.
The Cossack considers every substring of length |b| in string a. Let's call this substring c. He matches the corresponding characters in b and c, after which he counts the number of positions where the two strings are different. We call this function f(b, c).
For example, let b = 00110, and c = 11000. In these strings, the first, second, third and fourth positions are different.
Vus the Cossack counts the number of such substrings c such that f(b, c) is even.
For example, let a = 01100010 and b = 00110. a has four substrings of the length |b|: 01100, 11000, 10001, 00010.
* f(00110, 01100) = 2;
* f(00110, 11000) = 4;
* f(00110, 10001) = 4;
* f(00110, 00010) = 1.
Since in three substrings, f(b, c) is even, the answer is 3.
Vus can not find the answer for big strings. That is why he is asking you to help him.
Input
The first line contains a binary string a (1 β€ |a| β€ 10^6) β the first string.
The second line contains a binary string b (1 β€ |b| β€ |a|) β the second string.
Output
Print one number β the answer.
Examples
Input
01100010
00110
Output
3
Input
1010111110
0110
Output
4
Note
The first example is explained in the legend.
In the second example, there are five substrings that satisfy us: 1010, 0101, 1111, 1111.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[2000000], t[2000000];
int a[2000000];
int main() {
cin >> s >> t;
int tot = 0;
a[0] = 0;
int lt = strlen(t), ls = strlen(s);
for (int i = 0; i < ls; ++i) {
a[i + 1] = a[i];
if (s[i] == '1') a[i + 1]++;
}
for (int i = 0; i < lt; ++i) {
if (t[i] == '1') ++tot;
}
int ans = 0;
for (int i = lt; i <= ls; ++i) {
if ((a[i] - a[i - lt]) % 2 == (tot % 2)) ++ans;
}
printf("%d", ans);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
While creating high loaded systems one should pay a special attention to caching. This problem will be about one of the most popular caching algorithms called LRU (Least Recently Used).
Suppose the cache may store no more than k objects. At the beginning of the workflow the cache is empty. When some object is queried we check if it is present in the cache and move it here if it's not. If there are more than k objects in the cache after this, the least recently used one should be removed. In other words, we remove the object that has the smallest time of the last query.
Consider there are n videos being stored on the server, all of the same size. Cache can store no more than k videos and caching algorithm described above is applied. We know that any time a user enters the server he pick the video i with probability pi. The choice of the video is independent to any events before.
The goal of this problem is to count for each of the videos the probability it will be present in the cache after 10100 queries.
Input
The first line of the input contains two integers n and k (1 β€ k β€ n β€ 20) β the number of videos and the size of the cache respectively. Next line contains n real numbers pi (0 β€ pi β€ 1), each of them is given with no more than two digits after decimal point.
It's guaranteed that the sum of all pi is equal to 1.
Output
Print n real numbers, the i-th of them should be equal to the probability that the i-th video will be present in the cache after 10100 queries. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 1
0.3 0.2 0.5
Output
0.3 0.2 0.5
Input
2 1
0.0 1.0
Output
0.0 1.0
Input
3 2
0.3 0.2 0.5
Output
0.675 0.4857142857142857 0.8392857142857143
Input
3 3
0.2 0.3 0.5
Output
1.0 1.0 1.0
### Response
```cpp
#include <bits/stdc++.h>
long double f[1 << 20];
double p[1 << 20];
int g[1 << 20];
double ans[20];
int main() {
f[0] = 1;
int n, k;
scanf("%d%d", &n, &k);
int cnt = n;
for (int i = 0; i < n; ++i) {
scanf("%lf", &p[1 << i]);
if (p[1 << i] == 0) cnt--;
}
if (cnt < k) k = cnt;
int lim = 1 << n;
for (int i = 1; i < lim; ++i) {
p[i] = p[i & (-i)] + p[i ^ (i & (-i))];
g[i] = (i & 1) + g[i >> 1];
}
for (int i = 0; i < lim; ++i) {
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) continue;
if (p[i] != 1) f[i ^ (1 << j)] += f[i] * p[1 << j] / (1 - p[i]);
}
if (g[i] == k) {
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) ans[j] += f[i];
}
}
}
for (int i = 0; i < n; ++i)
printf("%.7f%c", ans[i], (i == n - 1) ? '\n' : ' ');
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Sereja has a sequence that consists of n positive integers, a1, a2, ..., an.
First Sereja took a piece of squared paper and wrote all distinct non-empty non-decreasing subsequences of sequence a. Then for each sequence written on the squared paper, Sereja wrote on a piece of lines paper all sequences that do not exceed it.
A sequence of positive integers x = x1, x2, ..., xr doesn't exceed a sequence of positive integers y = y1, y2, ..., yr, if the following inequation holds: x1 β€ y1, x2 β€ y2, ..., xr β€ yr.
Now Sereja wonders, how many sequences are written on the lines piece of paper. Help Sereja, find the required quantity modulo 1000000007 (109 + 7).
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 106).
Output
In the single line print the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
1
42
Output
42
Input
3
1 2 2
Output
13
Input
5
1 2 3 4 5
Output
719
### Response
```cpp
#include <bits/stdc++.h>
const int64_t MOD = 1e9 + 7;
int64_t as[100005];
int64_t bit[100006];
int64_t raw[100006];
void add(int64_t i, int64_t v) {
raw[i] = (raw[i] + v) % MOD;
for (i++; i < 100006; i += (i & -i)) {
bit[i] = (bit[i] + v) % MOD;
}
}
void set(int64_t i, int64_t v) { add(i, (v + MOD - raw[i]) % MOD); }
int64_t prefix(int64_t i) {
int64_t ac = 0;
for (i++; i > 0; i -= (i & -i)) {
ac = (ac + bit[i]) % MOD;
}
return ac;
}
int64_t total = 0;
int main() {
int64_t N;
scanf("%I64d", &N);
std::map<int64_t, int64_t> cps;
for (int64_t i = 0; i < N; i++) {
scanf("%I64d", &as[i]);
cps[as[i]];
}
int64_t last = 1;
for (auto& pair : cps) {
pair.second = last++;
}
add(0, 1);
for (int64_t i = 0; i < N; i++) {
int64_t x = cps[as[i]];
int64_t q = prefix(x);
set(x, q * as[i] % MOD);
}
printf("%I64d\n", (prefix(last) + MOD - 1) % MOD);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Your friend Mishka and you attend a calculus lecture. Lecture lasts n minutes. Lecturer tells ai theorems during the i-th minute.
Mishka is really interested in calculus, though it is so hard to stay awake for all the time of lecture. You are given an array t of Mishka's behavior. If Mishka is asleep during the i-th minute of the lecture then ti will be equal to 0, otherwise it will be equal to 1. When Mishka is awake he writes down all the theorems he is being told β ai during the i-th minute. Otherwise he writes nothing.
You know some secret technique to keep Mishka awake for k minutes straight. However you can use it only once. You can start using it at the beginning of any minute between 1 and n - k + 1. If you use it on some minute i then Mishka will be awake during minutes j such that <image> and will write down all the theorems lecturer tells.
You task is to calculate the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up.
Input
The first line of the input contains two integer numbers n and k (1 β€ k β€ n β€ 105) β the duration of the lecture in minutes and the number of minutes you can keep Mishka awake.
The second line of the input contains n integer numbers a1, a2, ... an (1 β€ ai β€ 104) β the number of theorems lecturer tells during the i-th minute.
The third line of the input contains n integer numbers t1, t2, ... tn (0 β€ ti β€ 1) β type of Mishka's behavior at the i-th minute of the lecture.
Output
Print only one integer β the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up.
Example
Input
6 3
1 3 5 2 5 4
1 1 0 1 0 0
Output
16
Note
In the sample case the better way is to use the secret technique at the beginning of the third minute. Then the number of theorems Mishka will be able to write down will be equal to 16.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int y, i, j, k, n, a = 0, b = 0, max, s[100050], x[100050];
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &s[i]);
for (j = 0; j < n; j++) scanf("%d", &x[j]);
for (i = 0; i < n; i++) {
if (x[i] == 1) {
a += s[i];
}
}
for (i = 0; i < k; i++) {
if (x[i] == 0) b = b + s[i];
}
max = b;
for (i = 1; i < n; i++) {
if (x[i - 1] == 0) b = b - s[i - 1];
if (x[i + k - 1] == 0 && i + k - 1 < n) b = b + s[i + k - 1];
if (max < b) max = b;
}
printf("%d\n", a + max);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Count the number of strings S that satisfy the following constraints, modulo 10^9 + 7.
* The length of S is exactly N.
* S consists of digits (`0`...`9`).
* You are given Q intervals. For each i (1 \leq i \leq Q), the integer represented by S[l_i \ldots r_i] (the substring of S between the l_i-th (1-based) character and the r_i-th character, inclusive) must be a multiple of 9.
Here, the string S and its substrings may have leading zeroes. For example, `002019` represents the integer 2019.
Constraints
* 1 \leq N \leq 10^9
* 1 \leq Q \leq 15
* 1 \leq l_i \leq r_i \leq N
Input
Input is given from Standard Input in the following format:
N
Q
l_1 r_1
:
l_Q r_Q
Output
Print the number of strings that satisfy the conditions, modulo 10^9 + 7.
Examples
Input
4
2
1 2
2 4
Output
136
Input
6
3
2 5
3 5
1 3
Output
2720
Input
20
10
2 15
5 6
1 12
7 9
2 17
5 15
2 4
16 17
2 12
8 17
Output
862268030
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> sz;
UnionFind(int n=0){
if(n>0) initialize(n);
}
void initialize(int n){
par.resize(n);
sz.resize(n);
for(int i=0; i<n; i++){
par[i] = i;
sz[i] = 1;
}
}
int find(int x){
if(par[x] == x){
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(sz[x] < sz[y]){
par[x] = y;
sz[y] += sz[x];
}else{
par[y] = x;
sz[x] += sz[y];
}
}
bool same(int x, int y){
return find(x) == find(y);
}
};
int nth_bit(int64_t num, int n){
return (num >> n) & 1;
}
const int64_t MOD = 1e9+7;
void add(int64_t& a, int64_t b){
a = (a+b) % MOD;
}
void mul(int64_t& a, int64_t b){
a = a*b % MOD;
}
int64_t power_mod(int64_t num, int64_t power){
int64_t prod = 1;
num %= MOD;
while(power > 0){
if(power&1) prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int64_t extgcd(int64_t a, int64_t b, int64_t& x, int64_t& y){
int64_t d = a;
if(b != 0){
d = extgcd(b, a%b, y, x);
y -= (a/b) * x;
}else{
x = 1; y = 0;
}
return d;
}
int64_t inv_mod(int64_t a){
int64_t x, y;
extgcd(a, MOD, x, y);
return (MOD + x%MOD) % MOD;
}
int main(){
int N, Q, L[15], R[15];
cin >> N >> Q;
for(int i=0; i<Q; i++){
cin >> L[i] >> R[i];
L[i]--;
}
vector<int> compress;
for(int i=0; i<Q; i++){
compress.push_back(L[i]);
compress.push_back(R[i]);
}
sort(compress.begin(), compress.end());
compress.erase(unique(compress.begin(), compress.end()), compress.end());
map<int, int> compress_inv;
for(int i=0; i<compress.size(); i++) compress_inv[compress[i]] = i;
UnionFind uf(Q);
for(int i=0; i<Q; i++) for(int j=i+1; j<Q; j++){
if(L[i] == L[j] || L[i] == R[j] || R[i] == L[j] || R[i] == R[j]) uf.unite(i, j);
}
vector<vector<int>> components;
for(int i=0; i<Q; i++){
if(uf.find(i) != i) continue;
vector<int> v;
for(int j=0; j<Q; j++){
if(uf.same(i, j)){
v.push_back(compress_inv[L[j]]);
v.push_back(compress_inv[R[j]]);
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
components.push_back(v);
}
sort(components.begin(), components.end());
Q = components.size();
static int64_t coefficients[1<<15];
for(int bits=0; bits<(1<<Q); bits++){
vector<int> pts;
for(int i=0; i<Q; i++) if(nth_bit(bits, i)){
for(int v : components[i]) pts.push_back(v);
}
sort(pts.begin(), pts.end());
int64_t c = 1;
for(int i=0; i<(int)pts.size()-1; i++){
if(pts[i]+1 == pts[i+1]){
int dist = compress[pts[i+1]] - compress[pts[i]];
int64_t val = power_mod(10, dist) - 1;
mul(c, (val+9) * inv_mod(val) % MOD);
}
}
coefficients[bits] = c;
}
int64_t init[10];
for(int i=1; i<=9; i++) init[i] = ((power_mod(10, compress[0]) - 1) * inv_mod(9) + (i==9)) % MOD;
static int64_t dp[10][1<<15];
dp[0][0] = 1;
for(int n=1; n<=9; n++){
for(int bits=0; bits<(1<<Q); bits++){
for(int use=bits; use>=0; use=(use-1)&bits){
int64_t result = dp[n-1][bits-use] * coefficients[use] % MOD;
if(nth_bit(use, 0)) mul(result, init[n]);
add(dp[n][bits], result);
if(use == 0) break;
}
}
}
int64_t ans = dp[9][(1<<Q)-1];
for(int i=0; i<compress.size()-1; i++){
int dist = compress[i+1] - compress[i];
int64_t result = (power_mod(10, dist) - 1 + MOD) * inv_mod(9) % MOD;
mul(ans, result);
}
mul(ans, power_mod(10, N - compress.back()));
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Today you are to solve the problem even the famous Hercule Poirot can't cope with! That's why this crime has not yet been solved and this story was never included in Agatha Christie's detective story books.
You are not informed on what crime was committed, when and where the corpse was found and other details. We only know that the crime was committed in a house that has n rooms and m doors between the pairs of rooms. The house residents are very suspicious, that's why all the doors can be locked with keys and all the keys are different. According to the provided evidence on Thursday night all the doors in the house were locked, and it is known in what rooms were the residents, and what kind of keys had any one of them. The same is known for the Friday night, when all the doors were also locked. On Friday it was raining heavily, that's why nobody left the house and nobody entered it. During the day the house residents could
* open and close doors to the neighboring rooms using the keys at their disposal (every door can be opened and closed from each side);
* move freely from a room to a room if a corresponding door is open;
* give keys to one another, being in one room.
"Little grey matter" of Hercule Poirot are not capable of coping with such amount of information. Find out if the positions of people and keys on the Thursday night could result in the positions on Friday night, otherwise somebody among the witnesses is surely lying.
Input
The first line contains three preset integers n, m ΠΈ k (1 β€ n, m, k β€ 1000) β the number of rooms, the number of doors and the number of house residents respectively. The next m lines contain pairs of room numbers which join the doors. The rooms are numbered with integers from 1 to n. There cannot be more that one door between the pair of rooms. No door connects a room with itself. The next k lines describe the residents' position on the first night. Every line contains a resident's name (a non-empty line consisting of no more than 10 Latin letters), then after a space follows the room number, then, after a space β the number of keys the resident has. Then follow written space-separated numbers of the doors that can be unlocked by these keys. The doors are numbered with integers from 1 to m in the order in which they are described in the input data. All the residents have different names, uppercase and lowercase letters considered to be different. Every m keys occurs exactly once in the description. Multiple people may be present in one room, some rooms may be empty. The next k lines describe the position of the residents on the second night in the very same format. It is guaranteed that in the second night's description the residents' names remain the same and every m keys occurs exactly once.
Output
Print "YES" (without quotes) if the second arrangement can result from the first one, otherwise, print "NO".
Examples
Input
2 1 2
1 2
Dmitry 1 1 1
Natalia 2 0
Natalia 1 1 1
Dmitry 2 0
Output
YES
Input
4 4 3
1 3
1 2
2 3
3 4
Artem 1 1 4
Dmitry 1 1 2
Edvard 4 2 1 3
Artem 2 0
Dmitry 1 0
Edvard 4 4 1 2 3 4
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int tt = 1111;
int x[tt], y[tt], fa[tt], key[tt];
int n, m, k;
bool p1[tt], p2[tt];
char s[tt];
map<string, int> nm;
bool ans = true;
int findfa(int a) { return a == fa[a] ? a : fa[a] = findfa(fa[a]); }
void getans(bool *p) {
for (int i = 1; i <= n; i++) fa[i] = i;
for (bool pd = true; pd;) {
pd = false;
for (int i = 1; i <= m; i++)
if (!p[i]) {
int a = findfa(key[i]), b = findfa(x[i]), c = findfa(y[i]);
if (a == b || a == c) {
fa[b] = c;
pd = p[i] = true;
}
}
}
}
int main() {
int i, r, t, q;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= m; i++) scanf("%d%d", x + i, y + i), p1[i] = p2[i] = false;
for (i = 1; i <= k; i++) {
scanf("%s%d%d", s, &r, &t);
for (nm[s] = r; t; t--) key[scanf("%d", &q), q] = r;
}
getans(p1);
for (i = 1; i <= k; i++) {
scanf("%s%d%d", s, &r, &t);
ans &= findfa(nm[s]) == findfa(r);
for (; t; t--) {
ans &= findfa(key[scanf("%d", &q), q]) == findfa(r);
key[q] = r;
}
}
getans(p2);
for (i = 1; i <= m; i++) ans &= p1[i] == p2[i];
puts(ans ? "YES" : "NO");
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a rooted tree with n nodes, labeled from 1 to n. The tree is rooted at node 1. The parent of the i-th node is p_i. A leaf is node with no children. For a given set of leaves L, let f(L) denote the smallest connected subgraph that contains all leaves L.
You would like to partition the leaves such that for any two different sets x, y of the partition, f(x) and f(y) are disjoint.
Count the number of ways to partition the leaves, modulo 998244353. Two ways are different if there are two leaves such that they are in the same set in one way but in different sets in the other.
Input
The first line contains an integer n (2 β€ n β€ 200 000) β the number of nodes in the tree.
The next line contains n-1 integers p_2, p_3, β¦, p_n (1 β€ p_i < i).
Output
Print a single integer, the number of ways to partition the leaves, modulo 998244353.
Examples
Input
5
1 1 1 1
Output
12
Input
10
1 2 3 4 5 6 7 8 9
Output
1
Note
In the first example, the leaf nodes are 2,3,4,5. The ways to partition the leaves are in the following image <image>
In the second example, the only leaf is node 10 so there is only one partition. Note that node 1 is not a leaf.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, y, z, l, i, j, x, r;
long long a[100500], b[100500];
vector<long long> g[200500];
long long dp[200500][2];
long long binpow(long long x, long long y) {
if (y == 0) {
return 1;
}
long long tmp = binpow(x, y / 2);
tmp = tmp * tmp % 998244353;
if (y % 2) return x * tmp % 998244353;
return tmp;
}
long long inv(long long x) { return binpow(x, 998244353 - 2); }
void dfs(long long v, long long p = -1) {
long long k = 0;
long long prod1 = 1;
long long prod = 1;
long long sum = 0;
long long sum1 = 0;
for (auto to : g[v]) {
if (to == p) continue;
dfs(to, v);
prod1 = prod1 * (dp[to][0] + dp[to][1]) % 998244353;
prod = prod * (dp[to][1]) % 998244353;
sum = (sum + dp[to][0]) % 998244353;
sum1 = (sum1 + dp[to][1]) % 998244353;
k++;
}
if (k == 0) {
dp[v][0] = 1;
dp[v][1] = 1;
return;
}
long long mag = prod1;
for (auto to : g[v]) {
if (to == p) continue;
mag = (mag - prod * inv(dp[to][1]) % 998244353 * dp[to][0] % 998244353) +
998244353;
mag %= 998244353;
}
dp[v][0] = (prod1 - prod + 998244353 + 998244353) % 998244353;
dp[v][1] = mag;
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
g[x].push_back(i);
g[i].push_back(x);
}
dfs(1);
cout << dp[1][1] << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
β Thanks a lot for today.
β I experienced so many great things.
β You gave me memories like dreams... But I have to leave now...
β One last request, can you...
β Help me solve a Codeforces problem?
β ......
β What?
Chtholly has been thinking about a problem for days:
If a number is palindrome and length of its decimal representation without leading zeros is even, we call it a zcy number. A number is palindrome means when written in decimal representation, it contains no leading zeros and reads the same forwards and backwards. For example 12321 and 1221 are palindromes and 123 and 12451 are not. Moreover, 1221 is zcy number and 12321 is not.
Given integers k and p, calculate the sum of the k smallest zcy numbers and output this sum modulo p.
Unfortunately, Willem isn't good at solving this kind of problems, so he asks you for help!
Input
The first line contains two integers k and p (1 β€ k β€ 105, 1 β€ p β€ 109).
Output
Output single integer β answer to the problem.
Examples
Input
2 100
Output
33
Input
5 30
Output
15
Note
In the first example, the smallest zcy number is 11, and the second smallest zcy number is 22.
In the second example, <image>.
### Response
```cpp
#include <bits/stdc++.h>
int mod = 1000000007;
const double pi = 3.141592653689793238460;
const int inf = 0x3f3f3f3f;
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void r(int arr[], int d, int n) {
d = d % n;
int g_c_d = gcd(d, n);
for (int i = 0; i < g_c_d; i++) {
int temp = arr[i];
int j = i;
while (1) {
int k = j + d;
if (k >= n) k = k - n;
if (k == i) break;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long k, p;
cin >> k >> p;
long long sum = 0;
for (int i = 0; i < k + 1; i++) {
string s = to_string(i);
string x = to_string(i);
reverse(x.begin(), x.end());
s += x;
long long m = stoll(s);
sum = (sum + m) % p;
}
cout << sum % p << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Giant chess is quite common in Geraldion. We will not delve into the rules of the game, we'll just say that the game takes place on an h Γ w field, and it is painted in two colors, but not like in chess. Almost all cells of the field are white and only some of them are black. Currently Gerald is finishing a game of giant chess against his friend Pollard. Gerald has almost won, and the only thing he needs to win is to bring the pawn from the upper left corner of the board, where it is now standing, to the lower right corner. Gerald is so confident of victory that he became interested, in how many ways can he win?
The pawn, which Gerald has got left can go in two ways: one cell down or one cell to the right. In addition, it can not go to the black cells, otherwise the Gerald still loses. There are no other pawns or pieces left on the field, so that, according to the rules of giant chess Gerald moves his pawn until the game is over, and Pollard is just watching this process.
Input
The first line of the input contains three integers: h, w, n β the sides of the board and the number of black cells (1 β€ h, w β€ 105, 1 β€ n β€ 2000).
Next n lines contain the description of black cells. The i-th of these lines contains numbers ri, ci (1 β€ ri β€ h, 1 β€ ci β€ w) β the number of the row and column of the i-th cell.
It is guaranteed that the upper left and lower right cell are white and all cells in the description are distinct.
Output
Print a single line β the remainder of the number of ways to move Gerald's pawn from the upper left to the lower right corner modulo 109 + 7.
Examples
Input
3 4 2
2 2
2 3
Output
2
Input
100 100 3
15 16
16 15
99 88
Output
545732279
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int sz = 200010;
long long int f[sz], rev[sz], dp[sz];
pair<int, int> p[sz];
void compute() {
f[0] = 1;
rev[0] = rev[1] = 1;
for (int i = 1; i < sz; i++) {
f[i] = (i * f[i - 1]) % 1000000007;
}
for (int i = 2; i < sz; i++) {
rev[i] = (1000000007 - 1000000007 / i) * rev[1000000007 % i] % 1000000007;
}
for (int i = 2; i < sz; i++) {
rev[i] = (rev[i] * rev[i - 1]) % 1000000007;
}
}
long long int comb(long long int n, long long int r) {
long long int ans =
(((f[n] * rev[r]) % 1000000007) * rev[n - r]) % 1000000007;
return ans;
}
int main() {
compute();
long long int h, w, n;
cin >> h >> w >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
p[n] = make_pair(h, w);
sort(p, p + n + 1);
for (int i = 0; i <= n; i++) {
dp[i] = comb(p[i].first - 1 + p[i].second - 1, p[i].first - 1);
for (int j = 0; j < i; j++) {
if (p[j].first <= p[i].first && p[j].second <= p[i].second) {
dp[i] -= dp[j] *
comb(p[i].first - p[j].first + p[i].second - p[j].second,
p[i].first - p[j].first) %
1000000007;
dp[i] = (dp[i] % 1000000007 + 1000000007) % 1000000007;
}
}
}
dp[n] = ((dp[n] % 1000000007) + 1000000007) % 1000000007;
cout << dp[n] << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
We start with a permutation a_1, a_2, β¦, a_n and with an empty array b. We apply the following operation k times.
On the i-th iteration, we select an index t_i (1 β€ t_i β€ n-i+1), remove a_{t_i} from the array, and append one of the numbers a_{t_i-1} or a_{t_i+1} (if t_i-1 or t_i+1 are within the array bounds) to the right end of the array b. Then we move elements a_{t_i+1}, β¦, a_n to the left in order to fill in the empty space.
You are given the initial permutation a_1, a_2, β¦, a_n and the resulting array b_1, b_2, β¦, b_k. All elements of an array b are distinct. Calculate the number of possible sequences of indices t_1, t_2, β¦, t_k modulo 998 244 353.
Input
Each test contains multiple test cases. The first line contains an integer t (1 β€ t β€ 100 000), denoting the number of test cases, followed by a description of the test cases.
The first line of each test case contains two integers n, k (1 β€ k < n β€ 200 000): sizes of arrays a and b.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ n): elements of a. All elements of a are distinct.
The third line of each test case contains k integers b_1, b_2, β¦, b_k (1 β€ b_i β€ n): elements of b. All elements of b are distinct.
The sum of all n among all test cases is guaranteed to not exceed 200 000.
Output
For each test case print one integer: the number of possible sequences modulo 998 244 353.
Example
Input
3
5 3
1 2 3 4 5
3 2 5
4 3
4 3 2 1
4 3 1
7 4
1 4 7 3 6 2 5
3 2 4 5
Output
2
0
4
Note
\require{cancel}
Let's denote as a_1 a_2 β¦ \cancel{a_i} \underline{a_{i+1}} β¦ a_n β a_1 a_2 β¦ a_{i-1} a_{i+1} β¦ a_{n-1} an operation over an element with index i: removal of element a_i from array a and appending element a_{i+1} to array b.
In the first example test, the following two options can be used to produce the given array b:
* 1 2 \underline{3} \cancel{4} 5 β 1 \underline{2} \cancel{3} 5 β 1 \cancel{2} \underline{5} β 1 2; (t_1, t_2, t_3) = (4, 3, 2);
* 1 2 \underline{3} \cancel{4} 5 β \cancel{1} \underline{2} 3 5 β 2 \cancel{3} \underline{5} β 1 5; (t_1, t_2, t_3) = (4, 1, 2).
In the second example test, it is impossible to achieve the given array no matter the operations used. That's because, on the first application, we removed the element next to 4, namely number 3, which means that it couldn't be added to array b on the second step.
In the third example test, there are four options to achieve the given array b:
* 1 4 \cancel{7} \underline{3} 6 2 5 β 1 4 3 \cancel{6} \underline{2} 5 β \cancel{1} \underline{4} 3 2 5 β 4 3 \cancel{2} \underline{5} β 4 3 5;
* 1 4 \cancel{7} \underline{3} 6 2 5 β 1 4 3 \cancel{6} \underline{2} 5 β 1 \underline{4} \cancel{3} 2 5 β 1 4 \cancel{2} \underline{5} β 1 4 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 β 1 4 7 \cancel{3} \underline{2} 5 β \cancel{1} \underline{4} 7 2 5 β 4 7 \cancel{2} \underline{5} β 4 7 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 β 1 4 7 \cancel{3} \underline{2} 5 β 1 \underline{4} \cancel{7} 2 5 β 1 4 \cancel{2} \underline{5} β 1 4 5;
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int a[200010];
int b[200010];
int lf[200010], rg[200010];
int pre[200010], nxt[200010];
bool vis[200010];
int main() {
int t;
int n, m;
const long long p = 998244353;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
memset(vis, 0, sizeof(bool) * (n + 1));
memset(lf, 0, sizeof(int) * (n + 1));
memset(rg, 0, sizeof(int) * (n + 1));
memset(pre, 0, sizeof(int) * (n + 1));
memset(nxt, 0, sizeof(int) * (n + 1));
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
vis[b[i]] = true;
}
int sum = 0, pe = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i];
if (!vis[x]) {
++sum;
continue;
}
lf[x] = sum;
rg[pe] = sum;
pre[x] = pe;
nxt[pe] = x;
sum = 0;
pe = x;
}
rg[pe] = sum;
long long ans = 1;
for (int i = 1; i <= m; ++i) {
int x = b[i];
if (lf[x] == 0 && rg[x] == 0) {
ans = 0;
break;
}
if (lf[x] && rg[x]) {
ans = ans * 2 % p;
}
int pe = pre[x], nt = nxt[x];
rg[pe] += rg[x];
lf[nt] += lf[x];
nxt[pe] = nt;
pre[nt] = pe;
}
printf("%lld\n", ans);
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
char s[100];
cin >> s;
int len = strlen(s);
int i = 0;
while (i < len) {
if ('A' <= s[i] && s[i] <= 'Z')
i++;
else
break;
}
while (i < len) {
if ('0' <= s[i] && s[i] <= '9')
i++;
else
break;
}
if (i == len) {
int col = 0;
i = 0;
while ('A' <= s[i] && s[i] <= 'Z') {
col = col * 26 + s[i] - 'A' + 1;
i++;
}
int row = 0;
while (i < len) {
row = row * 10 + s[i] - '0';
i++;
}
cout << "R" << row << "C" << col << "\n";
} else {
i = 1;
int row = 0;
while (s[i] != 'C') {
row = row * 10 + s[i] - '0';
i++;
}
i++;
int col = 0;
while (i < len) {
col = col * 10 + s[i] - '0';
i++;
}
len = 0;
char ans[100];
while (col != 0) {
int md = col % 26;
col /= 26;
if (md == 0) {
ans[len++] = 'Z';
col--;
} else
ans[len++] = md + 'A' - 1;
}
for (i = len - 1; i >= 0; i--) cout << ans[i];
cout << row << "\n";
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Miyako came to the flea kingdom with a ukulele. She became good friends with local flea residents and played beautiful music for them every day.
In return, the fleas made a bigger ukulele for her: it has n strings, and each string has (10^{18} + 1) frets numerated from 0 to 10^{18}. The fleas use the array s_1, s_2, β¦, s_n to describe the ukulele's tuning, that is, the pitch of the j-th fret on the i-th string is the integer s_i + j.
Miyako is about to leave the kingdom, but the fleas hope that Miyako will answer some last questions for them.
Each question is in the form of: "How many different pitches are there, if we consider frets between l and r (inclusive) on all strings?"
Miyako is about to visit the cricket kingdom and has no time to answer all the questions. Please help her with this task!
Formally, you are given a matrix with n rows and (10^{18}+1) columns, where the cell in the i-th row and j-th column (0 β€ j β€ 10^{18}) contains the integer s_i + j. You are to answer q queries, in the k-th query you have to answer the number of distinct integers in the matrix from the l_k-th to the r_k-th columns, inclusive.
Input
The first line contains an integer n (1 β€ n β€ 100 000) β the number of strings.
The second line contains n integers s_1, s_2, β¦, s_n (0 β€ s_i β€ 10^{18}) β the tuning of the ukulele.
The third line contains an integer q (1 β€ q β€ 100 000) β the number of questions.
The k-th among the following q lines contains two integers l_kοΌr_k (0 β€ l_k β€ r_k β€ 10^{18}) β a question from the fleas.
Output
Output one number for each question, separated by spaces β the number of different pitches.
Examples
Input
6
3 1 4 1 5 9
3
7 7
0 2
8 17
Output
5 10 18
Input
2
1 500000000000000000
2
1000000000000000000 1000000000000000000
0 1000000000000000000
Output
2 1500000000000000000
Note
For the first example, the pitches on the 6 strings are as follows.
$$$ \begin{matrix} Fret & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & β¦ \\\ s_1: & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & ... \\\ s_2: & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & ... \\\ s_3: & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & ... \\\ s_4: & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & ... \\\ s_5: & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & ... \\\ s_6: & 9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & ... \end{matrix} $$$
There are 5 different pitches on fret 7 β 8, 10, 11, 12, 16.
There are 10 different pitches on frets 0, 1, 2 β 1, 2, 3, 4, 5, 6, 7, 9, 10, 11.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
sort(s.begin(), s.end());
n = unique(s.begin(), s.end()) - s.begin();
vector<long long> d(n);
for (int i = 1; i < n; ++i) {
d[i] = s[i] - s[i - 1] - 1;
}
sort(d.begin(), d.end());
vector<long long> sum(n);
for (int i = 1; i < n; ++i) {
sum[i] = sum[i - 1] + d[i];
}
int q;
cin >> q;
while (q--) {
long long l, r;
cin >> l >> r;
r -= l;
long long ans = n;
int iter = upper_bound(d.begin(), d.end(), r) - d.begin();
ans += sum[iter - 1];
ans += r * (n - iter + 1);
cout << ans << " ";
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Amr has got a large array of size n. Amr doesn't like large arrays so he intends to make it smaller.
Amr doesn't care about anything in the array except the beauty of it. The beauty of the array is defined to be the maximum number of times that some number occurs in this array. He wants to choose the smallest subsegment of this array such that the beauty of it will be the same as the original array.
Help Amr by choosing the smallest subsegment possible.
Input
The first line contains one number n (1 β€ n β€ 105), the size of the array.
The second line contains n integers ai (1 β€ ai β€ 106), representing elements of the array.
Output
Output two integers l, r (1 β€ l β€ r β€ n), the beginning and the end of the subsegment chosen respectively.
If there are several possible answers you may output any of them.
Examples
Input
5
1 1 2 2 1
Output
1 5
Input
5
1 2 2 3 1
Output
2 3
Input
6
1 2 2 1 1 2
Output
1 5
Note
A subsegment B of an array A from l to r is an array of size r - l + 1 where Bi = Al + i - 1 for all 1 β€ i β€ r - l + 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long fastmul(long long a, long long b) {
if (b == 0) return 0;
if (b == 1) return a;
long long tmp = fastmul(a, b >> 1);
return (b & 1) ? ((tmp << 1) + a) % 1000000007LL : (tmp << 1) % 1000000007LL;
}
struct Point {
double x, y;
Point() {}
Point(double A, double B) : x(A), y(B) {}
};
struct Vec {
double x, y;
Vec() {}
Vec(double A, double B) : x(A), y(B) {}
};
struct line {
double a, b, c;
line() {}
line(double A, double B, double C) : a(A), b(B), c(C) {}
line(Point A, Point B) {
a = A.y - B.y;
b = B.x - A.x;
c = -a * A.x - b * A.y;
}
};
Point intersect(line AB, line CD) {
AB.c = -AB.c;
CD.c = -CD.c;
double D = (AB.a * CD.b - AB.b * CD.a);
double Dx = (AB.c * CD.b - AB.b * CD.c);
double Dy = (AB.a * CD.c - AB.c * CD.a);
if (D == 0.0)
return Point(1e9, 1e9);
else
return Point(Dx / D, Dy / D);
}
struct matrix {
long long a[2 + 5][2 + 5];
matrix() {}
};
matrix matmul(matrix A, matrix B) {
matrix c;
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= 2; j++) {
c.a[i][j] = 0;
for (int k = 1; k <= 2; k++)
c.a[i][j] = (c.a[i][j] + fastmul(A.a[i][k], B.a[k][j])) % 1000000007LL;
}
return c;
}
int n, x, res = 0, cnt[1000005], Start[1000005], Stop[1000005], luui = 0,
luuj = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= 1000000; i++) Start[i] = long(1e9);
for (int i = 1; i <= n; i++) {
cin >> x;
cnt[x]++;
Start[x] = min(Start[x], i);
Stop[x] = max(Stop[x], i);
res = max(res, cnt[x]);
}
int RES = long(1e9);
for (int i = 1; i <= 1000000; i++) {
if (cnt[i] == res) {
if (Stop[i] - Start[i] + 1 < RES) {
RES = Stop[i] - Start[i] + 1;
luui = Start[i];
luuj = Stop[i];
}
}
}
cout << luui << ' ' << luuj;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Andrey needs one more problem to conduct a programming contest. He has n friends who are always willing to help. He can ask some of them to come up with a contest problem. Andrey knows one value for each of his fiends β the probability that this friend will come up with a problem if Andrey asks him.
Help Andrey choose people to ask. As he needs only one problem, Andrey is going to be really upset if no one comes up with a problem or if he gets more than one problem from his friends. You need to choose such a set of people that maximizes the chances of Andrey not getting upset.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of Andrey's friends. The second line contains n real numbers pi (0.0 β€ pi β€ 1.0) β the probability that the i-th friend can come up with a problem. The probabilities are given with at most 6 digits after decimal point.
Output
Print a single real number β the probability that Andrey won't get upset at the optimal choice of friends. The answer will be considered valid if it differs from the correct one by at most 10 - 9.
Examples
Input
4
0.1 0.2 0.3 0.8
Output
0.800000000000
Input
2
0.1 0.2
Output
0.260000000000
Note
In the first sample the best strategy for Andrey is to ask only one of his friends, the most reliable one.
In the second sample the best strategy for Andrey is to ask all of his friends to come up with a problem. Then the probability that he will get exactly one problem is 0.1Β·0.8 + 0.9Β·0.2 = 0.26.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
double p[105], suff[105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
sort(p + 1, p + n + 1);
cout << fixed << setprecision(10);
if (p[n] == 1) {
cout << 1. << '\n';
return 0;
}
suff[n] = 1 - p[n];
for (int i = n - 1; i >= 1; i--) {
suff[i] = (1 - p[i]) * suff[i + 1];
}
double ans = 0;
for (int i = n; i >= 1; i--) {
double tmp = 0;
for (int j = i; j <= n; j++) {
tmp += p[j] / (1 - p[j]);
}
tmp *= suff[i];
ans = max(ans, tmp);
}
cout << ans << '\n';
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
After hard work Igor decided to have some rest.
He decided to have a snail. He bought an aquarium with a slippery tree trunk in the center, and put a snail named Julia into the aquarium.
Igor noticed that sometimes Julia wants to climb onto the trunk, but can't do it because the trunk is too slippery. To help the snail Igor put some ropes on the tree, fixing the lower end of the i-th rope on the trunk on the height li above the ground, and the higher end on the height ri above the ground.
For some reason no two ropes share the same position of the higher end, i.e. all ri are distinct. Now Julia can move down at any place of the trunk, and also move up from the lower end of some rope to its higher end. Igor is proud of his work, and sometimes think about possible movements of the snail. Namely, he is interested in the following questions: Β«Suppose the snail is on the trunk at height x now. What is the highest position on the trunk the snail can get on if it would never be lower than x or higher than y?Β» Please note that Julia can't move from a rope to the trunk before it reaches the higher end of the rope, and Igor is interested in the highest position on the tree trunk.
Igor is interested in many questions, and not always can answer them. Help him, write a program that answers these questions.
Input
The first line contains single integer n (1 β€ n β€ 100000) β the height of the trunk.
The second line contains single integer m (1 β€ m β€ 100000) β the number of ropes.
The next m lines contain information about the ropes.
The i-th of these lines contains two integers li and ri (1 β€ li β€ ri β€ n) β the heights on which the lower and the higher ends of the i-th rope are fixed, respectively. It is guaranteed that all ri are distinct.
The next line contains single integer q (1 β€ q β€ 100000) β the number of questions.
The next q lines contain information about the questions.
Each of these lines contain two integers x and y (1 β€ x β€ y β€ n), where x is the height where Julia starts (and the height Julia can't get lower than), and y is the height Julia can't get higher than.
Output
For each question print the maximum reachable for Julia height.
Examples
Input
8
4
1 2
3 4
2 5
6 7
5
1 2
1 4
1 6
2 7
6 8
Output
2
2
5
5
7
Input
10
10
3 7
1 4
1 6
5 5
1 1
3 9
7 8
1 2
3 3
7 10
10
2 4
1 7
3 4
3 5
2 8
2 5
5 5
3 5
7 7
3 10
Output
2
7
3
3
2
2
5
3
7
10
Note
The picture of the first sample is on the left, the picture of the second sample is on the right. Ropes' colors are just for clarity, they don't mean anything.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
using std::vector;
const int maxn = 100017;
int val[maxn << 2], tag[maxn << 2];
int N, M, Q;
int rp[maxn];
struct Query {
int id, x;
};
vector<Query> q[maxn];
int ans[maxn];
struct node {
int mx, sc, tag;
} tree[maxn << 2];
void pushdown(int i) {
if (tree[i].tag == 0) return;
if (tree[(i << 1)].mx > tree[i].sc)
tree[(i << 1)].mx = tree[(i << 1)].tag = tree[i].tag;
if (tree[(i << 1 | 1)].mx > tree[i].sc)
tree[(i << 1 | 1)].mx = tree[(i << 1 | 1)].tag = tree[i].tag;
tree[i].tag = 0;
return;
}
void pushup(int i) {
tree[i].mx = max(tree[(i << 1)].mx, tree[(i << 1 | 1)].mx);
tree[i].sc = max(tree[(i << 1)].sc, tree[(i << 1 | 1)].sc);
if (tree[(i << 1)].mx != tree[(i << 1 | 1)].mx)
tree[i].sc = max(tree[i].sc, min(tree[(i << 1)].mx, tree[(i << 1 | 1)].mx));
return;
}
void update(int L, int R, int l, int r, int li, int ri, int i) {
if (li > tree[i].mx) return;
if (l <= L && R <= r) {
if (li > tree[i].sc)
tree[i].mx = tree[i].tag = ri;
else {
int mid = L + R >> 1;
pushdown(i);
update(L, mid, l, r, li, ri, (i << 1));
update(mid + 1, R, l, r, li, ri, (i << 1 | 1));
pushup(i);
}
} else {
int mid = L + R >> 1;
pushdown(i);
if (l <= mid) update(L, mid, l, r, li, ri, (i << 1));
if (r > mid) update(mid + 1, R, l, r, li, ri, (i << 1 | 1));
pushup(i);
}
return;
}
void update(int L, int R, int x, int i) {
if (L == R) {
tree[i].mx = x;
return;
}
pushdown(i);
int mid = L + R >> 1;
if (x <= mid)
update(L, mid, x, (i << 1));
else
update(mid + 1, R, x, (i << 1 | 1));
return pushup(i);
}
int query(int L, int R, int x, int i) {
if (L == R) return tree[i].mx;
pushdown(i);
int mid = L + R >> 1;
if (x <= mid)
return query(L, mid, x, (i << 1));
else
return query(mid + 1, R, x, (i << 1 | 1));
}
int main() {
scanf("%d%d", &N, &M);
int x, y;
for (int i = 1; i <= M; i++) scanf("%d%d", &x, &y), rp[y] = x;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back((Query){i, x});
for (int i = 1; i <= N; i++) {
update(1, N, i, 1);
if (rp[i]) update(1, N, 1, rp[i], rp[i], i, 1);
for (int k = 0; k < q[i].size(); k++)
ans[q[i][k].id] = query(1, N, q[i][k].x, 1);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You have a garland consisting of n lamps. Each lamp is colored red, green or blue. The color of the i-th lamp is s_i ('R', 'G' and 'B' β colors of lamps in the garland).
You have to recolor some lamps in this garland (recoloring a lamp means changing its initial color to another) in such a way that the obtained garland is nice.
A garland is called nice if any two lamps of the same color have distance divisible by three between them. I.e. if the obtained garland is t, then for each i, j such that t_i = t_j should be satisfied |i-j|~ mod~ 3 = 0. The value |x| means absolute value of x, the operation x~ mod~ y means remainder of x when divided by y.
For example, the following garlands are nice: "RGBRGBRG", "GB", "R", "GRBGRBG", "BRGBRGB". The following garlands are not nice: "RR", "RGBG".
Among all ways to recolor the initial garland to make it nice you have to choose one with the minimum number of recolored lamps. If there are multiple optimal solutions, print any of them.
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of lamps.
The second line of the input contains the string s consisting of n characters 'R', 'G' and 'B' β colors of lamps in the garland.
Output
In the first line of the output print one integer r β the minimum number of recolors needed to obtain a nice garland from the given one.
In the second line of the output print one string t of length n β a nice garland obtained from the initial one with minimum number of recolors. If there are multiple optimal solutions, print any of them.
Examples
Input
3
BRB
Output
1
GRB
Input
7
RGBGRBB
Output
3
RGBRGBR
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5;
const int INF = 1e9 + 1e5 + 2;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
map<int, string> mp;
mp[1] = "RGB";
mp[2] = "RBG";
mp[3] = "BRG";
mp[4] = "BGR";
mp[5] = "GBR";
mp[6] = "GRB";
string second;
cin >> second;
int ans = 1e6;
string anss;
for (int i = 1; i <= 6; i++) {
string x = mp[i];
int sum = 0;
for (int j = 0; j < n; j += 3) {
if (x[0] != second[j]) ++sum;
if (x[1] != second[j + 1] && j + 1 < n) ++sum;
if (x[2] != second[j + 2] && j + 2 < n) ++sum;
}
if (sum < ans) {
ans = sum;
anss = x;
}
}
cout << ans << "\n";
for (int i = 0; i < n / 3; i++) cout << anss;
int y = n % 3;
for (int i = 0; i < y; i++) cout << anss[i];
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n β length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 β€ n β€ 10^3, n is even) β length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 β€ k β€ n) β number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> ones;
vector<int> zeros;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
ones.push_back(i);
} else {
zeros.push_back(i);
}
}
if (ones.size() <= n / 2) {
cout << n - ones.size() << endl;
for (int i = 0; i < zeros.size(); i++) {
cout << 0 << " ";
}
cout << endl;
} else {
cout << n - (zeros.size() + (ones.size() % 2 == 1)) << endl;
for (int i = 0; i < ones.size() - (ones.size() % 2 == 1); i++) {
cout << 1 << " ";
}
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Vasya decided to pass a very large integer n to Kate. First, he wrote that number as a string, then he appended to the right integer k β the number of digits in n.
Magically, all the numbers were shuffled in arbitrary order while this note was passed to Kate. The only thing that Vasya remembers, is a non-empty substring of n (a substring of n is a sequence of consecutive digits of the number n).
Vasya knows that there may be more than one way to restore the number n. Your task is to find the smallest possible initial integer n. Note that decimal representation of number n contained no leading zeroes, except the case the integer n was equal to zero itself (in this case a single digit 0 was used).
Input
The first line of the input contains the string received by Kate. The number of digits in this string does not exceed 1 000 000.
The second line contains the substring of n which Vasya remembers. This string can contain leading zeroes.
It is guaranteed that the input data is correct, and the answer always exists.
Output
Print the smalles integer n which Vasya could pass to Kate.
Examples
Input
003512
021
Output
30021
Input
199966633300
63
Output
3036366999
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
int n, m, c[10], d[10], k, b, x, p, a;
char s[N], t[N];
int d1(int k) {
int c = 0;
while (k) k /= 10, c++;
return c;
}
bool d2(int k) {
memset(d, 0, sizeof d);
while (k) d[k % 10]++, k /= 10;
for (int i = 0; i < 10; ++i)
if (d[i] > c[i]) return 0;
return true;
}
int main() {
scanf("%s %s", s, t);
n = strlen(s), m = strlen(t);
for (int i = 0; i < n; ++i) c[s[i] - '0']++;
for (k = N; k > 0; --k)
if (k + d1(k) == n and d2(k)) break;
for (int i = 0; i < m; ++i) c[t[i] - '0']--;
while (k) c[k % 10]--, k /= 10;
x = t[0] - '0';
a = (x != 0);
for (int i = 0; i < 10; ++i) d[i] = c[i];
for (int i = 0; i < m; ++i) {
for (int j = 0 + (i == 0); j < t[i] - '0'; ++j)
if (d[j]) a = 0;
if (d[t[i] - '0'] == 0 or !a) break;
d[t[i] - '0']--;
}
for (int i = 0; i < m; ++i) {
if (t[i] > t[0]) {
b = 0;
break;
} else if (t[i] < t[0]) {
b = 1;
break;
}
}
for (int i = 1; i < 10; ++i) {
if (a) {
printf("%s", t);
p = 1;
break;
}
if (c[i]) {
printf("%c", i + '0');
--c[i];
break;
}
if (!a and i == x and !b) {
printf("%s", t);
p = 1;
break;
}
}
for (int i = 0; i < 10; ++i) {
if (i == x and b and !p) printf("%s", t), p = 1;
while (c[i]) printf("%c", i + '0'), --c[i];
if (i == x and !b and !p) printf("%s", t), p = 1;
}
printf("\n");
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a connected undirected simple graph, which has N vertices and M edges. The vertices are numbered 1 through N, and the edges are numbered 1 through M. Edge i connects vertices A_i and B_i. Your task is to find a path that satisfies the following conditions:
* The path traverses two or more vertices.
* The path does not traverse the same vertex more than once.
* A vertex directly connected to at least one of the endpoints of the path, is always contained in the path.
It can be proved that such a path always exists. Also, if there are more than one solution, any of them will be accepted.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i < B_i \leq N
* The given graph is connected and simple (that is, for every pair of vertices, there is at most one edge that directly connects them).
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find one path that satisfies the conditions, and print it in the following format. In the first line, print the count of the vertices contained in the path. In the second line, print a space-separated list of the indices of the vertices, in order of appearance in the path.
Examples
Input
5 6
1 3
1 4
2 3
1 5
3 5
2 4
Output
4
2 3 1 4
Input
7 8
1 2
2 3
3 4
4 5
5 6
6 7
3 5
2 6
Output
7
1 2 3 4 5 6 7
### Response
```cpp
#include<bits/stdc++.h>
int n,m,s,t;
int to[200005],nxt[200005],fst[100005],tot;
void add(int u,int v)
{
to[++tot]=v;
nxt[tot]=fst[u];
fst[u]=tot;
}
bool vis[100005];
int q[200005],l,r;
void extend(int u,int &p,int d)
{
vis[q[p+=d]=u]=1;
for(int e=fst[u],v;e;e=nxt[e])
if(!vis[v=to[e]]){extend(v,p,d);return;}
}
int main()
{
scanf("%d%d",&n,&m);
for(int e=1;e<=m;++e)
{
scanf("%d%d",&s,&t);
add(s,t),add(t,s);
}
vis[s]=vis[t]=1;
extend(s,l=100001,-1);
extend(t,r=100000,1);
printf("%d\n",r-l+1);
for(int i=l;i<=r;++i)
printf("%d ",q[i]);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Write a program which reads a list of N integers and prints the number of prime numbers in the list.
Constraints
1 β€ N β€ 10000
2 β€ an element of the list β€ 108
Input
The first line contains an integer N, the number of elements in the list.
N numbers are given in the following lines.
Output
Print the number of prime numbers in the given list.
Examples
Input
5
2
3
4
5
6
Output
3
Input
11
7
8
9
10
11
12
13
14
15
16
17
Output
4
### Response
```cpp
#include <iostream>
using namespace std;
bool isPrime(int n){
if(n <= 1){
return false;
}
for(int i = 2; i*i <= n; i++){
if(n%i == 0){
return false;
}
}
return true;
}
int main(){
int n,c = 0;
cin >> n;
for(int i = 0; i < n; i++){
int D;
cin >> D;
if(isPrime(D)){
c++;
}
}
cout << c << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Snuke is having a barbeque party.
At the party, he will make N servings of Skewer Meal.
<image>
Example of a serving of Skewer Meal
He has a stock of 2N skewers, all of which will be used in Skewer Meal. The length of the i-th skewer is L_i. Also, he has an infinite supply of ingredients.
To make a serving of Skewer Meal, he picks 2 skewers and threads ingredients onto those skewers. Let the length of the shorter skewer be x, then the serving can hold the maximum of x ingredients.
What is the maximum total number of ingredients that his N servings of Skewer Meal can hold, if he uses the skewers optimally?
Constraints
* 1β¦Nβ¦100
* 1β¦L_iβ¦100
* For each i, L_i is an integer.
Input
The input is given from Standard Input in the following format:
N
L_1 L_2 ... L_{2N}
Output
Print the maximum total number of ingredients that Snuke's N servings of Skewer Meal can hold.
Examples
Input
2
1 3 1 2
Output
3
Input
5
100 1 2 3 14 15 58 58 58 29
Output
135
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int a[300];
int main()
{
int n;
cin>>n;
int res=0;
for(int i=0;i<n*2;i++)cin>>a[i];
sort(a,a+n*2);
for(int i=0;i<n*2;i+=2)res+=min(a[i],a[i+1]);
cout<<res<<endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There is a railroad in Takahashi Kingdom. The railroad consists of N sections, numbered 1, 2, ..., N, and N+1 stations, numbered 0, 1, ..., N. Section i directly connects the stations i-1 and i. A train takes exactly A_i minutes to run through section i, regardless of direction. Each of the N sections is either single-tracked over the whole length, or double-tracked over the whole length. If B_i = 1, section i is single-tracked; if B_i = 2, section i is double-tracked. Two trains running in opposite directions can cross each other on a double-tracked section, but not on a single-tracked section. Trains can also cross each other at a station.
Snuke is creating the timetable for this railroad. In this timetable, the trains on the railroad run every K minutes, as shown in the following figure. Here, bold lines represent the positions of trains running on the railroad. (See Sample 1 for clarification.)
<image>
When creating such a timetable, find the minimum sum of the amount of time required for a train to depart station 0 and reach station N, and the amount of time required for a train to depart station N and reach station 0. It can be proved that, if there exists a timetable satisfying the conditions in this problem, this minimum sum is always an integer.
Formally, the times at which trains arrive and depart must satisfy the following:
* Each train either departs station 0 and is bound for station N, or departs station N and is bound for station 0.
* Each train takes exactly A_i minutes to run through section i. For example, if a train bound for station N departs station i-1 at time t, the train arrives at station i exactly at time t+A_i.
* Assume that a train bound for station N arrives at a station at time s, and departs the station at time t. Then, the next train bound for station N arrives at the station at time s+K, and departs the station at time t+K. Additionally, the previous train bound for station N arrives at the station at time s-K, and departs the station at time t-K. This must also be true for trains bound for station 0.
* Trains running in opposite directions must not be running on the same single-tracked section (except the stations at both ends) at the same time.
Constraints
* 1 \leq N \leq 100000
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 10^9
* A_i is an integer.
* B_i is either 1 or 2.
Input
The input is given from Standard Input in the following format:
N K
A_1 B_1
A_2 B_2
:
A_N B_N
Output
Print an integer representing the minimum sum of the amount of time required for a train to depart station 0 and reach station N, and the amount of time required for a train to depart station N and reach station 0. If it is impossible to create a timetable satisfying the conditions, print -1 instead.
Examples
Input
3 10
4 1
3 1
4 1
Output
26
Input
1 10
10 1
Output
-1
Input
6 4
1 1
1 1
1 1
1 1
1 1
1 1
Output
12
Input
20 987654321
129662684 2
162021979 1
458437539 1
319670097 2
202863355 1
112218745 1
348732033 1
323036578 1
382398703 1
55854389 1
283445191 1
151300613 1
693338042 2
191178308 2
386707193 1
204580036 1
335134457 1
122253639 1
824646518 2
902554792 2
Output
14829091348
### Response
```cpp
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define MP make_pair
#define PB push_back
using namespace std;
int read(){
int x=0,f=1,c=getchar();
for(;!isdigit(c);c=getchar())if(c=='-')f^=1;
for(; isdigit(c);c=getchar())x=x*10+c-48;
return f?x:-x;
}
const int N=1<<18;
int n,K;
int a[N],b[N];
ll L[N],R[N],rL[N],rR[N];
ll dpL[N],dpR[N];
void chkmin(int&x,int y){if(y<x)x=y;}
ll cst(ll x,ll y){return y>=x?y-x:y-x+K;}
struct SegT{
int mn[N<<1];
void ini(int v){
for(int i=1;i<(N<<1);++i)mn[i]=v;
}
void upd(int l,int r,int v){
for(l+=N,r+=N;l<r;l>>=1,r>>=1){
if(l&1)chkmin(mn[l++],v);
if(r&1)chkmin(mn[--r],v);
}
}
int qry(int x){
int ans=1<<30;
for(x+=N;x;x>>=1){
chkmin(ans,mn[x]);
}
return ans;
}
}segt;
int main(){
n=read(),K=read();
for(int i=0;i<n;++i)a[i]=read(),b[i]=read();
for(int i=0;i<n;++i){
if(i)L[i]=((L[i-1]-2*a[i-1])%K+K)%K;
R[i]=((R[i-1]-2*a[i])%K+K)%K;
}
for(int i=0;i<n;++i)
if(b[i]==2)L[i]=0,R[i]=K-1;
else if(2*a[i]>K){
puts("-1");return 0;
}
vector<int>v;
for(int i=0;i<n;++i)v.PB(L[i]),v.PB(R[i]);
v.PB(0),v.PB(K);
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
for(int i=0;i<n;++i){
rL[i]=L[i],rR[i]=R[i];
L[i]=lower_bound(v.begin(),v.end(),rL[i])-v.begin();
R[i]=lower_bound(v.begin(),v.end(),rR[i])-v.begin();
}
dpL[n-1]=dpR[n-1]=0;
segt.ini(1<<30);
ll ans=1LL<<60;
for(int i=n-2;~i;--i){
if(L[i+1]<=R[i+1]){
segt.upd(R[i+1]+1,v.size(),i+1);
segt.upd(0,L[i+1],i+1);
}else segt.upd(R[i+1]+1,L[i+1],i+1);
int j;
j=segt.qry(L[i]);
if(j>=n)dpL[i]=0;
else dpL[i]=min(dpL[j]+cst(rL[i],rL[j]),dpR[j]+cst(rL[i],rR[j]));
j=segt.qry(R[i]);
if(j>=n)dpR[i]=0;
else dpR[i]=min(dpL[j]+cst(rR[i],rL[j]),dpR[j]+cst(rR[i],rR[j]));
}
segt.ini(1);
for(int i=0;i<n;++i){
int j;
j=-segt.qry(L[i]);
if(j<0)ans=min(ans,dpL[i]);
j=-segt.qry(R[i]);
if(j<0)ans=min(ans,dpR[i]);
if(L[i]<=R[i]){
segt.upd(R[i]+1,v.size(),-i);
segt.upd(0,L[i],-i);
}else segt.upd(R[i]+1,L[i],-i);
}
ll sum=0;
for(int i=0;i<n;++i)sum+=a[i];
printf("%lld\n",ans+2*sum);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given a string S and an array of strings [t_1, t_2, ..., t_k]. Each string t_i consists of lowercase Latin letters from a to n; S consists of lowercase Latin letters from a to n and no more than 14 question marks.
Each string t_i has its cost c_i β an integer number. The value of some string T is calculated as β_{i = 1}^{k} F(T, t_i) β
c_i, where F(T, t_i) is the number of occurences of string t_i in T as a substring. For example, F(aaabaaa, aa) = 4.
You have to replace all question marks in S with pairwise distinct lowercase Latin letters from a to n so the value of S is maximum possible.
Input
The first line contains one integer k (1 β€ k β€ 1000) β the number of strings in the array [t_1, t_2, ..., t_k].
Then k lines follow, each containing one string t_i (consisting of lowercase Latin letters from a to n) and one integer c_i (1 β€ |t_i| β€ 1000, -10^6 β€ c_i β€ 10^6). The sum of lengths of all strings t_i does not exceed 1000.
The last line contains one string S (1 β€ |S| β€ 4 β
10^5) consisting of lowercase Latin letters from a to n and question marks. The number of question marks in S is not greater than 14.
Output
Print one integer β the maximum value of S after replacing all question marks with pairwise distinct lowercase Latin letters from a to n.
Examples
Input
4
abc -10
a 1
b 1
c 3
?b?
Output
5
Input
2
a 1
a 1
?
Output
2
Input
3
a 1
b 3
ab 4
ab
Output
8
Input
1
a -1
?????????????
Output
0
Input
1
a -1
??????????????
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9 + 100;
const long long inf_ll = 1e18;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 2e5 + 100;
const int LOG = 21;
const int mod = 998244353;
const int MX = (1e7 + 100);
int go[1024][26];
int sufLink[1024];
int leaf[1024];
int top = 1;
void build() {
memset(sufLink, -1, sizeof sufLink);
queue<int> q;
q.push(0);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < 26; ++i) {
int to = go[v][i];
int suf = sufLink[v] == -1 ? 0 : go[sufLink[v]][i];
if (to >= 0) {
sufLink[to] = suf;
q.push(to);
} else {
go[v][i] = suf;
}
}
if (sufLink[v] >= 0) leaf[v] += leaf[sufLink[v]];
}
}
long long dp[2][1 << 14][1024];
inline pair<int, long long> process_string(int v, const string &a) {
long long res = 0;
for (char c : a) {
v = go[v][c];
res += leaf[v];
}
return {v, res};
}
long long calc_cost[1024];
int calc_pos[1024];
void solve() {
memset(go, -1, sizeof go);
int k;
cin >> k;
for (int i = 1; i <= k; ++i) {
string a;
cin >> a;
int v = 0;
for (int c : a) {
c = c - 'a';
if (go[v][c] == -1) {
go[v][c] = top++;
}
v = go[v][c];
}
int cost;
cin >> cost;
leaf[v] += cost;
}
build();
string t;
cin >> t;
for (char &c : t) {
if (c == '?') {
continue;
}
c = c - 'a';
}
vector<int> pos;
for (int i = 0; i < (int(t.size())); ++i) {
if (t[i] == '?') {
pos.push_back(i);
}
}
long long ans = 0;
if (pos.empty()) {
int v = 0;
for (char c : t) {
v = go[v][c];
ans += leaf[v];
}
cout << ans << "\n";
return;
}
int st = pos[0];
for (int i = 0; i < (1 << 14); ++i) {
fill(dp[0][i], dp[0][i] + 1024, -inf_ll);
fill(dp[1][i], dp[1][i] + 1024, -inf_ll);
}
auto x = process_string(0, t.substr(0, st));
dp[0][0][x.first] = x.second;
42;
for (int i = 0; i < (int(pos.size())); ++i) {
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
if (dp[0][mask][v] != -inf_ll) {
long long val = dp[0][mask][v];
for (int c = 0; c < 14; ++c) {
if (!(mask & (1 << c))) {
int to = go[v][c];
dp[1][mask | (1 << c)][to] =
max(dp[1][mask | (1 << c)][to], val + leaf[to]);
}
}
dp[0][mask][v] = -inf_ll;
}
}
}
string to_nxt = "";
if (i + 1 < (int(pos.size()))) {
to_nxt = t.substr(pos[i] + 1, pos[i + 1] - pos[i] - 1);
} else {
to_nxt = t.substr(pos[i] + 1, (int(t.size())) - pos[i] - 1);
}
42;
for (int v = 0; v < top; ++v) {
auto x = process_string(v, to_nxt);
calc_cost[v] = x.second;
calc_pos[v] = x.first;
}
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
if (dp[1][mask][v] != -inf_ll) {
dp[0][mask][calc_pos[v]] =
max(dp[0][mask][calc_pos[v]], dp[1][mask][v] + calc_cost[v]);
dp[1][mask][v] = -inf_ll;
}
}
}
}
ans = -inf_ll;
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
ans = max(ans, dp[0][mask][v]);
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(2);
int t = 1;
while (t--) {
solve();
}
42;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
This problem is interactive.
We have hidden a permutation p_1, p_2, ..., p_n of numbers from 1 to n from you, where n is even. You can try to guess it using the following queries:
? k a_1 a_2 ... a_k.
In response, you will learn if the average of elements with indexes a_1, a_2, ..., a_k is an integer. In other words, you will receive 1 if \frac{p_{a_1} + p_{a_2} + ... + p_{a_k}}{k} is integer, and 0 otherwise.
You have to guess the permutation. You can ask not more than 18n queries.
Note that permutations [p_1, p_2, ..., p_k] and [n + 1 - p_1, n + 1 - p_2, ..., n + 1 - p_k] are indistinguishable. Therefore, you are guaranteed that p_1 β€ n/2.
Note that the permutation p is fixed before the start of the interaction and doesn't depend on your queries. In other words, interactor is not adaptive.
Note that you don't have to minimize the number of queries.
Input
The first line contains a single integer n (2 β€ n β€ 800, n is even).
Interaction
You begin the interaction by reading n.
To ask a question about elements on positions a_1, a_2, ..., a_k, in a separate line output
? k a_1 a_2 ... a_k
Numbers in the query have to satisfy 1 β€ a_i β€ n, and all a_i have to be different. Don't forget to 'flush', to get the answer.
In response, you will receive 1 if \frac{p_{a_1} + p_{a_2} + ... + p_{a_k}}{k} is integer, and 0 otherwise.
In case your query is invalid or you asked more than 18n queries, the program will print -1 and will finish interaction. You will receive a Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.
When you determine permutation, output
! p_1 p_2 ... p_n
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hack format
For the hacks use the following format:
The first line has to contain a single integer n (2 β€ n β€ 800, n is even).
In the next line output n integers p_1, p_2, ..., p_n β the valid permutation of numbers from 1 to n. p_1 β€ n/2 must hold.
Example
Input
2
1 2
Output
? 1 2
? 1 1
! 1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int pos, v, n, k;
cin >> n >> k;
map<int, int> m;
int mx = -1;
for (int i = 1; i <= k + 1; i++) {
cout << "? ";
for (int j = 1; j <= k + 1; j++) {
if (j != i) cout << j << " ";
}
cout << endl;
cin >> pos >> v;
m[v]++;
mx = max(mx, v);
}
cout << "! " << m[mx] << "\n";
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Lavrenty, a baker, is going to make several buns with stuffings and sell them.
Lavrenty has n grams of dough as well as m different stuffing types. The stuffing types are numerated from 1 to m. Lavrenty knows that he has ai grams left of the i-th stuffing. It takes exactly bi grams of stuffing i and ci grams of dough to cook a bun with the i-th stuffing. Such bun can be sold for di tugriks.
Also he can make buns without stuffings. Each of such buns requires c0 grams of dough and it can be sold for d0 tugriks. So Lavrenty can cook any number of buns with different stuffings or without it unless he runs out of dough and the stuffings. Lavrenty throws away all excess material left after baking.
Find the maximum number of tugriks Lavrenty can earn.
Input
The first line contains 4 integers n, m, c0 and d0 (1 β€ n β€ 1000, 1 β€ m β€ 10, 1 β€ c0, d0 β€ 100). Each of the following m lines contains 4 integers. The i-th line contains numbers ai, bi, ci and di (1 β€ ai, bi, ci, di β€ 100).
Output
Print the only number β the maximum number of tugriks Lavrenty can earn.
Examples
Input
10 2 2 1
7 3 2 100
12 3 1 10
Output
241
Input
100 1 25 50
15 5 20 10
Output
200
Note
To get the maximum number of tugriks in the first sample, you need to cook 2 buns with stuffing 1, 4 buns with stuffing 2 and a bun without any stuffing.
In the second sample Lavrenty should cook 4 buns without stuffings.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000 /HEAP:10000000")
using namespace std;
struct nachinka {
int a;
int b;
int c;
int d;
};
struct answer {
vector<int> nach;
int ans;
};
int main() {
int i, j, n, m, c0, d0, M, pos;
nachinka p;
answer P, nul;
cin >> n >> m >> c0 >> d0;
M = c0;
vector<nachinka> v;
for (i = 0; i < m; i++) {
cin >> p.a >> p.b >> p.c >> p.d;
if (p.c < M) M = p.c;
v.push_back(p);
}
P.nach.assign(m, 0);
P.ans = 0;
nul = P;
vector<answer> dp;
dp.push_back(P);
for (i = 1; i <= n; i++) {
if (i < M) {
dp.push_back(P);
continue;
}
P.ans = 0;
pos = -1;
for (j = 0; j < m; j++)
if (i >= v[j].c) {
if (dp[i - v[j].c].ans + v[j].d > P.ans &&
(dp[i - v[j].c].nach[j] + 1) * v[j].b <= v[j].a) {
P.ans = dp[i - v[j].c].ans + v[j].d;
pos = j;
}
}
if (i >= c0 && dp[i - c0].ans + d0 >= P.ans) {
P.nach = dp[i - c0].nach;
P.ans = dp[i - c0].ans + d0;
dp.push_back(P);
} else if (pos != -1) {
P.nach = dp[i - v[pos].c].nach;
P.nach[pos] = dp[i - v[pos].c].nach[pos] + 1;
dp.push_back(P);
} else
dp.push_back(P);
}
M = -1;
for (i = 1; i <= n; i++) M = max(M, dp[i].ans);
cout << M;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The next "Data Structures and Algorithms" lesson will be about Longest Increasing Subsequence (LIS for short) of a sequence. For better understanding, Nam decided to learn it a few days before the lesson.
Nam created a sequence a consisting of n (1 β€ n β€ 105) elements a1, a2, ..., an (1 β€ ai β€ 105). A subsequence ai1, ai2, ..., aik where 1 β€ i1 < i2 < ... < ik β€ n is called increasing if ai1 < ai2 < ai3 < ... < aik. An increasing subsequence is called longest if it has maximum length among all increasing subsequences.
Nam realizes that a sequence may have several longest increasing subsequences. Hence, he divides all indexes i (1 β€ i β€ n), into three groups:
1. group of all i such that ai belongs to no longest increasing subsequences.
2. group of all i such that ai belongs to at least one but not every longest increasing subsequence.
3. group of all i such that ai belongs to every longest increasing subsequence.
Since the number of longest increasing subsequences of a may be very large, categorizing process is very difficult. Your task is to help him finish this job.
Input
The first line contains the single integer n (1 β€ n β€ 105) denoting the number of elements of sequence a.
The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 105).
Output
Print a string consisting of n characters. i-th character should be '1', '2' or '3' depending on which group among listed above index i belongs to.
Examples
Input
1
4
Output
3
Input
4
1 3 2 5
Output
3223
Input
4
1 5 2 3
Output
3133
Note
In the second sample, sequence a consists of 4 elements: {a1, a2, a3, a4} = {1, 3, 2, 5}. Sequence a has exactly 2 longest increasing subsequences of length 3, they are {a1, a2, a4} = {1, 3, 5} and {a1, a3, a4} = {1, 2, 5}.
In the third sample, sequence a consists of 4 elements: {a1, a2, a3, a4} = {1, 5, 2, 3}. Sequence a have exactly 1 longest increasing subsequence of length 3, that is {a1, a3, a4} = {1, 2, 3}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int lowest[100005];
int latest[100005];
vector<vector<pair<int, int> > > dp(100005);
class segment {
int holder[100005 * 4];
public:
void init() { memset(holder, 0, sizeof(holder)); }
int update(int k, int l, int r, int pos, int val) {
if (l == r && l == pos) {
return holder[k] = val;
}
if (l > pos || r < pos) {
return holder[k];
}
return holder[k] = max(update(k * 2, l, (l + r) / 2, pos, val),
update(k * 2 + 1, (l + r) / 2 + 1, r, pos, val));
}
int find(int k, int l, int r, int a, int b) {
if (l >= a && r <= b) {
return holder[k];
}
if (l > b || r < a) {
return 0;
}
return max(find(k * 2, l, (l + r) / 2, a, b),
find(k * 2 + 1, (l + r) / 2 + 1, r, a, b));
}
};
int main(int argc, const char* argv[]) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
lowest[i] = 1000000000;
}
int longest = 0;
for (int i = 0; i < n; i++) {
int low = 0, high = longest;
while (low < high) {
int mid = (low + high) / 2;
if (arr[i] > lowest[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
if (arr[i] > lowest[low]) {
dp[low + 1].push_back(pair<int, int>(i, arr[i]));
lowest[low + 1] = min(lowest[low + 1], arr[i]);
longest = max(longest, low + 1);
} else {
dp[low].push_back(pair<int, int>(i, arr[i]));
lowest[low] = arr[i];
}
}
map<int, int> res;
segment sg;
sg.init();
for (int i = 0; i < dp[longest].size(); i++) {
res[dp[longest][i].first] = (dp[longest].size() == 1) + 2;
sg.update(1, 1, n, dp[longest][i].first + 1, dp[longest][i].second);
}
for (int i = longest - 1; i >= 1; i--) {
bool b = true;
int k = -1;
for (int j = 0; j < dp[i].size(); j++) {
if (sg.find(1, 1, n, dp[i][j].first + 1, n) <= dp[i][j].second) {
continue;
}
res[dp[i][j].first] = 2;
sg.update(1, 1, n, dp[i][j].first + 1, dp[i][j].second);
if (k == -1) {
k = dp[i][j].first;
} else {
b = false;
}
}
for (int j = 0; j < dp[i + 1].size(); j++) {
sg.update(1, 1, n, dp[i + 1][j].first + 1, 0);
}
if (b) {
res[k] = 3;
}
}
for (int i = 0; i < n; i++) {
cout << max(1, res[i]);
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A palindrome is a string that reads the same backward as forward. For example, the strings "z", "aaa", "aba", and "abccba" are palindromes, but "codeforces" and "ab" are not. You hate palindromes because they give you dΓ©jΓ vu.
There is a string s. You must insert exactly one character 'a' somewhere in s. If it is possible to create a string that is not a palindrome, you should find one example. Otherwise, you should report that it is impossible.
For example, suppose s= "cbabc". By inserting an 'a', you can create "acbabc", "cababc", "cbaabc", "cbabac", or "cbabca". However "cbaabc" is a palindrome, so you must output one of the other options.
Input
The first line contains a single integer t (1β€ tβ€ 10^4) β the number of test cases.
The only line of each test case contains a string s consisting of lowercase English letters.
The total length of all strings does not exceed 3β
10^5.
Output
For each test case, if there is no solution, output "NO".
Otherwise, output "YES" followed by your constructed string of length |s|+1 on the next line. If there are multiple solutions, you may print any.
You can print each letter of "YES" and "NO" in any case (upper or lower).
Example
Input
6
cbabc
ab
zza
ba
a
nutforajaroftuna
Output
YES
cbabac
YES
aab
YES
zaza
YES
baa
NO
YES
nutforajarofatuna
Note
The first test case is described in the statement.
In the second test case, we can make either "aab" or "aba". But "aba" is a palindrome, so "aab" is the only correct answer.
In the third test case, "zaza" and "zzaa" are correct answers, but not "azza".
In the fourth test case, "baa" is the only correct answer.
In the fifth test case, we can only make "aa", which is a palindrome. So the answer is "NO".
In the sixth test case, "anutforajaroftuna" is a palindrome, but inserting 'a' elsewhere is valid.
### Response
```cpp
#include <bits/stdc++.h>
#include<iostream>
#include<string.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#define ll long long int
#define ull unsigned long long
#define lcm(a,b) a*b/__gcd(a,b)
#define gcd(a,b) __gcd(a,b)
//vectors & pairs
#define all(a) a.begin(),a.end()
#define pb(x) push_back(x)
#define eb(x,y) emplace_back(x,y)
#define vi vector<int>
#define vll vector<ll>
#define vull vector<ull>
#define vvi vector<vector<int>>
#define vvll vector<vector<ll>>
#define vpll vector<pair<ll,ll>>
#define vp vector<pair<int,int>>
#define mp make_pair
#define sortVA(a) sort(a.begin(),a.end())
#define sortVD(a) sort(a.rbegin(),a.rend())
//map
#define f first
#define s second
//constants
double PIE = 3.1415926536;
int MOD = 1000000007;
int MAX = (1e9 + 5);
int MIN = -(1e9 + 5);
#define endl "\n"
//loop
#define ff(i,s,e) for(i=(int)s; i< (int)e; i++)
#define rff(i,s,e) for(i=(int)e; i>=(int)s; i--)
#define vff(a) for(auto x: a)
#define read(a) for(auto &x: a) cin>>x;
#define put(a) for(auto &x: a) cout<<x<<" "; cout<<endl;
// global variables
int i,j;
//helper functions
ll ceil_div(ll x, ll y){
return (x + y - 1) / y;
}
//coding starts here
void test_cases(){
string s;
cin>>s;
int n=s.length();
string temp3=s;
int flag=1;
ff(i,0,n){
if(s[i]!='a'){
flag=0;
}
}
if(flag){
cout<<"NO"<<endl;
return;
}
cout<<"YES"<<endl;
string temp2, temp;
temp2 ='a' + s;
temp=temp2;
reverse(all(temp));
if(temp!=temp2){
cout<<temp2<<endl;
return;
}
temp2 = s + 'a';
temp=temp2;
reverse(all(temp));
if(temp!=temp2){
cout<<temp2<<endl;
return;
}
return;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T=1;
cin>>T;
while(T--){
test_cases();
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
We have a directed weighted graph with N vertices. Each vertex has two integers written on it, and the integers written on Vertex i are A_i and B_i.
In this graph, there is an edge from Vertex x to Vertex y for all pairs 1 \leq x,y \leq N, and its weight is {\rm min}(A_x,B_y).
We will consider a directed cycle in this graph that visits every vertex exactly once. Find the minimum total weight of the edges in such a cycle.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_N B_N
Output
Print the minimum total weight of the edges in such a cycle.
Examples
Input
3
1 5
4 2
6 3
Output
7
Input
4
1 5
2 6
3 7
4 8
Output
10
Input
6
19 92
64 64
78 48
57 33
73 6
95 73
Output
227
### Response
```cpp
#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
using namespace std;
int main(){
int n;
cin >> n;
vector<pair<int, int>> p;
long long as = 0, bs = 0, ans = 0;
for(int i = 0; i < n; i++){
int a, b;
cin >> a >> b;
p.push_back({a, i});
p.push_back({b, i});
as += a;
bs += b;
}
ans = min(as, bs);
sort(p.begin(), p.end());
vector<int> e(n);
for(int i = 0; i < n; i++){
e[p[i].second] = 1;
}
if(find(e.begin(), e.end(), 0) == e.end()){
int q1, q2, q3, q4, d1, d2;
if(p[n - 1].second != p[n].second){
q1 = n - 1, q2 = n;
}else{
q1 = n - 1, q2 = n + 1;
}
if(p[n - 2].second != p[n].second){
q3 = n - 2, q4 = n;
} else{
q3 = n - 2, q4 = n + 1;
}
d1 = p[q2].first - p[q1].first;
d2 = p[q4].first - p[q3].first;
if(d1 <= d2) swap(p[q1], p[q2]);
else swap(p[q3], p[q4]);
}
long long sum = 0;
for(int i = 0; i < n; i++){
sum += p[i].first;
}
ans = min(ans, sum);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Vasya has got a robot which is situated on an infinite Cartesian plane, initially in the cell (0, 0). Robot can perform the following four kinds of operations:
* U β move from (x, y) to (x, y + 1);
* D β move from (x, y) to (x, y - 1);
* L β move from (x, y) to (x - 1, y);
* R β move from (x, y) to (x + 1, y).
Vasya also has got a sequence of n operations. Vasya wants to modify this sequence so after performing it the robot will end up in (x, y).
Vasya wants to change the sequence so the length of changed subsegment is minimum possible. This length can be calculated as follows: maxID - minID + 1, where maxID is the maximum index of a changed operation, and minID is the minimum index of a changed operation. For example, if Vasya changes RRRRRRR to RLRRLRL, then the operations with indices 2, 5 and 7 are changed, so the length of changed subsegment is 7 - 2 + 1 = 6. Another example: if Vasya changes DDDD to DDRD, then the length of changed subsegment is 1.
If there are no changes, then the length of changed subsegment is 0. Changing an operation means replacing it with some operation (possibly the same); Vasya can't insert new operations into the sequence or remove them.
Help Vasya! Tell him the minimum length of subsegment that he needs to change so that the robot will go from (0, 0) to (x, y), or tell him that it's impossible.
Input
The first line contains one integer number n~(1 β€ n β€ 2 β
10^5) β the number of operations.
The second line contains the sequence of operations β a string of n characters. Each character is either U, D, L or R.
The third line contains two integers x, y~(-10^9 β€ x, y β€ 10^9) β the coordinates of the cell where the robot should end its path.
Output
Print one integer β the minimum possible length of subsegment that can be changed so the resulting sequence of operations moves the robot from (0, 0) to (x, y). If this change is impossible, print -1.
Examples
Input
5
RURUU
-2 3
Output
3
Input
4
RULR
1 1
Output
0
Input
3
UUU
100 100
Output
-1
Note
In the first example the sequence can be changed to LULUU. So the length of the changed subsegment is 3 - 1 + 1 = 3.
In the second example the given sequence already leads the robot to (x, y), so the length of the changed subsegment is 0.
In the third example the robot can't end his path in the cell (x, y).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
const double EPS = 1e-9;
const double pi = acos(-1);
template <class T>
T smod(T a, T b) {
return (a % b + b) % b;
}
int need[200], have[200];
int main() {
memset(need, 0, sizeof(need));
memset(have, 0, sizeof(have));
int sx = 0, sy = 0;
int n;
cin >> n;
string s;
cin >> s;
for (decltype(0) i = (0); i < (n); ++i) {
if (s[i] == 'U') sy++;
if (s[i] == 'R') sx++;
if (s[i] == 'D') sy--;
if (s[i] == 'L') sx--;
}
int ex, ey;
cin >> ex >> ey;
int dist = abs(ex - sx) + abs(ey - sy);
int mn = INF;
int l = 0, r = 0;
while (l < n) {
while (r < n) {
int px = sx - have['R'] + have['L'], py = sy - have['U'] + have['D'];
int dist = abs(ex - px) + abs(ey - py);
if (dist % 2 == (r - l) % 2 && dist <= r - l) break;
have[s[r]]++;
r++;
}
int px = sx - have['R'] + have['L'], py = sy - have['U'] + have['D'];
int dist = abs(ex - px) + abs(ey - py);
if (dist % 2 == (r - l) % 2 && dist <= r - l) mn = min(mn, r - l);
have[s[l]]--;
l++;
}
if (mn == INF)
cout << -1 << endl;
else
cout << max(mn, 0) << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Iahub and Iahubina went to a date at a luxury restaurant. Everything went fine until paying for the food. Instead of money, the waiter wants Iahub to write a Hungry sequence consisting of n integers.
A sequence a1, a2, ..., an, consisting of n integers, is Hungry if and only if:
* Its elements are in increasing order. That is an inequality ai < aj holds for any two indices i, j (i < j).
* For any two indices i and j (i < j), aj must not be divisible by ai.
Iahub is in trouble, so he asks you for help. Find a Hungry sequence with n elements.
Input
The input contains a single integer: n (1 β€ n β€ 105).
Output
Output a line that contains n space-separated integers a1 a2, ..., an (1 β€ ai β€ 107), representing a possible Hungry sequence. Note, that each ai must not be greater than 10000000 (107) and less than 1.
If there are multiple solutions you can output any one.
Examples
Input
3
Output
2 9 15
Input
5
Output
11 14 20 27 31
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
bool x[10010000];
void sieve() {
for (int i = 2; i <= 10000000; i++) {
if (x[i]) continue;
for (int c = i + i; c <= 10000000; c += i) x[c] = 1;
primes.push_back(i);
}
return;
}
int main() {
sieve();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) printf("%d ", primes[i]);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
The goal of the 8 puzzle problem is to complete pieces on $3 \times 3$ cells where one of the cells is empty space.
In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 8 as shown below.
1 3 0
4 2 5
7 8 6
You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).
1 2 3
4 5 6
7 8 0
Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.
Constraints
* There is a solution.
Input
The $3 \times 3$ integers denoting the pieces or space are given.
Output
Print the fewest steps in a line.
Example
Input
1 3 0
4 2 5
7 8 6
Output
4
### Response
```cpp
#include <iostream>
#include <map>
#include <queue>
#include <vector>
#define N 3
#define N2 9
using namespace std;
struct game{
int b[N2];
bool operator < (const game &other) const{
for(int i=0;i<N2;i++){
if(b[i]<other.b[i]){
return true;
}else if(b[i]>other.b[i]){
return false;
}
}
return false;
}
};
game g;
map<game,int> checked;
queue<game> q;
void print(game _g){
for(int i=0;i<N2;i++)
printf("%d ",_g.b[i]);
printf("\n");
}
bool clear(game _g){
for(int i=0;i<N2;i++){
if(_g.b[i]!=i+1) return false;
}
return true;
}
int solve(){
q.push(g);
checked.insert(make_pair(g,0));
int depth;
while(!q.empty()){
g=q.front();q.pop();
depth=checked[g];
if(clear(g)){ return depth; }
int w;
for(int i=0;i<N2;i++){
if(g.b[i]==N2) {
w=i;
break;
}
}
vector<int> v;
if(w%N<N-1) v.push_back(1);
if(w%N>0 ) v.push_back(-1);
if(w/N<N-1) v.push_back(N);
if(w/N>0 ) v.push_back(-N);
for(int i:v){
game gt=g;
swap(gt.b[w],gt.b[w+i]);
if(checked.find(gt)==checked.end()){
q.push(gt);
checked.insert(make_pair(gt,depth+1));
}
}
}
return -1;
}
int main(){
for(int i=0;i<N2;i++) {
int tmp; cin>>tmp;
if(tmp==0) tmp=N2;
g.b[i]=tmp;
}
cout<<solve()<<endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).
Input
The first line contains the single positive integer n (1 β€ n β€ 105) β the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.
Examples
Input
4
7 3 2 1
Output
2
Input
3
1 1 1
Output
3
Note
In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).
In the second example all pairs of indexes (i, j) (where i < j) include in answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
map<long long, int> mp;
map<long long, int> mp2;
map<long long, int> mp3;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
for (int i = 0; i < n; i++) {
for (long long j = 2; j < 1e12; j *= 2) {
if (j - a[i] == a[i] && mp[a[i]] > 0) {
mp2[j - a[i]]++;
} else if (j - a[i] != a[i]) {
mp3[j - a[i]]++;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += (mp2[a[i]] / mp[a[i]]) * (mp[a[i]] - 1);
ans += mp3[a[i]];
}
cout << ans / 2 << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 β€ N β€ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 β€ ki β€ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n,cnt;
int k[10000];
bool f;
while(scanf("%d",&n)&&n){
cnt=0;
f=false;
for(int i=0;i<n;i++)scanf("%d",&k[i]);
for(int i=0;i<n;i++){
if(k[i]>0){
cnt++;
}
if(k[i]>1){
f=true;
}
}
if(f)printf("%d\n",cnt+1);
else printf("NA\n");
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Yaroslav calls an array of r integers a1, a2, ..., ar good, if it meets the following conditions: |a1 - a2| = 1, |a2 - a3| = 1, ..., |ar - 1 - ar| = 1, |ar - a1| = 1, at that <image>.
An array of integers b1, b2, ..., br is called great, if it meets the following conditions:
1. The elements in it do not decrease (bi β€ bi + 1).
2. If the inequalities 1 β€ r β€ n and 1 β€ bi β€ m hold.
3. If we can rearrange its elements and get at least one and at most k distinct good arrays.
Yaroslav has three integers n, m, k. He needs to count the number of distinct great arrays. Help Yaroslav! As the answer may be rather large, print the remainder after dividing it by 1000000007 (109 + 7).
Two arrays are considered distinct if there is a position in which they have distinct numbers.
Input
The single line contains three integers n, m, k (1 β€ n, m, k β€ 100).
Output
In a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
0
Input
3 3 3
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int NN = 110;
const int MM = 55;
int dp[MM][MM][MM][NN], c[NN][NN];
void add(int &u, int v) {
u += v;
if (u >= mod) u -= mod;
}
int main() {
for (int i = (0); i < (NN); i++)
for (int j = (0); j < (i + 1); j++) {
c[i][j] = (i == 0 || j == 0) ? 1 : (c[i - 1][j] + c[i - 1][j - 1]);
c[i][j] = min(c[i][j], NN);
}
int N, M, K, ans = 0, i, s, lst, w, res, nxt;
scanf("%d%d%d", &N, &M, &K);
dp[0][0][0][1] = 1;
for (i = 0; i < M && i <= N / 2; i++) {
for (s = 0; s <= N / 2; s++) {
for (lst = 0; lst <= N / 2; lst++) {
for (w = 1; w <= K; w++) {
res = dp[i][s][lst][w];
if (!res) continue;
if (i > 0) add(ans, 1LL * res * (M - i) % mod);
for (nxt = 1; nxt + s <= N / 2; nxt++) {
int ww = w * c[lst + nxt - 1][nxt - 1];
if (ww <= K) add(dp[i + 1][s + nxt][nxt][ww], res);
}
}
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vasilisa the Wise from the Kingdom of Far Far Away got a magic box with a secret as a present from her friend Hellawisa the Wise from the Kingdom of A Little Closer. However, Vasilisa the Wise does not know what the box's secret is, since she cannot open it again. She hopes that you will help her one more time with that.
The box's lock looks as follows: it contains 4 identical deepenings for gems as a 2 Γ 2 square, and some integer numbers are written at the lock's edge near the deepenings. The example of a lock is given on the picture below.
<image>
The box is accompanied with 9 gems. Their shapes match the deepenings' shapes and each gem contains one number from 1 to 9 (each number is written on exactly one gem). The box will only open after it is decorated with gems correctly: that is, each deepening in the lock should be filled with exactly one gem. Also, the sums of numbers in the square's rows, columns and two diagonals of the square should match the numbers written at the lock's edge. For example, the above lock will open if we fill the deepenings with gems with numbers as is shown on the picture below.
<image>
Now Vasilisa the Wise wants to define, given the numbers on the box's lock, which gems she should put in the deepenings to open the box. Help Vasilisa to solve this challenging task.
Input
The input contains numbers written on the edges of the lock of the box. The first line contains space-separated integers r1 and r2 that define the required sums of numbers in the rows of the square. The second line contains space-separated integers c1 and c2 that define the required sums of numbers in the columns of the square. The third line contains space-separated integers d1 and d2 that define the required sums of numbers on the main and on the side diagonals of the square (1 β€ r1, r2, c1, c2, d1, d2 β€ 20). Correspondence between the above 6 variables and places where they are written is shown on the picture below. For more clarifications please look at the second sample test that demonstrates the example given in the problem statement.
<image>
Output
Print the scheme of decorating the box with stones: two lines containing two space-separated integers from 1 to 9. The numbers should be pairwise different. If there is no solution for the given lock, then print the single number "-1" (without the quotes).
If there are several solutions, output any.
Examples
Input
3 7
4 6
5 5
Output
1 2
3 4
Input
11 10
13 8
5 16
Output
4 7
9 1
Input
1 2
3 4
5 6
Output
-1
Input
10 10
10 10
10 10
Output
-1
Note
Pay attention to the last test from the statement: it is impossible to open the box because for that Vasilisa the Wise would need 4 identical gems containing number "5". However, Vasilisa only has one gem with each number from 1 to 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int r1, r2, c1, c2, d1, d2;
void fun() {
int val1, val2, val3, val4;
for (int i = 1; i < 10; i++) {
val1 = i;
val2 = r1 - val1;
val3 = c1 - val1;
val4 = c2 - val2;
if (val1 == val2 || val1 == val3 || val1 == val4 || val2 == val3 ||
val3 == val4 || val3 == val4 || val2 == val4 || val1 < 1 || val2 < 1 ||
val3 < 1 || val4 < 1 || val1 > 9 || val2 > 9 || val3 > 9 || val4 > 9)
continue;
if (val1 + val2 == r1 && val1 + val3 == c1 && val1 + val4 == d1 &&
val2 + val3 == d2 && val2 + val4 == c2 && val3 + val4 == r2) {
cout << val1 << " " << val2 << endl << val3 << " " << val4 << endl;
return;
}
}
cout << -1 << endl;
return;
}
int main() {
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
fun();
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a matrix a, consisting of n rows and m columns. Each cell contains an integer in it.
You can change the order of rows arbitrarily (including leaving the initial order), but you can't change the order of cells in a row. After you pick some order of rows, you traverse the whole matrix the following way: firstly visit all cells of the first column from the top row to the bottom one, then the same for the second column and so on. During the traversal you write down the sequence of the numbers on the cells in the same order you visited them. Let that sequence be s_1, s_2, ..., s_{nm}.
The traversal is k-acceptable if for all i (1 β€ i β€ nm - 1) |s_i - s_{i + 1}| β₯ k.
Find the maximum integer k such that there exists some order of rows of matrix a that it produces a k-acceptable traversal.
Input
The first line contains two integers n and m (1 β€ n β€ 16, 1 β€ m β€ 10^4, 2 β€ nm) β the number of rows and the number of columns, respectively.
Each of the next n lines contains m integers (1 β€ a_{i, j} β€ 10^9) β the description of the matrix.
Output
Print a single integer k β the maximum number such that there exists some order of rows of matrix a that it produces an k-acceptable traversal.
Examples
Input
4 2
9 9
10 8
5 3
4 3
Output
5
Input
2 4
1 2 3 4
10 3 7 3
Output
0
Input
6 1
3
6
2
5
1
4
Output
3
Note
In the first example you can rearrange rows as following to get the 5-acceptable traversal:
5 3
10 8
4 3
9 9
Then the sequence s will be [5, 10, 4, 9, 3, 8, 3, 9]. Each pair of neighbouring elements have at least k = 5 difference between them.
In the second example the maximum k = 0, any order is 0-acceptable.
In the third example the given order is already 3-acceptable, you can leave it as it is.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 18;
const int M = 100 * 1000 + 13;
const int INF = 1e9;
int dp[1 << N][N];
int n, m;
int a[N][M];
int mn1[N][N], mn2[N][N];
int calc(int mask, int v) {
if (dp[mask][v] != -1) return dp[mask][v];
dp[mask][v] = 0;
for (int u = 0; u < int(n); u++)
if (v != u && ((mask >> u) & 1))
dp[mask][v] = max(dp[mask][v], min(mn1[u][v], calc(mask ^ (1 << v), u)));
return dp[mask][v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) scanf("%d", &a[i][j]);
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(n); j++) {
int val = INF;
for (int k = 0; k < int(m); k++) val = min(val, abs(a[i][k] - a[j][k]));
mn1[i][j] = val;
val = INF;
for (int k = 0; k < int(m - 1); k++)
val = min(val, abs(a[i][k] - a[j][k + 1]));
mn2[i][j] = val;
}
int ans = 0;
for (int i = 0; i < int(n); i++) {
memset(dp, -1, sizeof(dp));
for (int j = 0; j < int(n); j++) dp[1 << j][j] = (j == i ? INF : 0);
for (int j = 0; j < int(n); j++)
ans = max(ans, min(mn2[j][i], calc((1 << n) - 1, j)));
}
printf("%d\n", ans);
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a positive integer n. Let's build a graph on vertices 1, 2, ..., n in such a way that there is an edge between vertices u and v if and only if <image>. Let d(u, v) be the shortest distance between u and v, or 0 if there is no path between them. Compute the sum of values d(u, v) over all 1 β€ u < v β€ n.
The gcd (greatest common divisor) of two positive integers is the maximum positive integer that divides both of the integers.
Input
Single integer n (1 β€ n β€ 107).
Output
Print the sum of d(u, v) over all 1 β€ u < v β€ n.
Examples
Input
6
Output
8
Input
10
Output
44
Note
All shortest paths in the first example:
* <image>
* <image>
* <image>
* <image>
* <image>
* <image>
There are no paths between other pairs of vertices.
The total distance is 2 + 1 + 1 + 2 + 1 + 1 = 8.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
int phi[N], fen[N], f[N];
bool pr[N];
void upd(int p, int vl) {
for (p++; p < N; p += p & -p) fen[p] += vl;
return;
}
int get(int p) {
int res = 0;
for (; p > 0; p -= p & -p) res += fen[p];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
long long ans = 0, sum = 0;
for (int i = 1; i <= n; i++) {
phi[i] += i;
if (!pr[i]) f[i] = i;
for (int j = 2 * i; j <= n; j += i) {
phi[j] -= phi[i];
if (i - 1) pr[j] = true;
if (f[j] == 0 && i > 1) f[j] = i;
}
if (i - 1) sum += phi[i];
}
int r = 1;
for (int i = 2; i <= n; i++) {
if (!pr[i] && 2 * i > n) r++;
}
sum -= 1LL * r * (r - 1) / 2 + 1LL * r * (n - r);
sum = 1LL * (n - r) * (n - r - 1) / 2 - sum;
ans += 1LL * (n - r) * (n - r - 1) / 2;
long long k = 0;
for (int i = 2; i <= n; i++) {
int p = f[i];
k += get(n / p + 1);
upd(p, 1);
}
ans += k - sum;
ans += 2LL * (1LL * (n - r) * (n - r - 1) / 2 - k);
cout << ans << endl;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given an n Γ m table, consisting of characters Β«AΒ», Β«GΒ», Β«CΒ», Β«TΒ». Let's call a table nice, if every 2 Γ 2 square contains all four distinct characters. Your task is to find a nice table (also consisting of Β«AΒ», Β«GΒ», Β«CΒ», Β«TΒ»), that differs from the given table in the minimum number of characters.
Input
First line contains two positive integers n and m β number of rows and columns in the table you are given (2 β€ n, m, n Γ m β€ 300 000). Then, n lines describing the table follow. Each line contains exactly m characters Β«AΒ», Β«GΒ», Β«CΒ», Β«TΒ».
Output
Output n lines, m characters each. This table must be nice and differ from the input table in the minimum number of characters.
Examples
Input
2 2
AG
CT
Output
AG
CT
Input
3 5
AGCAG
AGCAG
AGCAG
Output
TGCAT
CATGC
TGCAT
Note
In the first sample, the table is already nice. In the second sample, you can change 9 elements to make the table nice.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, ma;
vector<string> en;
vector<string> res;
vector<string> can;
int che(int i, char c1, char c2) {
int c = 0;
int j;
for (j = 0; j < m; j += 2)
if (en[i][j] == c1) c++;
for (j = 1; j < m; j += 2)
if (en[i][j] == c2) c++;
return c;
}
int che2(int j, char c1, char c2) {
int c = 0;
int i;
for (i = 0; i < n; i += 2)
if (en[i][j] == c1) c++;
for (i = 1; i < n; i += 2)
if (en[i][j] == c2) c++;
return c;
}
void p1(int i, char c1, char c2) {
int j;
for (j = 0; j < m; j += 2) can[i][j] = c1;
for (j = 1; j < m; j += 2) can[i][j] = c2;
}
void p2(int j, char c1, char c2) {
int i;
for (i = 0; i < n; i += 2) can[i][j] = c1;
for (i = 1; i < n; i += 2) can[i][j] = c2;
}
void fu(char c1, char c2, char c3, char c4) {
int i, mc = 0, ca1, ca2;
for (i = 0; i < n; i += 2) {
ca1 = che(i, c1, c2);
ca2 = che(i, c2, c1);
if (ca1 > ca2) {
mc += ca1;
p1(i, c1, c2);
} else {
mc += ca2;
p1(i, c2, c1);
}
}
for (i = 1; i < n; i += 2) {
ca1 = che(i, c3, c4);
ca2 = che(i, c4, c3);
if (ca1 > ca2) {
mc += ca1;
p1(i, c3, c4);
} else {
mc += ca2;
p1(i, c4, c3);
}
}
if (mc > ma) {
ma = mc;
res = can;
}
mc = 0;
for (i = 0; i < m; i += 2) {
ca1 = che2(i, c1, c2);
ca2 = che2(i, c2, c1);
if (ca1 > ca2) {
mc += ca1;
p2(i, c1, c2);
} else {
mc += ca2;
p2(i, c2, c1);
}
}
for (i = 1; i < m; i += 2) {
ca1 = che2(i, c3, c4);
ca2 = che2(i, c4, c3);
if (ca1 > ca2) {
mc += ca1;
p2(i, c3, c4);
} else {
mc += ca2;
p2(i, c4, c3);
}
}
if (mc > ma) {
ma = mc;
res = can;
}
}
int main() {
cin >> n >> m;
en.resize(n);
can.resize(n);
int i, ma = 0;
for (i = 0; i < n; i++) {
cin >> en[i];
can[i] = en[i];
}
fu('G', 'C', 'T', 'A');
fu('G', 'T', 'C', 'A');
fu('G', 'A', 'T', 'C');
fu('A', 'C', 'G', 'T');
fu('T', 'C', 'G', 'A');
fu('T', 'A', 'G', 'C');
for (i = 0; i < n; i++) {
cout << res[i] << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
A film festival is coming up in the city N. The festival will last for exactly n days and each day will have a premiere of exactly one film. Each film has a genre β an integer from 1 to k.
On the i-th day the festival will show a movie of genre ai. We know that a movie of each of k genres occurs in the festival programme at least once. In other words, each integer from 1 to k occurs in the sequence a1, a2, ..., an at least once.
Valentine is a movie critic. He wants to watch some movies of the festival and then describe his impressions on his site.
As any creative person, Valentine is very susceptive. After he watched the movie of a certain genre, Valentine forms the mood he preserves until he watches the next movie. If the genre of the next movie is the same, it does not change Valentine's mood. If the genres are different, Valentine's mood changes according to the new genre and Valentine has a stress.
Valentine can't watch all n movies, so he decided to exclude from his to-watch list movies of one of the genres. In other words, Valentine is going to choose exactly one of the k genres and will skip all the movies of this genre. He is sure to visit other movies.
Valentine wants to choose such genre x (1 β€ x β€ k), that the total number of after-movie stresses (after all movies of genre x are excluded) were minimum.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 105), where n is the number of movies and k is the number of genres.
The second line of the input contains a sequence of n positive integers a1, a2, ..., an (1 β€ ai β€ k), where ai is the genre of the i-th movie. It is guaranteed that each number from 1 to k occurs at least once in this sequence.
Output
Print a single number β the number of the genre (from 1 to k) of the excluded films. If there are multiple answers, print the genre with the minimum number.
Examples
Input
10 3
1 1 2 3 2 3 3 1 1 3
Output
3
Input
7 3
3 1 3 2 3 1 2
Output
1
Note
In the first sample if we exclude the movies of the 1st genre, the genres 2, 3, 2, 3, 3, 3 remain, that is 3 stresses; if we exclude the movies of the 2nd genre, the genres 1, 1, 3, 3, 3, 1, 1, 3 remain, that is 3 stresses; if we exclude the movies of the 3rd genre the genres 1, 1, 2, 2, 1, 1 remain, that is 2 stresses.
In the second sample whatever genre Valentine excludes, he will have exactly 3 stresses.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const int Max = 110000;
int maxz(int x, int y) { return x > y ? x : y; }
int minz(int x, int y) { return x < y ? x : y; }
int a[123456];
int b[123456];
int num[123456];
int main() {
int T, n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int u = 1;
for (i = 1; i < n; i++)
if (a[i] != a[i - 1]) a[u++] = a[i];
num[a[0]] = 1;
for (i = 1; i < u - 1; i++) {
num[a[i]]++;
if (a[i - 1] == a[i + 1]) b[a[i]]++;
}
num[a[i]]++;
int minn = 123456;
int k = 0;
for (i = 1; i <= m; i++)
if (u - 1 - num[i] - b[i] < minn) {
minn = u - 1 - num[i] - b[i];
k = i;
}
printf("%d\n", k);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given a tree with N vertices 1,2,\ldots,N, and positive integers c_1,c_2,\ldots,c_N. The i-th edge in the tree (1 \leq i \leq N-1) connects Vertex a_i and Vertex b_i.
We will write a positive integer on each vertex in T and calculate our score as follows:
* On each edge, write the smaller of the integers written on the two endpoints.
* Let our score be the sum of the integers written on all the edges.
Find the maximum possible score when we write each of c_1,c_2,\ldots,c_N on one vertex in T, and show one way to achieve it. If an integer occurs multiple times in c_1,c_2,\ldots,c_N, we must use it that number of times.
Constraints
* 1 \leq N \leq 10000
* 1 \leq a_i,b_i \leq N
* 1 \leq c_i \leq 10^5
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 \ldots c_N
Output
Use the following format:
M
d_1 \ldots d_N
where M is the maximum possible score, and d_i is the integer to write on Vertex i. d_1,d_2,\ldots,d_N must be a permutation of c_1,c_2,\ldots,c_N. If there are multiple ways to achieve the maximum score, any of them will be accepted.
Examples
Input
5
1 2
2 3
3 4
4 5
1 2 3 4 5
Output
10
1 2 3 4 5
Input
5
1 2
1 3
1 4
1 5
3141 59 26 53 59
Output
197
59 26 3141 59 53
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans;
int a[10005],b[10005];
int c[10005];
int d[10005];
bool v[10005];
vector<int> G[10005];
int N;
void bfs(int x){
queue<int> que;
que.push(x);
while(que.size()){
int t=que.front(); que.pop();
for(int i=0;i<G[t].size();i++){
int e=G[t][i];
//cout<<e<<" ";
if(v[e]==false){
que.push(e);
v[e]=true;
d[e]=c[N];
N--;
//cout<<e<<endl;
}
}
}
}
int main(void){
int n; cin>>n;
for(int i=0;i<n-1;i++){
cin>>a[i]>>b[i];
G[a[i]-1].push_back(b[i]-1); G[b[i]-1].push_back(a[i]-1);
}
for(int i=0;i<n;i++){
cin>>c[i];
ans+=c[i];
}
sort(c,c+n);
ans-=c[n-1];
N=n-1;
d[0]=c[N];
N--;
v[0]=true;
bfs(0);
cout<<ans<<endl;
for(int i=0;i<n;i++){
cout<<d[i];
if(i!=n-1){
cout<<" ";
}
}
cout<<endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
In Arcady's garden there grows a peculiar apple-tree that fruits one time per year. Its peculiarity can be explained in following way: there are n inflorescences, numbered from 1 to n. Inflorescence number 1 is situated near base of tree and any other inflorescence with number i (i > 1) is situated at the top of branch, which bottom is pi-th inflorescence and pi < i.
Once tree starts fruiting, there appears exactly one apple in each inflorescence. The same moment as apples appear, they start to roll down along branches to the very base of tree. Each second all apples, except ones in first inflorescence simultaneously roll down one branch closer to tree base, e.g. apple in a-th inflorescence gets to pa-th inflorescence. Apples that end up in first inflorescence are gathered by Arcady in exactly the same moment. Second peculiarity of this tree is that once two apples are in same inflorescence they annihilate. This happens with each pair of apples, e.g. if there are 5 apples in same inflorescence in same time, only one will not be annihilated and if there are 8 apples, all apples will be annihilated. Thus, there can be no more than one apple in each inflorescence in each moment of time.
Help Arcady with counting number of apples he will be able to collect from first inflorescence during one harvest.
Input
First line of input contains single integer number n (2 β€ n β€ 100 000) β number of inflorescences.
Second line of input contains sequence of n - 1 integer numbers p2, p3, ..., pn (1 β€ pi < i), where pi is number of inflorescence into which the apple from i-th inflorescence rolls down.
Output
Single line of output should contain one integer number: amount of apples that Arcady will be able to collect from first inflorescence during one harvest.
Examples
Input
3
1 1
Output
1
Input
5
1 2 2 2
Output
3
Input
18
1 1 1 4 4 3 2 2 2 10 8 9 9 9 10 10 4
Output
4
Note
In first example Arcady will be able to collect only one apple, initially situated in 1st inflorescence. In next second apples from 2nd and 3rd inflorescences will roll down and annihilate, and Arcady won't be able to collect them.
In the second example Arcady will be able to collect 3 apples. First one is one initially situated in first inflorescence. In a second apple from 2nd inflorescence will roll down to 1st (Arcady will collect it) and apples from 3rd, 4th, 5th inflorescences will roll down to 2nd. Two of them will annihilate and one not annihilated will roll down from 2-nd inflorescence to 1st one in the next second and Arcady will collect it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
bool visited[100005];
bool lvl[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> p;
adj[p].push_back(i);
adj[i].push_back(p);
}
int maxl = 0;
queue<pair<int, int> > q;
q.push({1, 1});
visited[1] = true;
while (!q.empty()) {
int cur = q.front().first;
int l = q.front().second;
maxl = max(maxl, l);
lvl[l] = !lvl[l];
q.pop();
for (int y : adj[cur]) {
if (!visited[y]) {
q.push({y, l + 1});
visited[y] = true;
}
}
}
int ans = 0;
for (int i = 1; i <= maxl; i++)
if (lvl[i]) ans++;
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 β€ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n β the number of the Beaver's acquaintances.
The second line contains an integer k <image> β the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> β indices of people who form the i-th pair of friends.
The next line contains an integer m <image> β the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 β€ n β€ 14
The input limitations for getting 100 points are:
* 2 β€ n β€ 2000
Output
Output a single number β the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)(1e5 + 123);
vector<int> gg[MAXN], gb[MAXN];
bool was[MAXN], been[MAXN];
int cnt = 0;
void dfs(int v) {
cnt++;
was[v] = been[v] = true;
for (auto to : gg[v]) {
if (was[to]) continue;
dfs(to);
}
}
int main() {
int n;
cin >> n;
int good;
cin >> good;
for (int i = 1; i <= good; i++) {
int a, b;
cin >> a >> b;
gg[a].push_back(b);
gg[b].push_back(a);
}
int bad;
cin >> bad;
for (int i = 1; i <= bad; i++) {
int a, b;
cin >> a >> b;
gb[a].push_back(b);
gb[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (was[i]) continue;
cnt = 0;
dfs(i);
bool no = false;
for (int j = 1; j <= n; j++) {
if (been[j]) {
for (auto to : gb[j])
if (been[to]) {
no = true;
break;
}
}
if (no) break;
}
if (!no) ans = max(ans, cnt);
for (int j = 1; j <= n; j++) been[j] = false;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Vasya passes all exams! Despite expectations, Vasya is not tired, moreover, he is ready for new challenges. However, he does not want to work too hard on difficult problems.
Vasya remembered that he has a not-so-hard puzzle: m colored cubes are placed on a chessboard of size n Γ n. The fact is that m β€ n and all cubes have distinct colors. Each cube occupies exactly one cell. Also, there is a designated cell for each cube on the board, the puzzle is to place each cube on its place. The cubes are fragile, so in one operation you only can move one cube onto one of four neighboring by side cells, if only it is empty. Vasya wants to be careful, so each operation takes exactly one second.
Vasya used to train hard for VK Cup Final, so he can focus his attention on the puzzle for at most 3 hours, that is 10800 seconds. Help Vasya find such a sequence of operations that all cubes will be moved onto their designated places, and Vasya won't lose his attention.
Input
The first line contains two integers n and m (1 β€ m β€ n β€ 50).
Each of the next m lines contains two integers x_i, y_i (1 β€ x_i, y_i β€ n), the initial positions of the cubes.
The next m lines describe the designated places for the cubes in the same format and order.
It is guaranteed that all initial positions are distinct and all designated places are distinct, however, it is possible that some initial positions coincide with some final positions.
Output
In the first line print a single integer k (0 β€ k β€ 10800) β the number of operations Vasya should make.
In each of the next k lines you should describe one operation: print four integers x_1, y_1, x_2, y_2, where x_1, y_1 is the position of the cube Vasya should move, and x_2, y_2 is the new position of the cube. The cells x_1, y_1 and x_2, y_2 should have a common side, the cell x_2, y_2 should be empty before the operation.
We can show that there always exists at least one solution. If there are multiple solutions, print any of them.
Examples
Input
2 1
1 1
2 2
Output
2
1 1 1 2
1 2 2 2
Input
2 2
1 1
2 2
1 2
2 1
Output
2
2 2 2 1
1 1 1 2
Input
2 2
2 1
2 2
2 2
2 1
Output
4
2 1 1 1
2 2 2 1
1 1 1 2
1 2 2 2
Input
4 3
2 2
2 3
3 3
3 2
2 2
2 3
Output
9
2 2 1 2
1 2 1 1
2 3 2 2
3 3 2 3
2 2 1 2
1 1 2 1
2 1 3 1
3 1 3 2
1 2 2 2
Note
In the fourth example the printed sequence of movements (shown on the picture below) is valid, but not shortest. There is a solution in 3 operations.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
int n, m, x[N], y[N], dx[4] = {-1, +1, 0, 0}, dy[4] = {0, 0, -1, +1}, ex[N],
ey[N], col[N][N];
vector<pair<int, int>> o;
bool vld(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < n && !col[x][y];
}
void dir_move(int id, int i) {
assert(vld(x[id] + dx[i], y[id] + dy[i]));
o.push_back({x[id] + 1, y[id] + 1});
col[x[id]][y[id]] = 0;
x[id] += dx[i], y[id] += dy[i];
col[x[id]][y[id]] = id + 1;
o.push_back({x[id] + 1, y[id] + 1});
}
void Up(int id) { dir_move(id, 0); }
void Down(int id) { dir_move(id, 1); }
void Left(int id) { dir_move(id, 2); }
void Right(int id) { dir_move(id, 3); }
void swap_cube(int i, int j) {
if (i == j) return;
if (y[i] > y[j]) swap(i, j);
if (y[j] - y[i] == 1) {
Down(i), Left(j), Right(i), Up(i);
return;
}
Down(i), Down(i);
Down(j);
int t = y[j] - y[i];
for (int k = 0; k < t; k++) Left(j);
Up(j);
for (int k = 0; k < t; k++) Right(i);
Up(i), Up(i);
}
void print() {
cerr << "HI\n";
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < n; j++) cout << col[i][j] << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
--x[i], --y[i];
col[x[i]][y[i]] = i + 1;
}
for (int i = 0; i < m; i++) cin >> ex[i] >> ey[i], ex[i]--, ey[i]--;
vector<int> p(m);
iota(p.begin(), p.end(), 0);
sort(p.begin(), p.end(), [](int i, int j) {
return make_pair(x[i], y[j]) < make_pair(x[j], y[i]);
});
for (auto id : p) {
while (vld(x[id] - 1, y[id])) Up(id);
while (vld(x[id], y[id] + 1)) Right(id);
}
sort(p.begin(), p.end(), [](int i, int j) {
return make_pair(x[i], y[i]) < make_pair(x[j], y[j]);
});
for (auto id : p) {
while (vld(x[id] - 1, y[id])) Up(id);
while (vld(x[id], y[id] - 1)) Left(id);
}
for (int i = 0; i < m; i++) {
int bruh = i;
int id = col[0][bruh];
for (int i = bruh; i < m; i++)
if (col[0][i]) {
int u = col[0][i];
if (ey[u - 1] < ey[id - 1]) id = u;
}
swap_cube(col[0][i] - 1, id - 1);
}
sort(p.begin(), p.end(), [](int i, int j) {
return make_pair(-ex[i], ey[i]) < make_pair(-ex[j], ey[j]);
});
for (int i = 0; i < m; i++) {
int id = p[i];
while (x[id] != ex[id]) Down(id);
}
vector<int> pp(m);
iota(pp.begin(), pp.end(), 0);
sort(pp.begin(), pp.end(), [](int i, int j) {
return make_pair(x[i], y[i]) < make_pair(x[j], y[j]);
});
for (int i = 0; i < m; i++) {
int id = pp[i];
while (vld(x[id], y[id] - 1)) Left(id);
}
sort(p.begin(), p.end(), [](int i, int j) { return ey[i] > ey[j]; });
for (int i = 0; i < m; i++) {
int id = p[i];
while (y[id] < ey[id]) Right(id);
}
int sz = (int)(o.size());
cout << sz / 2 << '\n';
for (int i = 0; i < sz; i++) {
cout << o[i].first << ' ' << o[i].second << ' ';
if (i % 2 == 1) cout << '\n';
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
John Doe offered his sister Jane Doe find the gcd of some set of numbers a.
Gcd is a positive integer g, such that all number from the set are evenly divisible by g and there isn't such g' (g' > g), that all numbers of the set are evenly divisible by g'.
Unfortunately Jane couldn't cope with the task and John offered her to find the ghd of the same subset of numbers.
Ghd is a positive integer g, such that at least half of numbers from the set are evenly divisible by g and there isn't such g' (g' > g) that at least half of the numbers from the set are evenly divisible by g'.
Jane coped with the task for two hours. Please try it, too.
Input
The first line contains an integer n (1 β€ n β€ 106) showing how many numbers are in set a. The second line contains space-separated integers a1, a2, ..., an (1 β€ ai β€ 1012). Please note, that given set can contain equal numbers.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the %I64d specifier.
Output
Print a single integer g β the Ghd of set a.
Examples
Input
6
6 2 3 4 5 6
Output
3
Input
5
5 5 6 10 15
Output
5
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O500")
#pragma comment(linker, "/STACK:1677777216")
#pragma warning(default : 4)
using namespace std;
const double eps = 1e-12;
const int oo = 0x3F3F3F3F;
const long long ooLL = 0x3F3F3F3F3F3F3F3FLL;
const int MOD = 1000000007;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
void debpr(const T &);
template <typename T1, typename T2>
void debpr(const pair<T1, T2> &);
template <typename T1, typename T2>
void debpr(const vector<T1, T2> &);
template <typename T>
void debpr(const set<T> &);
template <typename T1, typename T2>
void debpr(const map<T1, T2> &);
template <typename T>
void prcont(T be, T en, const string &st, const string &fi, const string &mi) {
debpr(st);
bool ft = 0;
while (be != en) {
if (ft) debpr(mi);
ft = 1;
debpr(*be);
++be;
}
debpr(fi);
}
template <typename T>
void debpr(const T &a) {}
template <typename T1, typename T2>
void debpr(const pair<T1, T2> &p) {
debpr("(");
debpr(p.first);
debpr(", ");
debpr(p.second);
debpr(")");
}
template <typename T1, typename T2>
void debpr(const vector<T1, T2> &a) {
prcont(a.begin(), a.end(), "[", "]", ", ");
}
template <typename T>
void debpr(const set<T> &a) {
prcont(a.begin(), a.end(), "{", "}", ", ");
}
template <typename T1, typename T2>
void debpr(const map<T1, T2> &a) {
prcont(a.begin(), a.end(), "{", "}", ", ");
}
void deb(){};
template <typename T1>
void deb(const T1 &t1) {
debpr(t1);
debpr('\n');
}
template <typename T1, typename T2>
void deb(const T1 &t1, const T2 &t2) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr('\n');
}
template <typename T1, typename T2, typename T3>
void deb(const T1 &t1, const T2 &t2, const T3 &t3) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr(' ');
debpr(t3);
debpr('\n');
}
template <typename T1, typename T2, typename T3, typename T4>
void deb(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr(' ');
debpr(t3);
debpr(' ');
debpr(t4);
debpr('\n');
}
const double PI = acos(-1.);
long long Round(double x) { return x < 0 ? x - .5 : x + .5; }
template <typename T>
void ass(bool v, const T &x, string m = "Fail") {
if (!v) {
deb(m);
deb(x);
throw;
}
}
int main() {
void run();
run();
return 0;
}
long long a[1 << 20];
int n;
long long gcd(long long a, long long b) {
long long t;
while (a) b %= a, t = a, a = b, b = t;
return b;
}
long long mrand() {
long long rs = 0;
for (int i = (0), _b(60); i < _b; ++i)
if (rand() % 2) rs += 1LL << i;
return rs;
}
void run() {
scanf("%d", &n);
for (int i = (0), _b(n); i < _b; ++i) scanf("%lld", &a[i]);
long long rs = 1;
srand(3);
for (int it = (0), _b(12); it < _b; ++it) {
long long t = a[mrand() % n];
unordered_map<long long, int> m;
m.reserve(1 << 15);
for (int i = (0), _b(n); i < _b; ++i) ++m[gcd(a[i], t)];
vector<pair<long long, long long> > v((m).begin(), (m).end());
for (int i = (0), _b(v.size()); i < _b; ++i) {
int z = 0;
for (int j = (0), _b(v.size()); j < _b; ++j)
if (v[j].first % v[i].first == 0) z += v[j].second;
if (z >= (n + 1) / 2) rs = max(rs, v[i].first);
}
}
cout << rs << endl;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
bool b[10] {0};
for(int i = 0; i < 4; i++){
int n;
cin >> n;
b[n] = true;
}
if(b[1] && b[9] && b[7] && b[4]) cout << "YES" << endl;
else cout << "NO" << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class UnionFind {
public:
explicit UnionFind(int N) : root(N, -1), size(N, 1), edge(N, 0) {}
int getRoot(int u){ return root[u] == -1 ? u : root[u] = getRoot(root[u]); }
int getSize(int u){ return size[getRoot(u)]; }
int same(int a, int b){
return getRoot(a) == getRoot(b);
}
bool merge(int a, int b){
int u = getRoot(a);
int v = getRoot(b);
if(u != v){
if(edge[u] + edge[v] + 1 > size[u] + size[v]) return false;
root[u] = v;
size[v] += size[u];
edge[v] += edge[u] + 1;
} else {
if(edge[u] + 1 > size[u]) return false;
edge[u]++;
}
return true;
}
private:
vector<int> root;
vector<int> size;
vector<int> edge;
};
int main(){
int N, H, W;
while(cin >> N >> H >> W){
UnionFind uf(H+W);
long long res = 0;
vector<pair<int, pair<int, int>>> vp;
for(int i=0;i<N;i++){
int r, c, a; cin >> r >> c >> a;
vp.emplace_back(a, make_pair(r-1, c-1+H));
}
sort(vp.rbegin(), vp.rend());
for(auto& p : vp){
if(uf.merge(p.second.first, p.second.second)){
res += p.first;
}
}
cout << res << endl;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Oleg the bank client lives in Bankopolia. There are n cities in Bankopolia and some pair of cities are connected directly by bi-directional roads. The cities are numbered from 1 to n. There are a total of m roads in Bankopolia, the i-th road connects cities ui and vi. It is guaranteed that from each city it is possible to travel to any other city using some of the roads.
Oleg wants to give a label to each city. Suppose the label of city i is equal to xi. Then, it must hold that for all pairs of cities (u, v) the condition |xu - xv| β€ 1 holds if and only if there is a road connecting u and v.
Oleg wonders if such a labeling is possible. Find an example of such labeling if the task is possible and state that it is impossible otherwise.
Input
The first line of input contains two space-separated integers n and m (2 β€ n β€ 3Β·105, 1 β€ m β€ 3Β·105) β the number of cities and the number of roads.
Next, m lines follow. The i-th line contains two space-separated integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β the cities connected by the i-th road. It is guaranteed that there is at most one road between each pair of cities and it is possible to travel from any city to any other city using some roads.
Output
If the required labeling is not possible, output a single line containing the string "NO" (without quotes).
Otherwise, output the string "YES" (without quotes) on the first line. On the next line, output n space-separated integers, x1, x2, ..., xn. The condition 1 β€ xi β€ 109 must hold for all i, and for all pairs of cities (u, v) the condition |xu - xv| β€ 1 must hold if and only if there is a road connecting u and v.
Examples
Input
4 4
1 2
1 3
1 4
3 4
Output
YES
2 3 1 1
Input
5 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
5 4
Output
YES
1 1 1 1 1
Input
4 3
1 2
1 3
1 4
Output
NO
Note
For the first sample, x1 = 2, x2 = 3, x3 = x4 = 1 is a valid labeling. Indeed, (3, 4), (1, 2), (1, 3), (1, 4) are the only pairs of cities with difference of labels not greater than 1, and these are precisely the roads of Bankopolia.
For the second sample, all pairs of cities have difference of labels not greater than 1 and all pairs of cities have a road connecting them.
For the last sample, it is impossible to construct a labeling satisfying the given constraints.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 301000;
long long myrand() {
return ((long long)rand() << 48) + ((long long)rand << 32) +
((long long)rand() << 16) + rand();
}
set<int> e[N];
int n, m, u, v, id[N], f[N], dep[N], t;
pair<int, int> E[N];
map<long long, int> hs;
long long lev[N], d[N];
void dfs(int u, int f, int d) {
dep[u] = d;
for (auto v : e[u])
if (v != f) {
dfs(v, u, d + 1);
}
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
srand(time(0));
scanf("%d%d", &n, &m);
lev[0] = 1;
for (int i = 1; i < n + 1; i++) lev[i] = lev[i - 1] * 111;
for (int i = 1; i < n + 1; i++) d[i] = lev[i];
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
E[i] = make_pair(u, v);
d[u] += lev[v];
d[v] += lev[u];
}
for (int i = 1; i < n + 1; i++) {
if (!hs.count(d[i])) hs[d[i]] = t++;
id[i] = hs[d[i]];
}
for (int i = 0; i < t; i++) f[i] = i;
for (int i = 0; i < m; i++) {
u = id[E[i].first], v = id[E[i].second];
if (u == v) continue;
if (e[u].count(v) || e[v].count(u)) continue;
if (find(u) == find(v)) {
puts("NO");
return 0;
}
f[find(u)] = find(v);
e[u].insert(v);
e[v].insert(u);
}
for (int i = 0; i < t; i++)
if (((int)(e[i]).size()) > 2) {
puts("NO");
return 0;
}
for (int i = 0; i < t; i++)
if (((int)(e[i]).size()) < 2) {
dfs(i, -1, 1);
puts("YES");
for (int j = 1; j < n + 1; j++) printf("%d ", dep[id[j]]);
puts("");
return 0;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Dima and Inna love spending time together. The problem is, Seryozha isn't too enthusiastic to leave his room for some reason. But Dima and Inna love each other so much that they decided to get criminal...
Dima constructed a trap graph. He shouted: "Hey Seryozha, have a look at my cool graph!" to get his roommate interested and kicked him into the first node.
A trap graph is an undirected graph consisting of n nodes and m edges. For edge number k, Dima denoted a range of integers from lk to rk (lk β€ rk). In order to get out of the trap graph, Seryozha initially (before starting his movements) should pick some integer (let's call it x), then Seryozha must go some way from the starting node with number 1 to the final node with number n. At that, Seryozha can go along edge k only if lk β€ x β€ rk.
Seryozha is a mathematician. He defined the loyalty of some path from the 1-st node to the n-th one as the number of integers x, such that if he initially chooses one of them, he passes the whole path. Help Seryozha find the path of maximum loyalty and return to his room as quickly as possible!
Input
The first line of the input contains two integers n and m (2 β€ n β€ 103, 0 β€ m β€ 3Β·103). Then follow m lines describing the edges. Each line contains four integers ak, bk, lk and rk (1 β€ ak, bk β€ n, 1 β€ lk β€ rk β€ 106). The numbers mean that in the trap graph the k-th edge connects nodes ak and bk, this edge corresponds to the range of integers from lk to rk.
Note that the given graph can have loops and multiple edges.
Output
In a single line of the output print an integer β the maximum loyalty among all paths from the first node to the n-th one. If such paths do not exist or the maximum loyalty equals 0, print in a single line "Nice work, Dima!" without the quotes.
Examples
Input
4 4
1 2 1 10
2 4 3 5
1 3 1 5
2 4 2 7
Output
6
Input
5 6
1 2 1 10
2 5 11 20
1 4 2 5
1 3 10 11
3 4 12 10000
4 5 6 6
Output
Nice work, Dima!
Note
Explanation of the first example.
Overall, we have 2 ways to get from node 1 to node 4: first you must go along the edge 1-2 with range [1-10], then along one of the two edges 2-4.
One of them contains range [3-5], that is, we can pass through with numbers 3, 4, 5. So the loyalty of such path is 3.
If we go along edge 2-4 with range [2-7], then we can pass through with numbers 2, 3, 4, 5, 6, 7. The loyalty is 6. That is the answer.
The edge 1-2 have no influence on the answer because its range includes both ranges of the following edges.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void Read(T& x) {
int f = 1;
char t = getchar();
while (t < '0' || t > '9') {
if (t == '-') f = -1;
t = getchar();
}
x = 0;
while (t >= '0' && t <= '9') {
x = x * 10 + t - '0';
t = getchar();
}
x *= f;
}
const int maxn = 1005;
const int maxm = 6005;
const int inf = 0x3f3f3f3f;
int fa[maxn];
int find(int x) {
if (fa[x] == x)
return x;
else
return fa[x] = find(fa[x]);
}
void merge(int x, int y) {
int t1 = find(x), t2 = find(y);
if (t1 != t2) fa[t1] = t2;
}
struct edge {
int u, v, l, r;
void read() {
Read(u);
Read(v);
Read(l);
Read(r);
}
bool operator<(const edge& rhs) const { return r < rhs.r; }
};
int n, m;
int ans = 0, ansl = 0, ansr = 0;
edge e[maxm];
void input() {
int x, y, ll, rr;
Read(n);
Read(m);
for (register int i = 1; i <= m; i++) {
e[i].read();
}
sort(e + 1, e + m + 1);
}
int calc(int l) {
for (register int i = 1; i <= n; i++) fa[i] = i;
for (register int i = m; i >= 1; i--) {
if (e[i].r < l || e[i].l > l) continue;
if (find(e[i].u) == find(e[i].v)) continue;
merge(e[i].u, e[i].v);
if (find(1) == find(n)) return e[i].r;
}
return 0;
}
void solve() {
int ln, rn;
for (register int i = 1; i <= m; i++) {
ln = e[i].l;
rn = calc(ln);
if (rn - ln + 1 > ans) {
ans = rn - ln + 1;
ansl = ln, ansr = rn;
} else if (rn - ln + 1 == ans && ln < ansl) {
ansl = ln, ansr = rn;
}
}
if (ans == 0) {
printf("Nice work, Dima!\n");
} else {
printf("%d\n", ans);
}
}
int main() {
input();
solve();
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a tree (an undirected connected acyclic graph) consisting of n vertices. You are playing a game on this tree.
Initially all vertices are white. On the first turn of the game you choose one vertex and paint it black. Then on each turn you choose a white vertex adjacent (connected by an edge) to any black vertex and paint it black.
Each time when you choose a vertex (even during the first turn), you gain the number of points equal to the size of the connected component consisting only of white vertices that contains the chosen vertex. The game ends when all vertices are painted black.
Let's see the following example:
<image>
Vertices 1 and 4 are painted black already. If you choose the vertex 2, you will gain 4 points for the connected component consisting of vertices 2, 3, 5 and 6. If you choose the vertex 9, you will gain 3 points for the connected component consisting of vertices 7, 8 and 9.
Your task is to maximize the number of points you gain.
Input
The first line contains an integer n β the number of vertices in the tree (2 β€ n β€ 2 β
10^5).
Each of the next n - 1 lines describes an edge of the tree. Edge i is denoted by two integers u_i and v_i, the indices of vertices it connects (1 β€ u_i, v_i β€ n, u_i β v_i).
It is guaranteed that the given edges form a tree.
Output
Print one integer β the maximum number of points you gain if you will play optimally.
Examples
Input
9
1 2
2 3
2 5
2 6
1 4
4 9
9 7
9 8
Output
36
Input
5
1 2
1 3
2 4
2 5
Output
14
Note
The first example tree is shown in the problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int N = 200010;
long long int n, res;
vector<long long int> g[N];
long long int sz[N], dp[N];
void dfs(long long int u, long long int p = -1) {
sz[u] = 1;
for (long long int v : g[u]) {
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
dp[u] += dp[v];
}
}
dp[u] += sz[u];
}
void dfs1(long long int u, long long int p = -1) {
res = max(res, dp[u]);
for (long long int v : g[u]) {
if (v == p) continue;
dp[u] -= dp[v];
dp[u] -= sz[v];
sz[u] -= sz[v];
sz[v] += sz[u];
dp[v] += dp[u];
dp[v] += sz[u];
dfs1(v, u);
dp[v] -= sz[u];
dp[v] -= dp[u];
sz[v] -= sz[u];
sz[u] += sz[v];
dp[u] += sz[v];
dp[u] += dp[v];
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long int i = 0; i < n - 1; ++i) {
long long int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
dfs1(1);
cout << res << '\n';
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The GCD table G of size n Γ n for an array of positive integers a of length n is defined by formula
<image>
Let us remind you that the greatest common divisor (GCD) of two positive integers x and y is the greatest integer that is divisor of both x and y, it is denoted as <image>. For example, for array a = {4, 3, 6, 2} of length 4 the GCD table will look as follows:
<image>
Given all the numbers of the GCD table G, restore array a.
Input
The first line contains number n (1 β€ n β€ 500) β the length of array a. The second line contains n2 space-separated numbers β the elements of the GCD table of G for array a.
All the numbers in the table are positive integers, not exceeding 109. Note that the elements are given in an arbitrary order. It is guaranteed that the set of the input data corresponds to some array a.
Output
In the single line print n positive integers β the elements of array a. If there are multiple possible solutions, you are allowed to print any of them.
Examples
Input
4
2 1 2 3 4 3 2 6 1 1 2 2 1 2 3 2
Output
4 3 6 2
Input
1
42
Output
42
Input
2
1 1 1 1
Output
1 1
### Response
```cpp
#include <bits/stdc++.h>
const double eps = 1e-10;
const float epsf = 1e-6;
using namespace std;
inline int compfloat(float& x, float& y) {
if (fabs(x - y) < epsf)
return 0;
else if (x - y > 0)
return 1;
return -1;
}
inline int compdouble(double x, double y) {
if (fabs(x - y) < eps)
return 0;
else if (x - y > 0)
return 1;
else
return -1;
}
bool prime(long long int k) {
for (long long int i = 2; i * i <= k; i++)
if (k % i == 0) {
return false;
}
return true;
}
void pdash(int n = 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
cout << "-";
}
cout << "\n";
}
}
long long int power(long long int x, long long int y) {
long long int result = 1;
while (y > 0) {
if (y & 1) {
result = (result * x);
}
y = y >> 1;
x = (x * x);
}
return result;
}
long long int power(long long int x, long long int y, long long int z) {
long long int result = 1;
x = x % z;
while (y > 0) {
if (y & 1) {
result = (result * x) % z;
}
y = y >> 1;
x = (x * x) % z;
}
return result;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrF(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int f[n + 1];
f[0] = 1;
for (long long int i = 1; i <= n; i++) f[i] = f[i - 1] * i % p;
return (f[n] * modInverse(f[r], p) % p * modInverse(f[n - r], p) % p) % p;
}
inline int __gcd(int a, int b) {
if (a == 0 || b == 0) {
return max(a, b);
}
int tempa, tempb;
while (1) {
if (a % b == 0)
return b;
else {
tempa = a;
tempb = b;
a = tempb;
b = tempa % tempb;
}
}
}
void solve() {
int n;
cin >> n;
;
int a[n * n];
for (int i = 0; i < n * n; i++) cin >> a[i];
multiset<int> st(a, a + (n * n));
vector<int> vec;
while (!st.empty()) {
int p = *st.rbegin();
st.erase(st.find(p));
for (auto& j : vec) {
st.erase(st.find(__gcd(j, p)));
st.erase(st.find(__gcd(j, p)));
}
vec.push_back(p);
}
for (auto& j : vec) {
cout << j << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Koto Municipal Subway
Koto Municipal Subway
Koto City is a famous city whose roads are in a grid pattern, as shown in the figure below. The roads extending from north to south and the roads extending from east to west are lined up at intervals of 1 km each. Let Koto station at the southwestern intersection of Koto city be (0, 0), and mark x km east and y km north from it as (x, y) (0 β€ x, y). ).
<image>
In anticipation of an increase in tourists due to the Olympic Games to be held five years later, the city has decided to build a new subway line starting from Koto station. Currently, we are planning to lay a rail to Shin-Koto station, which will be newly constructed as the next station after Koto station. The rail will be laid straight from Koto station to Shin-Koto station. Therefore, when the location of Shin-Koto station is (x, y), the length of the rail is β (x2 + y2). The cost of laying the rail is the same as the length of the laid rail. Even if the rail length is a decimal number such as 1.5km, the cost is also 1.5.
The location (x, y) of Shin-Koto station has not been decided yet, and we plan to make it a location that meets the following conditions.
* It is an intersection. That is, x and y are integers, respectively.
* The shortest distance walked along the road from Koto station is exactly D. That is, x + y = D is satisfied.
Among the above two conditions, select the location of Shin-Koto station so that the difference between the rail budget E and the rail cost set by the city | β (x2 + y2) --E | is minimized. Here, | A | represents the absolute value of A. Your job is to create a program that outputs the difference between the cost and budget for laying rails when the Shin-Koto station was constructed as described above.
Input
The input consists of multiple data sets, and the number of data sets contained in one input is 100 or less. The format of each data set is as follows.
> D E
D (1 β€ D β€ 100) is an integer that represents the shortest distance when walking along the road from Koto station to Shin-Koto station. E (1 β€ E β€ 100) is an integer representing the budget for rail construction.
The end of the input is indicated by a line of two zeros separated by a blank.
Output
For each data set, output the difference between the cost and budget when laying the rail so as to satisfy the problem condition in one line. The answer must have an absolute error greater than 10-3. Note that if you do not output a line break at the end of each line, or if you output unnecessary characters, it will be judged as an incorrect answer.
Sample Input
twenty one
7 5
7 6
7 7
76 5
8 41
0 0
Output for Sample Input
0.4142135624
0
0.0827625303
0
48.7401153702
33
Hint
In the first data set, as shown in the figure below, an intersection 2 km along the road from Koto station is a candidate for a place to build Shin-Koto station.
<image>
When Shin-Koto station is constructed at each intersection, the difference between the cost for laying the rail and budget 1 is as follows.
* (2, 0): | β (22 + 02) --1 | = 1.0
* (1, 1): | β (12 + 12) --1 | = 0.4142135623 ...
* (0, 2): | β (02 + 22) --1 | = 1.0
Therefore, the difference between the cost and the budget is minimized when the construction is done in (1, 1).
Example
Input
2 1
7 5
7 6
7 7
76 5
8 41
0 0
Output
0.4142135624
0
0.0827625303
0
48.7401153702
33
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
int main() {
int d, e;
while (cin >> d >> e and (d or e)) {
double ans = 1e8;
for (int y=0; y<=100; ++y) {
for (int x=0; x<=100; ++x) {
if (x+y == d) {
ans = min(abs(sqrt((x*x)+(y*y))-e), ans);
}
}
}
printf("%.10f\n", ans);
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Ievan Ritola is a researcher of behavioral ecology. Her group visited a forest to analyze an ecological system of some kinds of foxes.
The forest can be expressed as a two-dimensional plane. With her previous research, foxes in the forest are known to live at lattice points. Here, lattice points are the points whose x and y coordinates are both integers. Two or more foxes might live at the same point.
To observe the biology of these foxes, they decided to put a pair of sensors in the forest. The sensors can be put at lattice points. Then, they will be able to observe all foxes inside the bounding rectangle (including the boundary) where the sensors are catty-corner to each other. The sensors cannot be placed at the points that have the same x or y coordinate; in other words the rectangle must have non-zero area.
The more foxes can be observed, the more data can be collected; on the other hand, monitoring a large area consumes a large amount of energy. So they want to maximize the value given by N' / (|x_1 β x_2| Γ |y_1 β y_2|), where N' is the number of foxes observed and (x_1, y_1) and (x_2, y_2) are the positions of the two sensors.
Let's help her observe cute foxes!
Input
The input is formatted as follows.
N
x_1 y_1 w_1
x_2 y_2 w_2
:
:
x_N y_N w_N
The first line contains a single integer N (1 β€ N β€ 10^5) indicating the number of the fox lairs in the forest. Each of the next N lines contains three integers x_i, y_i (|x_i|,\, |y_i| β€ 10^9) and w_i (1 β€ w_i β€ 10^4), which represent there are w_i foxes at the point (x_i, y_i). It is guaranteed that all points are mutually different.
Output
Output the maximized value as a fraction:
a / b
where a and b are integers representing the numerator and the denominato respectively. There should be exactly one space before and after the slash. The fraction should be written in the simplest form, that is, a and b must not have a common integer divisor greater than one.
If the value becomes an integer, print a fraction with the denominator of one (e.g. `5 / 1` to represent 5). This implies zero should be printed as `0 / 1` (without quotes).
Sample Input 1
2
1 1 2
2 2 3
Output for the Sample Input 1
5 / 1
Example
Input
2
1 1 2
2 2 3
Output
5 / 1
### Response
```cpp
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
map<pair<int,int>,int> m;
int x[110000];
int y[110000];
vector<pair<int,int> >v;
int dx[]={0,1,0,1};
int dy[]={0,0,1,1};
int main(){
int a;
scanf("%d",&a);
for(int i=0;i<a;i++){
int z;
scanf("%d%d%d",x+i,y+i,&z);
m[make_pair(x[i],y[i])]=z;
v.push_back(make_pair(x[i],y[i]));
v.push_back(make_pair(x[i]-1,y[i]));
v.push_back(make_pair(x[i],y[i]-1));
v.push_back(make_pair(x[i]-1,y[i]-1));
}
int ret=0;
for(int i=0;i<v.size();i++){
int X=v[i].first;
int Y=v[i].second;
int val=0;
for(int j=0;j<4;j++){
if(m.count(make_pair(X+dx[j],Y+dy[j])))val+=m[make_pair(X+dx[j],Y+dy[j])];
}
ret=max(ret,val);
}
printf("%d / 1\n",ret);
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Fox Ciel wants to write a task for a programming contest. The task is: "You are given a simple undirected graph with n vertexes. Each its edge has unit length. You should calculate the number of shortest paths between vertex 1 and vertex 2."
Same with some writers, she wants to make an example with some certain output: for example, her birthday or the number of her boyfriend. Can you help her to make a test case with answer equal exactly to k?
Input
The first line contains a single integer k (1 β€ k β€ 109).
Output
You should output a graph G with n vertexes (2 β€ n β€ 1000). There must be exactly k shortest paths between vertex 1 and vertex 2 of the graph.
The first line must contain an integer n. Then adjacency matrix G with n rows and n columns must follow. Each element of the matrix must be 'N' or 'Y'. If Gij is 'Y', then graph G has a edge connecting vertex i and vertex j. Consider the graph vertexes are numbered from 1 to n.
The graph must be undirected and simple: Gii = 'N' and Gij = Gji must hold. And there must be at least one path between vertex 1 and vertex 2. It's guaranteed that the answer exists. If there multiple correct answers, you can output any of them.
Examples
Input
2
Output
4
NNYY
NNYY
YYNN
YYNN
Input
9
Output
8
NNYYYNNN
NNNNNYYY
YNNNNYYY
YNNNNYYY
YNNNNYYY
NYYYYNNN
NYYYYNNN
NYYYYNNN
Input
1
Output
2
NY
YN
Note
In first example, there are 2 shortest paths: 1-3-2 and 1-4-2.
In second example, there are 9 shortest paths: 1-3-6-2, 1-3-7-2, 1-3-8-2, 1-4-6-2, 1-4-7-2, 1-4-8-2, 1-5-6-2, 1-5-7-2, 1-5-8-2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int some, point = 2, tmp, st, en = 1;
char ans[1005][1005];
int main() {
for (register int i = 0; i <= 1000; i++) {
for (register int j = 0; j <= 1000; j++) {
ans[i][j] = 'N';
}
}
scanf("%d", &some);
for (register int i = 1; i <= some; i *= 2) {
tmp = point;
for (register int j = st; j < en; j++) {
ans[j][point] = 'Y';
ans[point][j] = 'Y';
point++;
}
for (register int j = st; j < en; j++) {
ans[j][point] = 'Y';
ans[point][j] = 'Y';
}
point++;
st = tmp;
en = point;
}
for (register int i = st + 1; i < en; i++) {
if (((1 << (i - st - 1)) & some) != 0) {
ans[i][1] = 'Y';
ans[1][i] = 'Y';
}
}
printf("%d\n", point);
for (register int i = 0; i < point; i++) {
for (register int j = 0; j < point; j++) {
printf("%c", ans[i][j]);
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Vanya got bored and he painted n distinct points on the plane. After that he connected all the points pairwise and saw that as a result many triangles were formed with vertices in the painted points. He asks you to count the number of the formed triangles with the non-zero area.
Input
The first line contains integer n (1 β€ n β€ 2000) β the number of the points painted on the plane.
Next n lines contain two integers each xi, yi ( - 100 β€ xi, yi β€ 100) β the coordinates of the i-th point. It is guaranteed that no two given points coincide.
Output
In the first line print an integer β the number of triangles with the non-zero area among the painted points.
Examples
Input
4
0 0
1 1
2 0
2 2
Output
3
Input
3
0 0
1 1
2 0
Output
1
Input
1
1 1
Output
0
Note
Note to the first sample test. There are 3 triangles formed: (0, 0) - (1, 1) - (2, 0); (0, 0) - (2, 2) - (2, 0); (1, 1) - (2, 2) - (2, 0).
Note to the second sample test. There is 1 triangle formed: (0, 0) - (1, 1) - (2, 0).
Note to the third sample test. A single point doesn't form a single triangle.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
int x[2010], y[2010];
cin >> n;
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
int c = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int k = j + 1; k < n; ++k) {
c += abs(x[i] * (y[j] - y[k]) + x[j] * (y[k] - y[i]) +
x[k] * (y[i] - y[j])) != 0;
}
}
}
cout << c;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A magic island Geraldion, where Gerald lives, has its own currency system. It uses banknotes of several values. But the problem is, the system is not perfect and sometimes it happens that Geraldionians cannot express a certain sum of money with any set of banknotes. Of course, they can use any number of banknotes of each value. Such sum is called unfortunate. Gerald wondered: what is the minimum unfortunate sum?
Input
The first line contains number n (1 β€ n β€ 1000) β the number of values of the banknotes that used in Geraldion.
The second line contains n distinct space-separated numbers a1, a2, ..., an (1 β€ ai β€ 106) β the values of the banknotes.
Output
Print a single line β the minimum unfortunate sum. If there are no unfortunate sums, print - 1.
Examples
Input
5
1 2 3 4 5
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
for (int i = 2; (i * i) <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
int nerPr(int n) {
for (int i = n;; i++) {
if (isPrime(i)) return i;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a;
int mn = (int)1e9;
for (int i = 0; i < n; i++) {
int d;
cin >> d;
a.push_back(d);
mn = min(mn, d);
if (d == 1) {
cout << "-1\n";
exit(0);
}
}
cout << 1;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
We have a sequence of N integers: A_1, A_2, \cdots, A_N.
You can perform the following operation between 0 and K times (inclusive):
* Choose two integers i and j such that i \neq j, each between 1 and N (inclusive). Add 1 to A_i and -1 to A_j, possibly producing a negative element.
Compute the maximum possible positive integer that divides every element of A after the operations. Here a positive integer x divides an integer y if and only if there exists an integer z such that y = xz.
Constraints
* 2 \leq N \leq 500
* 1 \leq A_i \leq 10^6
* 0 \leq K \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \cdots A_{N-1} A_{N}
Output
Print the maximum possible positive integer that divides every element of A after the operations.
Examples
Input
2 3
8 20
Output
7
Input
2 10
3 5
Output
8
Input
4 5
10 1 2 22
Output
7
Input
8 7
1 7 5 6 8 2 6 5
Output
5
### Response
```cpp
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int N,A[500],K;
int main()
{
cin>>N>>K;
int sum=0;
for(int i=0;i<N;i++)
{
cin>>A[i];
sum+=A[i];
}
vector<int>X;
for(int i=1;i*i<=sum;i++)
{
if(sum%i==0)
{
X.push_back(i);
if(sum/i!=i)X.push_back(sum/i);
}
}
int ans=1;
for(int x:X)
{
vector<int>B(N);
for(int i=0;i<N;i++)B[i]=A[i]%x;
sort(B.begin(),B.end());
int T=0;
for(int i=0;i<N;i++)
{
if(T+B[i]<=K)
{
T+=B[i];
B[i]=0;
}
}
for(int i=0;i<N;i++)
{
if(B[i]>0)
{
if(B[i]+T>=x)
{
T-=x-B[i];
B[i]=0;
}
}
}
bool flag=true;
for(int i=0;i<N;i++)flag&=B[i]==0;
if(flag)ans=max(ans,x);
}
cout<<ans<<endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Once upon a time in the Kingdom of Far Far Away lived Sam the Farmer. Sam had a cow named Dawn and he was deeply attached to her. Sam would spend the whole summer stocking hay to feed Dawn in winter. Sam scythed hay and put it into haystack. As Sam was a bright farmer, he tried to make the process of storing hay simpler and more convenient to use. He collected the hay into cubical hay blocks of the same size. Then he stored the blocks in his barn. After a summer spent in hard toil Sam stored AΒ·BΒ·C hay blocks and stored them in a barn as a rectangular parallelepiped A layers high. Each layer had B rows and each row had C blocks.
At the end of the autumn Sam came into the barn to admire one more time the hay he'd been stacking during this hard summer. Unfortunately, Sam was horrified to see that the hay blocks had been carelessly scattered around the barn. The place was a complete mess. As it turned out, thieves had sneaked into the barn. They completely dissembled and took away a layer of blocks from the parallelepiped's front, back, top and sides. As a result, the barn only had a parallelepiped containing (A - 1) Γ (B - 2) Γ (C - 2) hay blocks. To hide the evidence of the crime, the thieves had dissembled the parallelepiped into single 1 Γ 1 Γ 1 blocks and scattered them around the barn. After the theft Sam counted n hay blocks in the barn but he forgot numbers A, B ΠΈ C.
Given number n, find the minimally possible and maximally possible number of stolen hay blocks.
Input
The only line contains integer n from the problem's statement (1 β€ n β€ 109).
Output
Print space-separated minimum and maximum number of hay blocks that could have been stolen by the thieves.
Note that the answer to the problem can be large enough, so you must use the 64-bit integer type for calculations. Please, do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specificator.
Examples
Input
4
Output
28 41
Input
7
Output
47 65
Input
12
Output
48 105
Note
Let's consider the first sample test. If initially Sam has a parallelepiped consisting of 32 = 2 Γ 4 Γ 4 hay blocks in his barn, then after the theft the barn has 4 = (2 - 1) Γ (4 - 2) Γ (4 - 2) hay blocks left. Thus, the thieves could have stolen 32 - 4 = 28 hay blocks. If Sam initially had a parallelepiped consisting of 45 = 5 Γ 3 Γ 3 hay blocks in his barn, then after the theft the barn has 4 = (5 - 1) Γ (3 - 2) Γ (3 - 2) hay blocks left. Thus, the thieves could have stolen 45 - 4 = 41 hay blocks. No other variants of the blocks' initial arrangement (that leave Sam with exactly 4 blocks after the theft) can permit the thieves to steal less than 28 or more than 41 blocks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
long long k = ceil(sqrt(n));
for (long long i = k; i; i--) {
if (n % i == 0) {
return i;
}
}
}
long long e(long long n) {
long long k = ceil(cbrt(n)), mn = 1e12, x, x1;
for (long long i = k; i; i--) {
if (n % i == 0) {
x = f(n / i);
x1 = n / (i * x);
mn = min(mn, (i + 1) * (x + 2) * (x1 + 2));
}
}
return mn - n;
}
int main() {
long long n, s;
cin >> n;
cout << e(n) << " ";
cout << (n + 1) * 3 * 3 - n;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Peter had a cube with non-zero length of a side. He put the cube into three-dimensional space in such a way that its vertices lay at integer points (it is possible that the cube's sides are not parallel to the coordinate axes). Then he took a piece of paper and wrote down eight lines, each containing three integers β coordinates of cube's vertex (a single line contains coordinates of a single vertex, each vertex is written exactly once), put the paper on the table and left. While Peter was away, his little brother Nick decided to play with the numbers on the paper. In one operation Nick could swap some numbers inside a single line (Nick didn't swap numbers from distinct lines). Nick could have performed any number of such operations.
When Peter returned and found out about Nick's mischief, he started recollecting the original coordinates. Help Peter restore the original position of the points or else state that this is impossible and the numbers were initially recorded incorrectly.
Input
Each of the eight lines contains three space-separated integers β the numbers written on the piece of paper after Nick's mischief. All numbers do not exceed 106 in their absolute value.
Output
If there is a way to restore the cube, then print in the first line "YES". In each of the next eight lines print three integers β the restored coordinates of the points. The numbers in the i-th output line must be a permutation of the numbers in i-th input line. The numbers should represent the vertices of a cube with non-zero length of a side. If there are multiple possible ways, print any of them.
If there is no valid way, print "NO" (without the quotes) in the first line. Do not print anything else.
Examples
Input
0 0 0
0 0 1
0 0 1
0 0 1
0 1 1
0 1 1
0 1 1
1 1 1
Output
YES
0 0 0
0 0 1
0 1 0
1 0 0
0 1 1
1 0 1
1 1 0
1 1 1
Input
0 0 0
0 0 0
0 0 0
0 0 0
1 1 1
1 1 1
1 1 1
1 1 1
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct dot {
int x, y, z;
} A[10], P[10];
const int n = 8;
int B[10][3], cnt = 0, m;
long long len = 0;
int C[6][3] = {{1, 2, 3}, {1, 3, 2}, {2, 1, 3},
{2, 3, 1}, {3, 1, 2}, {3, 2, 1}};
long long sqr(long long x) { return x * x; }
dot operator-(dot p, dot q) { return (dot){p.x - q.x, p.y - q.y, p.z - q.z}; }
long long dis(dot p, dot q) {
return sqr(p.x - q.x) + sqr(p.y - q.y) + sqr(p.z - q.z);
}
long long dj(dot p, dot q) {
return 1LL * p.x * q.x + 1LL * p.y * q.y + 1LL * p.z * q.z;
}
bool check() {
int i, j;
len = 1LL * (1 << 30) * (1 << 30);
for (i = 1; i <= n; i++) {
A[i].x = B[i][0];
A[i].y = B[i][1];
A[i].z = B[i][2];
}
for (i = 1; i <= n; i++)
for (j = i + 1; j <= n; j++) len = min(len, dis(A[i], A[j]));
if (!len) return false;
for (i = 1; i <= n; i++) {
cnt = 0, m = 0;
for (j = 1; j <= n; j++)
if (i != j && dis(A[i], A[j]) == len) cnt++, P[++m] = A[j] - A[i];
if (cnt != 3) return false;
if (dj(P[1], P[2]) != 0) return false;
if (dj(P[1], P[3]) != 0) return false;
if (dj(P[2], P[3]) != 0) return false;
}
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d %d %d\n", A[i].x, A[i].y, A[i].z);
exit(0);
return true;
}
void work(int t) {
int i, j, V[3];
if (t > n) {
check();
return;
}
for (i = 0; i < 3; i++) V[i] = B[t][i];
for (i = 0; i < 6; i++) {
for (j = 0; j < 3; j++) B[t][j] = V[C[i][j] - 1];
work(t + 1);
}
for (i = 0; i < 3; i++) B[t][i] = V[i];
}
int main() {
int i, j;
for (i = 1; i <= n; i++)
for (j = 0; j < 3; j++) scanf("%d", &B[i][j]);
work(1);
printf("NO");
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.